Add Character Creation and Webtoon Line Art Challenge features, and enhance API integration

app/clients/comfyui_client.py

@@ -90,3 +90,4 @@ class ComfyUIClient:
 
 
 
+

app/database.py

@@ -1155,4 +1155,3 @@ class WebtoonLineArtJob(db.Model):
             'created_at': self.created_at.isoformat() if self.created_at else None,
             'updated_at': self.updated_at.isoformat() if self.updated_at else None,
         }
-

app/gemini_client.py

@@ -343,99 +343,76 @@ class GeminiClient:
                             pass
                         
                         # REST API 베이스 URL (v1beta 우선 사용)
-                        rest_base_url = 'https://generativelanguage.googleapis.com/v1beta'
-                        url = f"{rest_base_url}/models/{model_name_clean}:generateContent"
+                        rest_base_urls = [
+                            'https://generativelanguage.googleapis.com/v1beta',
+                            'https://generativelanguage.googleapis.com/v1'
+                        ]
                         
-                        logger.info(f"[Gemini] - API 버전: v1beta (기본)")
-                        logger.info(f"[Gemini] - 원본 모델 이름: {model_name}")
-                        logger.info(f"[Gemini] - 정규화된 모델 이름: {model_name_clean}")
-                        logger.info(f"[Gemini] - 전체 URL: {url}")
+                        rest_response = None
+                        success = False
                         
-                        # REST API 요청 본문 구성
-                        request_body = {
-                            "contents": [{
-                                "parts": [{
-                                    "text": prompt
-                                }]
-                            }],
-                            "generationConfig": generation_config
-                        }
-                        
-                        # REST API 헤더 (API 키를 헤더로 전달 시도)
-                        headers = {
-                            "Content-Type": "application/json",
-                            "x-goog-api-key": api_key_clean
-                        }
-                        
-                        logger.info(f"[Gemini] REST API 호출 전송 중...")
-                        # ... 로깅 생략 ...
-                        
-                        # REST API 호출 (API 키를 헤더와 params 양쪽으로 전달 시도)
-                        api_params = {"key": api_key_clean}
-                        
-                        rest_response = requests.post(
-                            url,
-                            headers=headers,
-                            json=request_body,
-                            params=api_params,
-                            timeout=timeout_seconds
-                        )
-                        
-                        # ... (API 키 마스킹 로깅 등 기존 로직 유지) ...
-                        
-                        logger.info(f"[Gemini] REST API 응답 상태 코드: {rest_response.status_code}")
-                        
-                        # 응답 본문 확인
-                        response_has_error = False
-                        try:
-                            response_data_check = rest_response.json()
-                            if 'error' in response_data_check:
-                                response_has_error = True
-                                error_info = response_data_check['error']
-                                error_code = error_info.get('code', rest_response.status_code)
-                                error_message = error_info.get('message', '알 수 없는 오류')
-                                logger.error(f"[Gemini] 응답 본문에 에러 감지: code={error_code}, message={error_message}")
+                        for base_url in rest_base_urls:
+                            url = f"{base_url}/models/{model_name_clean}:generateContent"
+                            logger.info(f"[Gemini] - API 호출 시도: {url}")
+                            
+                            # REST API 요청 본문 구성
+                            request_body = {
+                                "contents": [{
+                                    "parts": [{
+                                        "text": prompt
+                                    }]
+                                }],
+                                "generationConfig": generation_config
+                            }
+                            
+                            # REST API 헤더
+                            headers = {
+                                "Content-Type": "application/json",
+                                "x-goog-api-key": api_key_clean
+                            }
+                            
+                            api_params = {"key": api_key_clean}
+                            
+                            try:
+                                rest_response = requests.post(
+                                    url,
+                                    headers=headers,
+                                    json=request_body,
+                                    params=api_params,
+                                    timeout=timeout_seconds
+                                )
                                 
-                                # 에러 코드에 따라 처리 (404 재시도, 429 에러 메시지 생성 등 기존 로직 유��)
-                                if error_code == 404:
-                                    # ... (404 처리 로직) ...
-                                    logger.warning(f"[Gemini] v1beta에서 모델을 찾을 수 없음, v1으로 재시도...")
-                                    rest_base_url_v1 = 'https://generativelanguage.googleapis.com/v1'
-                                    url_v1 = f"{rest_base_url_v1}/models/{model_name_clean}:generateContent"
-                                    
-                                    rest_response = requests.post(
-                                        url_v1,
-                                        headers=headers,
-                                        json=request_body,
-                                        params=api_params,
-                                        timeout=timeout_seconds
-                                    )
-                                    # ... (이후 v1 응답 처리 및 Fallback 로직은 너무 길어 생략하나 원본 유지 필요) ...
-                                    # 편의상 원본의 404/429 처리 로직은 동일하게 작동한다고 가정하고 축약하지 않음
-                                    # 실제 구현 시에는 원본 파일 내용을 그대로 복사해야 함.
-                                    # 여기서는 지면 관계상 핵심 로직만 변경하고 나머지는 ... 처리 하였으나
-                                    # 실제 write 시에는 전체 내용을 넣어야 함.
-                                    
-                                    # (중략된 404/429 처리 로직)
-                                    pass # 실제 코드에서는 원본 내용 포함
-                                elif error_code == 429:
-                                    # ... (429 처리 로직) ...
-                                    raise Exception(f"Gemini API 할당량 초과 (429): {error_message}")
+                                logger.info(f"[Gemini] REST API 응답 상태 코드 ({base_url}): {rest_response.status_code}")
+                                
+                                if rest_response.status_code == 200:
+                                    response_data = rest_response.json()
+                                    if 'error' not in response_data:
+                                        success = True
+                                        break
+                                    else:
+                                        logger.warning(f"[Gemini] API 응답에 에러 포함: {response_data['error']}")
+                                elif rest_response.status_code == 404:
+                                    logger.warning(f"[Gemini] 모델을 찾을 수 없음 (404): {url}")
+                                    continue
                                 else:
-                                    error_text = json.dumps(error_info)
-                                    raise Exception(f"REST API 오류 {error_code}: {error_text}")
-                        except ValueError:
-                            pass
-                        
-                        if rest_response.status_code != 200 and not response_has_error:
-                             # ... (에러 처리) ...
-                             raise Exception(f"REST API 오류 {rest_response.status_code}")
-
-                        if response_has_error:
-                             raise Exception(f"REST API 오류: 응답에 에러가 포함되어 있습니다.")
+                                    logger.warning(f"[Gemini] API 호출 실패 ({rest_response.status_code}): {rest_response.text[:200]}")
+                            except Exception as e:
+                                logger.error(f"[Gemini] REST API 호출 중 예외 발생: {e}")
+                                continue
+                                
+                        if not success:
+                            if rest_response is not None:
+                                try:
+                                    error_data = rest_response.json()
+                                    error_msg = error_data.get('error', {}).get('message', '알 수 없는 오류')
+                                    raise Exception(f"Gemini API 오류 ({rest_response.status_code}): {error_msg}")
+                                except:
+                                    raise Exception(f"Gemini API 오류 ({rest_response.status_code})")
+                            else:
+                                raise Exception("Gemini API 호출에 실패했습니다.")
 
                         response_data = rest_response.json()
-                        
+
                         # 토큰 사용량 등 추출
                         input_tokens = None
                         output_tokens = None
@@ -618,9 +595,12 @@ class GeminiClient:
             }
 
             if is_image_gen_model:
-                # 이미지 생성 모델용 최적화 설정 (충돌 가능 파라미터 제거)
-                config_params['max_output_tokens'] = 1024
-                # 참고: 일부 이미지 모델은 temperature 등을 지원하지 않을 수 있어 최소화함
+                # 이미지 생성 모델용 최적화 설정
+                # imagen 계열은 텍스트 출력이 없으므로 작게 유지, gemini 계열(멀티모달)은 텍스트 분석도 하므로 크게 허용
+                if "imagen" in model_name_clean.lower():
+                    config_params['max_output_tokens'] = 1024
+                else:
+                    config_params['max_output_tokens'] = 4096 # 멀티모달 모델의 텍스트 응답 허용량 확대
             else:
                 # 일반 텍스트 모델용 설정
                 config_params.update({
@@ -784,12 +764,12 @@ class GeminiClient:
                             generated_images.append(part['inline_data'].get('data'))
             
             # 응답에 이미지는 없지만 텍스트만 있는 경우, 혹시 에러 메시지인지 확인
-            if not generated_images and response_text:
+            if is_image_gen_model and not generated_images and response_text:
                 if any(kw in response_text.lower() for kw in ["error", "cannot", "sorry", "unable", "failed"]):
                     logger.warning(f"[Gemini Multimodal] AI가 이미지 생성 거부 메시지를 보낸 것으로 보임: {response_text[:200]}")
             
-            # 응답이 비어있거나 이미지가 없는 경우 상세 로깅
-            if not generated_images:
+            # 응답이 비어있거나 이미지가 없는 경우 상세 로깅 (이미지 모델인 경우만)
+            if is_image_gen_model and not generated_images:
                 try:
                     # 차단 사유(Safety) 확인
                     block_reason = "No blocks"

app/models/webtoon_conti.py

@@ -11,6 +11,8 @@ class WebtoonConti(db.Model):
     episode_id = db.Column(db.Integer, db.ForeignKey('episode_analysis.id'), nullable=True)
     title = db.Column(db.String(255), nullable=False)
     description = db.Column(db.Text, nullable=True)
+    analysis_prompt = db.Column(db.Text, nullable=True)  # 분석 참조 프롬프트 추가
+    gen_prompt = db.Column(db.Text, nullable=True)       # 그림 콘티용 프롬프트 추가
     created_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False)
     updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow, nullable=False)
 
@@ -28,6 +30,8 @@ class WebtoonConti(db.Model):
             'episode_id': self.episode_id,
             'title': self.title,
             'description': self.description,
+            'analysis_prompt': self.analysis_prompt,
+            'gen_prompt': self.gen_prompt,
             'created_at': self.created_at.isoformat() if self.created_at else None,
             'updated_at': self.updated_at.isoformat() if self.updated_at else None,
             'panel_count': len(self.panels) if self.panels else 0

app/prompts/webtoon_conti.py

@@ -75,3 +75,4 @@ def get_webtoon_conti_prompt(
 
 
 
+

app/routers/creation.py

@@ -6,6 +6,7 @@ import os
 import asyncio
 import re
 import json
+import requests
 from sqlalchemy import case
 from app.database import db, NovelProject, UploadedFile, ParentChunk, DocumentChunk, GraphEntity, GraphRelationship, GraphEvent, NovelProjectFact, StyleAnalysis, SystemConfig
 from app.routes import inject_admin_menu as shared_inject_admin_menu
@@ -70,6 +71,215 @@ def get_deps(project_id: str, user_id: int, style_content: str = None) -> NovelW
         style_content=style_content
     )
 
+@creation_bp.route('/api/character/global-prompt', methods=['GET'])
+@login_required
+def get_character_global_prompt():
+    """캐릭터 제작용 전역 기본 프롬프트 조회"""
+    return jsonify({
+        "prompt": SystemConfig.get_config('character_creation_default_prompt', '')
+    })
+
+@creation_bp.route('/api/character/global-prompt', methods=['POST'])
+@login_required
+def save_character_global_prompt():
+    """캐릭터 제작용 전역 기본 프롬프트 저장"""
+    data = request.get_json()
+    prompt = data.get('prompt')
+    if prompt is not None:
+        SystemConfig.set_config('character_creation_default_prompt', prompt)
+    return jsonify({"success": True, "message": "캐릭터 제작 기본 프롬프트로 저장되었습니다."})
+
+@creation_bp.route('/api/line-art-challenge/global-prompt', methods=['GET'])
+@login_required
+def get_line_art_challenge_global_prompt():
+    """웹툰 선화 도전용 전역 기본 프롬프트 조회"""
+    return jsonify({
+        "prompt": SystemConfig.get_config('line_art_challenge_default_prompt', '')
+    })
+
+@creation_bp.route('/api/line-art-challenge/global-prompt', methods=['POST'])
+@login_required
+def save_line_art_challenge_global_prompt():
+    """웹툰 선화 도전용 전역 기본 프롬프트 저장"""
+    data = request.get_json()
+    prompt = data.get('prompt')
+    if prompt is not None:
+        SystemConfig.set_config('line_art_challenge_default_prompt', prompt)
+    return jsonify({"success": True, "message": "웹툰 선화 도전 기본 프롬프트로 저장되었습니다."})
+
+@creation_bp.route('/character', methods=['GET'])
+@login_required
+def character_creation():
+    """캐릭터 제작 대시보드 페이지"""
+    default_analysis_model = SystemConfig.get_config('default_analysis_model', '')
+    return render_template('character_creation.html', title="캐릭터 제작", default_analysis_model=default_analysis_model)
+
+@creation_bp.route('/webtoon-line-art-challenge', methods=['GET'])
+@login_required
+def webtoon_line_art_challenge():
+    """웹툰 선화 도전 페이지"""
+    default_analysis_model = SystemConfig.get_config('default_analysis_model', '')
+    return render_template('webtoon_line_art_challenge.html', title="웹툰 선화 도전", default_analysis_model=default_analysis_model)
+
+@creation_bp.route('/api/character/extract-main', methods=['POST'])
+@login_required
+def extract_main_characters():
+    """웹소설에 등록된 캐릭터 목록 및 정보 반환 (Parent Chunk 컨텍스트 포함)"""
+    data = request.get_json()
+    file_id = data.get('file_id')
+    
+    if not file_id:
+        return jsonify({"error": "파일 ID가 필요합니다."}), 400
+        
+    try:
+        file_id = int(file_id)
+    except (ValueError, TypeError):
+        return jsonify({"error": "유효하지 않은 파일 ID입니다."}), 400
+        
+    current_app.logger.info(f"Fetching character data for file_id: {file_id}")
+    
+    # 1. DB에 등록된 캐릭터 목록 가져오기 (이미지 정보 포함)
+    from app.database import WebnovelCharacter
+    db_characters = WebnovelCharacter.query.filter_by(file_id=file_id).order_by(WebnovelCharacter.created_at.asc()).all()
+    
+    # 2. Parent Chunk 정보 가져오기 (세계관, 줄거리 등 배경 정보용)
+    parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+    world_view = parent_chunk.world_view if parent_chunk else ""
+    story = parent_chunk.story if parent_chunk else ""
+    others = parent_chunk.others if parent_chunk else ""
+    
+    chars = []
+    
+    if db_characters:
+        # 등록된 캐릭터가 있으면 해당 데이터 사용
+        for c in db_characters:
+            chars.append({
+                "id": c.id,
+                "name": c.name,
+                "description": c.description or "",
+                "image_path": c.image_path,
+                "images": [img.to_dict() for img in c.images] if hasattr(c, 'images') else []
+            })
+    else:
+        # 등록된 캐릭터가 없으면 Parent Chunk에서 추출 (기존 로직 하위 호환성 유지)
+        if parent_chunk and parent_chunk.characters:
+            char_text = parent_chunk.characters
+            lines = char_text.split('\n')
+            current_char = None
+            attr_keywords = ['역할', '성격', '특징', '성별', '나이', '외모', '능력', '소속', '배경', '목표', '동기']
+            
+            for line in lines:
+                line = line.strip()
+                if not line: continue
+                clean_line = re.sub(r'^[-*\d\.\s]+', '', line).strip()
+                if not clean_line: continue
+                
+                if ':' in clean_line and len(clean_line.split(':', 1)[0]) < 15:
+                    name_part, desc_part = clean_line.split(':', 1)
+                    name_part = re.sub(r'[\[\](){}]', '', name_part).strip().replace('*', '')
+                    is_attr_kw = any(name_part == kw for kw in attr_keywords)
+                    if is_attr_kw:
+                        if current_char: current_char["description"] += "\n" + clean_line
+                    else:
+                        current_char = {"name": name_part, "description": clean_line, "image_path": None, "images": []}
+                        chars.append(current_char)
+                    continue
+
+                is_attribute = any(clean_line.startswith(kw) for kw in attr_keywords)
+                if is_attribute:
+                    if current_char: current_char["description"] += "\n" + clean_line
+                else:
+                    if len(clean_line) > 15:
+                        if current_char: current_char["description"] += "\n" + clean_line
+                        continue
+                    name = re.sub(r'[\[\](){}]', '', clean_line).strip().replace('*', '')
+                    if name:
+                        current_char = {"name": name, "description": clean_line, "image_path": None, "images": []}
+                        chars.append(current_char)
+            
+    return jsonify({
+        "characters": chars,
+        "world_view": world_view,
+        "story": story,
+        "others": others
+    })
+
+@creation_bp.route('/api/character/analyze', methods=['POST'])
+@login_required
+def analyze_character():
+    """캐릭터 정보를 분석하여 이미지 생성 프롬프트 생성"""
+    data = request.get_json()
+    char_name = data.get('name')
+    char_desc = data.get('description')
+    project_context = data.get('context', '') # 작품 배경 정보
+    model_name = data.get('model_name')
+    
+    if not char_desc or not model_name:
+        return jsonify({"error": "분석할 정보와 모델명이 필요합니다."}), 400
+        
+    prompt = f"""
+당신은 웹툰 캐릭터 시트 제작을 위한 전문가입니다. 아래 제공된 [작품 배경 정보]와 [캐릭터 정보]를 바탕으로, 이미지 생성 인공지능이 이해하기 쉬운 상세한 영어 프롬프트를 작성해주세요.
+
+[작품 배경 정보]
+{project_context}
+
+[캐릭터 정보]
+이름: {char_name}
+설명: {char_desc}
+
+[작성 규칙]
+1. 반드시 아래 5가지 섹션 구조를 유지하세요.
+2. 각 섹션의 [ ] 부분은 캐릭터 정보와 작품의 분위기에 맞춰 구체적인 영어 단어로 채우세요.
+3. 정보가 부족한 부분은 작품 배경을 고려하여 캐릭터의 성격과 외모에 어울리는 적절한 설정을 추측하여 보완하세요.
+4. 결과물은 반드시 아래 형식의 텍스트만 출력하세요. 다른 설명은 생략합니다.
+
+### [1. Style & Quality]
+(Masterpiece), (High-quality Korean webtoon art style), (Clean line art), (Vibrant digital coloring), (8k resolution), (Detailed character design).
+
+### [2. Character Core]
+A [Age: 나이] [Gender: 성별] with [Personality/Vibe: 분위기/성격].
+[Face: 이목구비 특징], [Eyes: 눈매와 눈동자 색], [Hair: 헤어스타일과 머리색].
+
+### [3. Outfit & Accessories]
+Wearing [Outfit: 의상 상세], [Accessories: 액세서리 및 소품].
+[Theme: 장르적 특징 - 예: imperial military uniform, modern streetwear].
+
+### [4. Pose & Composition]
+[Shot Type: 구도 - 예: Full body portrait], [Pose: 자세 - 예: Standing facing front], (Neutral pose), (Simple background), (Character sheet format).
+
+### [5. Atmosphere & Lighting]
+[Mood: 분위기 - 예: Calm and mysterious], [Lighting: 조명 - 예: Soft rim lighting], (Atmospheric depth).
+"""
+
+    try:
+        from app.gemini_client import GeminiClient
+        
+        if model_name.startswith('gemini:'):
+            actual_model = model_name.split(':', 1)[1]
+            client = GeminiClient()
+            response = client.generate_response(prompt, model_name=actual_model)
+            analysis_result = response.get('response') if isinstance(response, dict) else (response.text if hasattr(response, 'text') else str(response))
+        else:
+            # Ollama API 호출
+            ollama_response = requests.post(
+                f'{Config.OLLAMA_BASE_URL}/api/generate',
+                json={
+                    'model': model_name,
+                    'prompt': prompt,
+                    'stream': False
+                },
+                timeout=60
+            )
+            if ollama_response.status_code == 200:
+                analysis_result = ollama_response.json().get('response', '')
+            else:
+                return jsonify({"success": False, "error": f"Ollama API 오류: {ollama_response.status_code}"})
+            
+        return jsonify({"success": True, "analysis": analysis_result})
+    except Exception as e:
+        current_app.logger.error(f"Character analysis error: {str(e)}")
+        return jsonify({"success": False, "error": str(e)})
+
 @creation_bp.route('/webnovel', methods=['GET'])
 @login_required
 def webnovel():
@@ -129,11 +339,16 @@ def upload_image():
 @creation_bp.route('/api/generate-image', methods=['POST'])
 @login_required
 def api_generate_image():
-    """텍스트 프롬프트를 기반으로 이미지 생성"""
+    """텍스트 프롬프트와 참조 이미지(콘티, 캐릭터 등)를 기반으로 이미지 생성"""
     data = request.json
     prompt = data.get('prompt')
     model_name = data.get('model_name')
-    image_url = data.get('image_url') # 선택된 이미지 URL
+    image_url = data.get('image_url') # 단일 이미지 URL (하위 호환성)
+    image_urls = data.get('image_urls', []) # 다중 이미지 URL 리스트
+    
+    # image_url이 있고 image_urls가 비어있으면 합침
+    if image_url and not image_urls:
+        image_urls = [image_url]
 
     if not prompt:
         return jsonify({'error': '프롬프트를 입력해주세요.'}), 400
@@ -145,24 +360,32 @@ def api_generate_image():
     
     async def generate():
         # gemini_client를 통해 직접 이미지 생성 요청
-        # model_name에서 'gemini:' 접두사 처리
         target_model = model_name.replace('gemini:', '')
         
-        system_instruction = "You are a professional artist. Please generate a high-quality image based on the user's detailed prompt. Output ONLY the image."
+        # 시스템 지침 구성
+        system_instruction = (
+            "You are a professional webtoon artist specialized in clean line art. "
+            "Please generate a high-quality Korean webtoon style line art based on the provided references. "
+            "If multiple images are provided, the first image is usually a sketch/storyboard (conty), "
+            "and the subsequent images are character or style references. "
+            "Maintain the composition of the sketch while applying the detailed designs and features from the reference images. "
+            "Output ONLY the generated image."
+        )
         
         contents = [system_instruction]
         
-        # 선택된 이미지가 있으면 Gemini에 전달
-        if image_url:
-            try:
-                # /uploads/ 접두어 제거하여 상대 경로 획득
-                rel_path = image_url.replace('/uploads/', '')
-                img_obj = await service.load_image(rel_path, max_size=1024)
-                if img_obj:
-                    contents.append(img_obj)
-                    current_app.logger.info(f"Image attached to prompt: {rel_path}")
-            except Exception as e:
-                current_app.logger.error(f"Failed to load attached image: {e}")
+        # 모든 참조 이미지 로드 및 추가
+        if image_urls:
+            for url in image_urls:
+                try:
+                    # /uploads/ 접두어 제거하여 상대 경로 획득
+                    rel_path = url.replace('/uploads/', '')
+                    img_obj = await service.load_image(rel_path, max_size=1024)
+                    if img_obj:
+                        contents.append(img_obj)
+                        current_app.logger.info(f"Reference image attached: {rel_path}")
+                except Exception as e:
+                    current_app.logger.error(f"Failed to load image {url}: {e}")
         
         contents.append(f"Prompt: {prompt}")
         

app/routers/webtoon_conti.py

@@ -10,6 +10,30 @@ import logging
 logger = logging.getLogger(__name__)
 webtoon_conti_bp = Blueprint('webtoon_conti', __name__, url_prefix='/webtoon-conti')
 
+@webtoon_conti_bp.route('/api/global-prompts', methods=['GET'])
+@login_required
+def get_global_prompts():
+    """전역(기본) 프롬프트 설정 조회"""
+    from app.database import SystemConfig
+    return jsonify({
+        "analysis_prompt": SystemConfig.get_config('webtoon_conti_default_analysis_prompt', ''),
+        "gen_prompt": SystemConfig.get_config('webtoon_conti_default_gen_prompt', '')
+    })
+
+@webtoon_conti_bp.route('/api/global-prompts', methods=['POST'])
+@login_required
+def save_global_prompts():
+    """전역(기본) 프롬프트 설정 저장"""
+    data = request.get_json()
+    from app.database import SystemConfig
+    
+    if 'analysis_prompt' in data:
+        SystemConfig.set_config('webtoon_conti_default_analysis_prompt', data.get('analysis_prompt'))
+    if 'gen_prompt' in data:
+        SystemConfig.set_config('webtoon_conti_default_gen_prompt', data.get('gen_prompt'))
+        
+    return jsonify({"success": True, "message": "기본 프롬프트로 저장되었습니다."})
+
 # 지연 로딩을 위해 전역 변수는 유지하되 초기화는 함수 내부에서 진행
 _conti_service = None
 _visual_service = None
@@ -106,7 +130,9 @@ def create_project():
         file_id=file_id,
         episode_id=episode_id,
         title=title,
-        description=description
+        description=description,
+        analysis_prompt=data.get('analysis_prompt'),
+        gen_prompt=data.get('gen_prompt')
     )
     db.session.add(project)
     db.session.commit()
@@ -129,9 +155,13 @@ def extract_visuals():
     data = request.get_json()
     text = data.get('text')
     file_id = data.get('file_id')
+    episode_ids = data.get('episode_ids', []) # 다중 회차 ID
+    graph_episode_titles = data.get('graph_episode_titles', []) # GraphRAG 회차 제목들
     project_id = data.get('project_id')
     analysis_model = data.get('analysis_model', 'gemini-1.5-flash')
     gen_model = data.get('gen_model')
+    analysis_prompt = data.get('analysis_prompt') # 추가 분석 지침
+    gen_prompt = data.get('gen_prompt') # 추가 생성 지침
     
     if not text:
         return jsonify({"error": "분석할 텍스트가 없습니다."}), 400
@@ -140,12 +170,62 @@ def extract_visuals():
         return jsonify({"error": "프로젝트 ID가 필요합니다."}), 400
 
     async def _process():
-        # 1. 텍스트를 컷별로 분할 (분석 전용 모델 사용)
+        # 0. 프로젝트 프롬프트 정보 업데이트 (저장 관리용)
+        project = WebtoonConti.query.get(project_id)
+        if project:
+            if analysis_prompt is not None:
+                project.analysis_prompt = analysis_prompt
+            if gen_prompt is not None:
+                project.gen_prompt = gen_prompt
+            db.session.commit()
+            logger.info(f"Updated prompts for project {project_id}")
+
+        # 1. 추가 컨텍스트 수집 (ParentChunk + 선택된 EpisodeAnalysis + GraphRAG)
         service = get_conti_service()
-        panels_data = await service.divide_into_panels(text, int(file_id) if file_id else 0, model=analysis_model)
+        context_parts = []
+        
+        if file_id and file_id != 0:
+            # ParentChunk (세계관, 캐릭터 설정 등) - 무조건 참조
+            from app.database import ParentChunk
+            parent_chunk = ParentChunk.query.filter_by(file_id=file_id).first()
+            if parent_chunk:
+                context_parts.append(f"### 세계관 및 캐릭터 기본 설정 (Parent Chunk)\n{parent_chunk.world_view or ''}\n{parent_chunk.characters or ''}")
+            
+            # 선택된 회차들의 분석 내용 (EpisodeAnalysis)
+            if episode_ids:
+                from app.database import EpisodeAnalysis
+                episodes = EpisodeAnalysis.query.filter(EpisodeAnalysis.id.in_(episode_ids)).all()
+                for ep in episodes:
+                    context_parts.append(f"### 회차 요약: {ep.episode_title}\n{ep.analysis_content}")
+            
+            # 선택된 회차들의 GraphRAG 정보
+            if graph_episode_titles:
+                from app.database import GraphEntity, GraphEvent, GraphRelationship
+                for title in graph_episode_titles:
+                    entities = GraphEntity.query.filter_by(file_id=file_id, episode_title=title).all()
+                    events = GraphEvent.query.filter_by(file_id=file_id, episode_title=title).all()
+                    
+                    if entities or events:
+                        graph_info = f"### GraphRAG 참조 ({title})\n"
+                        if entities:
+                            graph_info += "인물/장소: " + ", ".join([f"{e.entity_name}({e.entity_type})" for e in entities]) + "\n"
+                        if events:
+                            graph_info += "주요 사건: " + ", ".join([e.event_name for e in events]) + "\n"
+                        context_parts.append(graph_info)
+        
+        context_text = "\n\n".join(context_parts)
+        
+        # 2. 텍스트를 컷별로 분할 (분석 전용 모델 사용)
+        panels_data = await service.divide_into_panels(
+            text, 
+            int(file_id) if file_id else 0, 
+            model=analysis_model,
+            context_text=context_text,
+            custom_prompt=analysis_prompt
+        )
         
         created_panels = []
-        # 2. 각 분할된 데이터를 ContiPanel로 저장 및 이미지 직접 생성 시도 (생성 전용 모델 사용)
+        # 3. 각 분할된 데이터를 ContiPanel로 저장 및 이미지 직접 생성 시도 (생성 전용 모델 사용)
         image_tasks = []
         
         for data in panels_data:
@@ -161,7 +241,11 @@ def extract_visuals():
             
             # 생성 모델이 지정되어 있고 Gemini/Imagen 계열인 경우 직접 제작 요청
             if gen_model and ('imagen' in gen_model.lower() or 'gemini' in gen_model.lower()):
-                direct_prompt = f"{panel.description}. Composition: {panel.composition}. Webtoon style."
+                # 커스텀 생성 프롬프트가 있으면 반영
+                direct_prompt = f"Scene: {panel.description}. Dialogue/Action: {panel.dialogue or ''}. Composition: {panel.composition}. Webtoon style."
+                if gen_prompt:
+                    direct_prompt = f"{direct_prompt} Style Guidelines: {gen_prompt}"
+                    
                 image_tasks.append((panel, service.generate_image_directly(direct_prompt, gen_model)))
             
             created_panels.append(panel)
@@ -202,6 +286,7 @@ def generate_samples():
     panel_id = data.get('panel_id')
     sample_count = data.get('sample_count', 3)
     model = data.get('model') # 프론트엔드에서 모델을 보낼 경우 대비
+    gen_prompt = data.get('gen_prompt') # 추가 스타일 지침
     
     panel = ContiPanel.query.get_or_404(panel_id)
     project = panel.conti
@@ -216,14 +301,19 @@ def generate_samples():
         elif project.file: # 프로젝트에 연결된 파일의 모델이 있으면 사용
             visual_service.update_model(project.file.model_name or 'gemini-1.5-flash')
 
-        # 2. 패널 묘사를 바탕으로 상세 시각 요소 추출
-        visual_info = await visual_service.extract_visuals(panel.description, project.file_id)
+        # 2. 패널 묘사와 대사/지문을 함께 바탕으로 상세 시각 요소 추출
+        combined_text = f"Visual Description: {panel.description}\nDialogue/Narration: {panel.dialogue or ''}"
+        visual_info = await visual_service.extract_visuals(combined_text, project.file_id)
         
         # 선택된 모델이 Gemini/Imagen이면 직접 생성
         if model and ('imagen' in model.lower() or 'gemini' in model.lower()):
             logger.info(f"Using direct AI generation for samples using {model}")
             prompt_text = visual_service.generate_combined_prompt(visual_info)
             
+            # 커스텀 생성 프롬프트가 있으면 반영
+            if gen_prompt:
+                prompt_text = f"{prompt_text} Style Guidelines: {gen_prompt}"
+            
             # 병렬 이미지 생성
             coros = [service.generate_image_directly(prompt_text, model) for _ in range(sample_count)]
             image_results = await asyncio.gather(*coros)
@@ -249,7 +339,8 @@ def generate_samples():
         result = await service.generate_multi_samples(
             visual_info, 
             project.file_id, 
-            sample_count=sample_count
+            sample_count=sample_count,
+            custom_prompt=gen_prompt # 커스텀 프롬프트 추가
         )
         return result
 
@@ -333,6 +424,21 @@ def select_final():
         "image_path": panel.image_path
     })
 
+@webtoon_conti_bp.route('/api/projects/<int:project_id>/prompts', methods=['PUT'])
+@login_required
+def update_project_prompts(project_id):
+    """프로젝트의 프롬프트 설정 업데이트"""
+    data = request.get_json()
+    project = WebtoonConti.query.get_or_404(project_id)
+    
+    if 'analysis_prompt' in data:
+        project.analysis_prompt = data.get('analysis_prompt')
+    if 'gen_prompt' in data:
+        project.gen_prompt = data.get('gen_prompt')
+        
+    db.session.commit()
+    return jsonify({"success": True, "message": "프롬프트가 저장되었습니다."})
+
 @webtoon_conti_bp.route('/api/panels', methods=['POST'])
 @login_required
 def create_panel():

app/routes.py

@@ -54,6 +54,8 @@ def get_default_admin_menu():
                 "roles": ["admin", "webtoon_pm", "webtoon_admin", "producer", "user"],
                 "items": [
                     {"label": "웹소설", "endpoint": "creation.webnovel"},
+                    {"label": "캐릭터 제작", "endpoint": "creation.character_creation"},
+                    {"label": "웹툰 선화 도전", "endpoint": "creation.webtoon_line_art_challenge"},
                     {"label": "웹툰 콘티", "endpoint": "webtoon_conti.dashboard"},
                     {"label": "웹툰 선화", "endpoint": "main.webtoon_line_art_dashboard"},
                     {"label": "이미지 생성 테스트", "endpoint": "creation.image_test"},
@@ -302,6 +304,8 @@ def get_user_menu():
                 "roles": ["user"],
                 "items": [
                     {"label": "웹소설", "endpoint": "creation.webnovel"},
+                    {"label": "캐릭터 제작", "endpoint": "creation.character_creation"},
+                    {"label": "웹툰 선화 도전", "endpoint": "creation.webtoon_line_art_challenge"},
                 ],
             },
             {

app/services/webtoon_conti_service.py

@@ -74,7 +74,7 @@ class WebtoonContiService:
             logger.error(f"Direct image generation failed: {e}")
             return None
 
-    async def divide_into_panels(self, text: str, file_id: int, model: str = 'gemini-1.5-flash'):
+    async def divide_into_panels(self, text: str, file_id: int, model: str = 'gemini-1.5-flash', context_text: str = "", custom_prompt: str = ""):
         """
         웹소설 텍스트를 분석하여 웹툰 콘티 패널(컷)들로 분할합니다.
         """
@@ -89,8 +89,15 @@ class WebtoonContiService:
 
         # 2. 프롬프트 생성
         prompt = get_webtoon_conti_prompt(text, char_info, bg_info)
+        
+        # 3. 추가 컨텍스트 및 커스텀 프롬프트 반영
+        if context_text:
+            prompt = f"### 추가 참조 정보\n{context_text}\n\n{prompt}"
+        
+        if custom_prompt:
+            prompt = f"{prompt}\n\n### 사용자 추가 지침\n{custom_prompt}"
 
-        # 3. LLM 호출 (선택된 모델 사용)
+        # 4. LLM 호출 (선택된 모델 사용)
         response_text = ""
         if 'gemini' in model.lower():
             client = get_gemini_client()
@@ -146,43 +153,51 @@ class WebtoonContiService:
                     resp = resp.text
                 else:
                     resp = str(resp)
-                    
-            # 1. 마크다운 코드 블록 제거
+            
+            # 1. 마크다운 코드 블록 제거 (다양한 형식 대응)
             resp = re.sub(r'```json\s*', '', resp)
+            resp = re.sub(r'```JSON\s*', '', resp)
             resp = re.sub(r'```\s*', '', resp)
             
-            # 2. JSON 내부의 실제 줄바꿈 문자 처리 (문자열 내의 \n은 유지하고 실제 개행만 제거 시도)
-            # 주의: 복잡한 정규식보다는 리스트/객체 기호 기준 추출이 안전함
+            # 2. 앞뒤 공백 제거
+            resp = resp.strip()
             
             # 3. 리스트([]) 또는 객체({})의 시작과 끝을 찾아 추출
+            # 여러 개의 JSON 블록이 있을 경우 첫 번째 블록을 우선적으로 시도
             start_list = resp.find('[')
             end_list = resp.rfind(']')
             
             start_obj = resp.find('{')
             end_obj = resp.rfind('}')
             
-            # 리스트가 우선 (패널 리스트이므로)
-            if start_list != -1 and end_list != -1 and end_list > start_list:
+            if start_list != -1 and end_list != -1 and (start_obj == -1 or start_list < start_obj):
                 return resp[start_list:end_list+1]
-            elif start_obj != -1 and end_obj != -1 and end_obj > start_obj:
+            elif start_obj != -1 and end_obj != -1:
                 return resp[start_obj:end_obj+1]
             
-            return resp.strip()
+            return resp
 
         try:
             cleaned_response = clean_json_response(response_text)
             try:
+                # 1차 시도: 전체 파싱
                 panels_data = json.loads(cleaned_response)
             except json.JSONDecodeError as e:
-                # 파싱 실패 시 마지막에 콤마가 있거나 잘린 경우 처리 시도
-                logger.warning(f"Initial JSON parse failed: {e}. Attempting recovery...")
-                
-                # 끝이 잘린 경우 닫는 괄호 추가 시도
-                if '[' in cleaned_response and not cleaned_response.strip().endswith(']'):
+                # 2차 시도: Extra data 에러인 경우 (유효한 JSON 뒤에 가비지가 있는 경우)
+                if "Extra data" in str(e):
+                    try:
+                        logger.warning(f"JSON has extra data, attempting raw_decode. Error: {e}")
+                        decoder = json.JSONDecoder()
+                        panels_data, index = decoder.raw_decode(cleaned_response)
+                    except Exception as e2:
+                        logger.error(f"raw_decode failed: {e2}")
+                        raise e
+                # 3차 시도: 잘린 JSON 복구 시도
+                elif '[' in cleaned_response and not cleaned_response.strip().endswith(']'):
                     try:
+                        logger.warning(f"Incomplete JSON list detected, attempting recovery. Error: {e}")
                         panels_data = json.loads(cleaned_response.strip() + ']')
                     except:
-                        # 더 복잡한 복구는 생략하고 원래 에러 발생 시킴
                         raise e
                 else:
                     raise e
@@ -274,7 +289,8 @@ class WebtoonContiService:
         visual_info: VisualExtractionOutput, 
         file_id: int, 
         workflow_name: str = "default_webtoon_conti", 
-        sample_count: int = 3
+        sample_count: int = 3,
+        custom_prompt: str = ""
     ):
         """
         동일한 시각 묘사를 바탕으로 서로 다른 시드값을 사용하여 여러 샘플 이미지를 생성합니다.
@@ -284,6 +300,7 @@ class WebtoonContiService:
             file_id: 캐릭터 검색용 파일 ID
             workflow_name: 사용할 ComfyUI 워크플로우 이름
             sample_count: 생성할 샘플 수 (기본 3개)
+            custom_prompt: 사용자 추가 스타일 지침
         """
         # 1. 캐릭터 참조 이미지 조회
         character_image_path = None
@@ -305,6 +322,10 @@ class WebtoonContiService:
 
         # 3. 영어 프롬프트 생성
         prompt_text = self.visual_service.generate_combined_prompt(visual_info)
+        
+        # 커스텀 프롬프트(그림 콘티용 프롬프트) 반영
+        if custom_prompt:
+            prompt_text = f"{prompt_text}, {custom_prompt}"
 
         samples = []
         # 4. 여러 시드로 이미지 생성 요청

force_update_menu.py

@@ -71,5 +71,6 @@ if __name__ == "__main__":
 
 
 
+
 
 

templates/admin_webtoon_milestone_producer_manager.html

@@ -365,5 +365,6 @@
 
 
 
+
 
 

templates/character_creation.html

@@ -0,0 +1,505 @@
+{% extends "creation_base.html" %}
+
+{% block title %}캐릭터 제작 - SOYMEDIA{% endblock %}
+
+{% block nav %}
+    {% set admin_nav_title = 'AI 캐릭터 제작' %}
+    {% set admin_nav_icon = '👤' %}
+    {% include '_admin_nav.html' %}
+{% endblock %}
+
+{% block extra_css %}
+<style>
+    .character-card {
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        background: white;
+        margin-bottom: 1.5rem;
+        overflow: hidden;
+        transition: all 0.3s;
+    }
+    .character-card:hover {
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        transform: translateY(-2px);
+    }
+    .character-header {
+        padding: 1rem 1.5rem;
+        background: #f8f9fa;
+        border-bottom: 1px solid var(--border);
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+    }
+    .character-body {
+        padding: 1.5rem;
+    }
+    .gen-input-column {
+        display: flex;
+        flex-direction: column;
+    }
+    #genPrompt {
+        flex-grow: 1;
+        min-height: 400px;
+    }
+    .result-image-container {
+        width: 100%;
+        max-width: 800px;
+        margin: 0 auto;
+        border-radius: 12px;
+        overflow: hidden;
+        background: #f0f0f0;
+        min-height: 400px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        border: 1px solid var(--border);
+        box-shadow: var(--shadow);
+    }
+    .result-image {
+        max-width: 100%;
+        height: auto;
+        display: block;
+    }
+    .character-item {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        padding: 12px !important;
+        transition: background 0.2s;
+    }
+    .character-item:hover {
+        background-color: #f0f7ff;
+    }
+    .character-item-img {
+        width: 50px;
+        height: 50px;
+        border-radius: 8px;
+        object-fit: cover;
+        background: #eee;
+        flex-shrink: 0;
+    }
+    .character-item-info {
+        flex-grow: 1;
+        overflow: hidden;
+    }
+    .character-item-name {
+        font-weight: 600;
+        font-size: 14px;
+        color: var(--text-primary);
+        margin-bottom: 2px;
+    }
+    .character-item-desc {
+        font-size: 12px;
+        color: var(--text-secondary);
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden;
+    }
+    .character-img-gallery {
+        display: flex;
+        gap: 4px;
+        margin-top: 4px;
+        overflow-x: auto;
+        padding-bottom: 4px;
+    }
+    .character-img-gallery img {
+        width: 30px;
+        height: 30px;
+        border-radius: 4px;
+        object-fit: cover;
+        cursor: pointer;
+        border: 1px solid transparent;
+    }
+    .character-img-gallery img:hover {
+        border-color: var(--accent);
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+<!-- 상단 헤더 영역 -->
+<div class="dashboard-header d-flex justify-content-between align-items-center mb-4">
+    <div>
+        <h1 class="title-main mb-1">AI 캐릭터 제작</h1>
+        <p class="text-meta mb-0">원작 설정을 바탕으로 캐릭터의 비주얼을 설계하고 이미지를 생성합니다. <br />
+            * '캐릭터 생성 프롬프트'에 자주 사용하시는 명령어나 설정을 저장하실 수 있습니다. 참조하는 작품들의 경우 저장된 정보에 추가되어 표시됩니다. <br />
+            * 프롬프트만 가지고 캐릭터를 생성할 수 있습니다. '캐릭터 생성 프롬프트'에 원하는 프롬프트를 입력 후 '캐릭터 이미지 생성 시작' 버튼을 눌러주세요. '생성 모델'로 선택한 AI가 캐릭터를 생성합니다. <br />
+            * 원작 웹소설 캐릭터를 분석 후 초안을 제작할 수 있습니다. <br />
+            1. '참조 웹소설 프로젝트'에서 원하는 작품을 선택하세요. 해당 작품 캐릭터 목록에 '캐릭터 목록'에 표시됩니다. <br />
+            2. '캐릭터 목록'에서 원하는 캐릭터를 클릭해 주세요. '분석 모델'에서 선택한 AI가 작품 속 캐릭터를 분석 후 '캐릭터 생성 프롬프트'에 캐릭터 정보를 추가합니다.
+        </p>
+    </div>
+</div>
+
+<!-- AI 설정 바 -->
+<div class="clean-card mb-4 py-2 px-4 d-flex align-items-center gap-4" style="cursor: default;">
+    <div class="d-flex align-items-center gap-2">
+        <label for="analysisModelSelect" class="small fw-bold text-secondary mb-0">
+            <i class="fas fa-search me-1 text-primary"></i> 분석 모델:
+        </label>
+        <select id="analysisModelSelect" class="form-select form-select-sm border-0 bg-transparent shadow-none" style="width: auto; min-width: 180px; font-weight: 600;">
+            <option value="">모델 로딩 중...</option>
+        </select>
+    </div>
+    <div class="vr"></div>
+    <div class="d-flex align-items-center gap-2">
+        <label for="modelSelect" class="small fw-bold text-secondary mb-0">
+            <i class="fas fa-paint-brush me-1 text-success"></i> 생성 모델:
+        </label>
+        <select id="modelSelect" class="form-select form-select-sm border-0 bg-transparent shadow-none" style="width: auto; min-width: 180px; font-weight: 600;">
+            <option value="">모델 로딩 중...</option>
+        </select>
+    </div>
+    <button class="btn btn-sm text-muted p-0 hover-rotate" onclick="loadModels()">
+        <i class="fas fa-sync-alt"></i>
+    </button>
+</div>
+
+<div class="row g-4 align-items-stretch mb-5">
+    <!-- 왼쪽: 프롬프트 입력 -->
+    <div class="col-lg-8 gen-input-column">
+        <div class="clean-card h-100 p-4">
+            <div class="d-flex justify-content-between align-items-center mb-3">
+                <h2 class="h5 fw-bold mb-0">캐릭터 생성 프롬프트</h2>
+                <div class="d-flex gap-2">
+                    <button class="btn btn-sm btn-outline-primary" onclick="saveGlobalPrompt()">
+                        <i class="fas fa-save me-1"></i> 기본값으로 저장
+                    </button>
+                </div>
+            </div>
+            <textarea id="genPrompt" class="form-control border-0 bg-light p-4" 
+                      style="border-radius: 12px; font-size: 14px; line-height: 1.6;"
+                      placeholder="생성할 캐릭터의 외모, 복장, 분위기 등을 상세히 입력하세요."></textarea>
+            
+            <div class="mt-4">
+                <button id="generateBtn" class="db-btn db-btn-primary w-100 py-3 fw-bold" onclick="generateCharacter()">
+                    <i class="fas fa-wand-sparkles me-2"></i> 캐릭터 이미지 생성 시작
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 오른쪽: 설정 및 참조 -->
+    <div class="col-lg-4">
+        <div class="clean-card p-4 h-100">
+            <h2 class="h5 fw-bold mb-4">참조 설정</h2>
+            
+            <div class="mb-4">
+                <label class="form-label small fw-bold text-secondary">참조 웹소설 프로젝트</label>
+                <select id="projectSelect" class="form-select border-0 shadow-sm mb-2" onchange="loadCharacters(this.value)">
+                    <option value="">-- 프로젝트 선택 --</option>
+                </select>
+                <p class="text-muted small mb-0"><i class="fas fa-info-circle me-1"></i> 프로젝트를 선택하면 등록된 메인 캐릭터 목록이 나타납니다.</p>
+            </div>
+
+            <div class="mb-4">
+                <label class="form-label small fw-bold text-secondary">캐릭터 목록</label>
+                <div id="characterList" class="bg-light border rounded p-2" style="max-height: 300px; overflow-y: auto; min-height: 100px;">
+                    <p class="text-muted small mb-0 p-2 text-center">프로젝트를 먼저 선택해주세요.</p>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- 하단 결과 영역 -->
+<div id="resultArea" class="d-none mb-5">
+    <div class="clean-card p-4">
+        <div class="d-flex justify-content-between align-items-center mb-4">
+            <h2 class="h5 fw-bold mb-0">캐릭터 생성 결과</h2>
+            <a id="downloadLink" href="#" class="db-btn db-btn-outline py-2" download>
+                <i class="fas fa-download"></i> 이미지 다운로드
+            </a>
+        </div>
+        <div class="result-image-container" id="imageContainer">
+            <div class="text-center py-5">
+                <div class="spinner-border text-primary mb-3" role="status"></div>
+                <p class="text-muted mb-0" id="loadingText">이미지를 생성하고 있습니다. 잠시만 기다려주세요...</p>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+let currentFileId = null;
+const defaultAnalysisModel = "{{ default_analysis_model }}";
+
+async function loadModels() {
+    const genSelect = document.getElementById('modelSelect');
+    const analysisSelect = document.getElementById('analysisModelSelect');
+    try {
+        const response = await fetch('/api/ollama/models?all=true');
+        const data = await response.json();
+        
+        if (data.models && data.models.length > 0) {
+            const optionsHtml = ['<option value="">모델 선택...</option>'];
+            const analysisOptionsHtml = ['<option value="">모델 선택...</option>'];
+            
+            // Gemini 모델 그룹
+            const geminiModels = data.models.filter(m => m.type === 'gemini');
+            if (geminiModels.length > 0) {
+                optionsHtml.push('<optgroup label="✨ Google Gemini">');
+                analysisOptionsHtml.push('<optgroup label="✨ Google Gemini">');
+                geminiModels.forEach(m => {
+                    const label = m.name.startsWith('gemini:') ? m.name.substring(7) : m.name;
+                    const genSelected = m.name.includes('gemini-3-pro-image-preview') ? 'selected' : '';
+                    
+                    // ���석 모델 기본값 설정
+                    let analysisSelected = '';
+                    if (defaultAnalysisModel) {
+                        if (m.name === defaultAnalysisModel || m.name === `gemini:${defaultAnalysisModel}`) {
+                            analysisSelected = 'selected';
+                        }
+                    } else if (m.name.includes('gemini-1.5-flash')) {
+                        analysisSelected = 'selected';
+                    }
+                    
+                    optionsHtml.push(`<option value="${m.name}" ${genSelected}>${label}</option>`);
+                    analysisOptionsHtml.push(`<option value="${m.name}" ${analysisSelected}>${label}</option>`);
+                });
+                optionsHtml.push('</optgroup>');
+                analysisOptionsHtml.push('</optgroup>');
+            }
+            
+            // Ollama 모델 그룹
+            const ollamaModels = data.models.filter(m => m.type !== 'gemini');
+            if (ollamaModels.length > 0) {
+                optionsHtml.push('<optgroup label="🤖 Ollama (Local)">');
+                analysisOptionsHtml.push('<optgroup label="🤖 Ollama (Local)">');
+                ollamaModels.forEach(m => {
+                    let analysisSelected = (m.name === defaultAnalysisModel) ? 'selected' : '';
+                    optionsHtml.push(`<option value="${m.name}">${m.name}</option>`);
+                    analysisOptionsHtml.push(`<option value="${m.name}" ${analysisSelected}>${m.name}</option>`);
+                });
+                optionsHtml.push('</optgroup>');
+                analysisOptionsHtml.push('</optgroup>');
+            }
+            
+            genSelect.innerHTML = optionsHtml.join('');
+            analysisSelect.innerHTML = analysisOptionsHtml.join('');
+        }
+    } catch (error) {
+        console.error('모델 로드 오류:', error);
+        genSelect.innerHTML = '<option value="">로드 실패</option>';
+        analysisSelect.innerHTML = '<option value="">로드 실패</option>';
+    }
+}
+
+async function loadNovelProjects() {
+    const select = document.getElementById('projectSelect');
+    try {
+        const res = await fetch('/api/files?sort=uploaded_at_desc&public_only=true');
+        const data = await res.json();
+        
+        if (data.files && data.files.length > 0) {
+            data.files.forEach(f => {
+                const opt = document.createElement('option');
+                opt.value = f.id;
+                opt.textContent = f.original_filename;
+                select.appendChild(opt);
+            });
+        }
+    } catch (e) {
+        console.error("Project load error:", e);
+    }
+}
+
+async function loadCharacters(fileId) {
+    if (!fileId) return;
+    currentFileId = fileId;
+    const list = document.getElementById('characterList');
+    const promptArea = document.getElementById('genPrompt');
+    list.innerHTML = '<div class="text-center p-3"><div class="spinner-border spinner-border-sm text-primary"></div></div>';
+    
+    try {
+        const res = await fetch('/creation/api/character/extract-main', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({ file_id: fileId })
+        });
+        const data = await res.json();
+        
+        // 전역 변수에 프로젝트 배경 정보 저장 (분석 시 사용)
+        window.projectContext = `세계관: ${data.world_view || '정보 없음'}\n줄거리: ${data.story || '정보 없음'}\n기타: ${data.others || '정보 없음'}`;
+
+        // 1. Parent Chunk 정보(세계관, 기타)를 프롬프트에 추가
+        if (data.world_view || data.others) {
+            let contextPrompt = '';
+            if (data.world_view) contextPrompt += `### 세계관 설명\n${data.world_view}\n\n`;
+            if (data.others) contextPrompt += `### 기타 설정\n${data.others}\n\n`;
+            
+            if (confirm("선택한 프로젝트의 '세계관 설명' 및 '기타 설정'을 프롬프트에 추가할까요?")) {
+                promptArea.value = contextPrompt + promptArea.value;
+            }
+        }
+
+        if (data.characters && data.characters.length > 0) {
+            list.innerHTML = data.characters.map((c, idx) => {
+                const mainImg = c.image_path ? `/uploads/${c.image_path}` : '';
+                const hasImages = c.images && c.images.length > 0;
+                
+                return `
+                    <div class="border-bottom character-item cursor-pointer" 
+                         data-char-index="${idx}"
+                         onclick='applyCharacterPrompt(${idx})'>
+                        ${mainImg ? `<img src="${mainImg}" class="character-item-img">` : `<div class="character-item-img d-flex align-items-center justify-content-center text-muted"><i class="fas fa-user"></i></div>`}
+                        <div class="character-item-info">
+                            <div class="character-item-name">${c.name}</div>
+                            <div class="character-item-desc text-muted small">${c.description || '설명 없음'}</div>
+                            ${hasImages ? `
+                                <div class="character-img-gallery mt-1">
+                                    ${c.images.map(img => `<img src="/uploads/${img.image_path}" onclick="event.stopPropagation(); window.open('/uploads/${img.image_path}', '_blank')" title="이미지 크게 보기">`).join('')}
+                                </div>
+                            ` : ''}
+                        </div>
+                    </div>
+                `;
+            }).join('');
+            
+            // 전역 변수에 캐릭터 데이터 저장
+            window.extractedCharacters = data.characters;
+        } else {
+            list.innerHTML = '<p class="text-muted small mb-0 p-2 text-center">분석된 캐릭터가 없습니다.</p>';
+        }
+    } catch (e) {
+        list.innerHTML = '<p class="text-danger small mb-0 p-2 text-center">로드 실패</p>';
+    }
+}
+
+async function applyCharacterPrompt(index) {
+    const c = window.extractedCharacters[index];
+    if (!c) return;
+    
+    const name = c.name;
+    const desc = c.description;
+    const promptArea = document.getElementById('genPrompt');
+    const analysisModel = document.getElementById('analysisModelSelect').value;
+    
+    if (!analysisModel) {
+        alert("분석 모델을 먼저 선택해주세요.");
+        return;
+    }
+    
+    if (confirm(`'${name}' 캐릭터 설정을 분석하여 프롬프트에 적용할까요?\n(선택한 분석 모델: ${analysisModel})`)) {
+        const originalBtnText = document.querySelector(`.character-item[data-char-index="${index}"]`).innerHTML;
+        const charItem = document.querySelector(`.character-item[data-char-index="${index}"]`);
+        
+        charItem.innerHTML = `<div class="fw-bold small text-primary"><span class="spinner-border spinner-border-sm me-1"></span>분석 중...</div>`;
+        charItem.style.pointerEvents = 'none';
+        
+        try {
+            const res = await fetch('/creation/api/character/analyze', {
+                method: 'POST',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({
+                    name: name,
+                    description: desc,
+                    context: window.projectContext || '',
+                    model_name: analysisModel
+                })
+            });
+            const data = await res.json();
+            
+            if (data.success) {
+                const analyzedPrompt = data.analysis;
+                if (promptArea.value.trim()) {
+                    promptArea.value = promptArea.value + "\n\n" + analyzedPrompt;
+                } else {
+                    promptArea.value = analyzedPrompt;
+                }
+                // 프롬프트 영역으로 스크롤
+                promptArea.scrollIntoView({ behavior: 'smooth' });
+            } else {
+                alert("분석 실패: " + data.error);
+            }
+        } catch (e) {
+            alert("통신 오류가 발생했습니다.");
+        } finally {
+            charItem.innerHTML = originalBtnText;
+            charItem.style.pointerEvents = 'auto';
+        }
+    }
+}
+
+async function generateCharacter() {
+    const prompt = document.getElementById('genPrompt').value.trim();
+    const model = document.getElementById('modelSelect').value;
+    const btn = document.getElementById('generateBtn');
+    const resultArea = document.getElementById('resultArea');
+    const imageContainer = document.getElementById('imageContainer');
+    
+    if (!prompt) return alert("프롬프트를 입력해주세요.");
+    if (!model) return alert("모델을 선택해주세요.");
+    
+    btn.disabled = true;
+    btn.innerHTML = '<span class="spinner-border spinner-border-sm me-2"></span>이미지 생성 중...';
+    
+    resultArea.classList.remove('d-none');
+    imageContainer.innerHTML = `
+        <div class="text-center py-5">
+            <div class="spinner-border text-primary mb-3" role="status"></div>
+            <p class="text-muted mb-0">이미지를 생성하고 있습니다. 잠시만 기다려주세요...</p>
+        </div>
+    `;
+    
+    // 결과 영역으로 스크롤
+    resultArea.scrollIntoView({ behavior: 'smooth' });
+    
+    try {
+        const res = await fetch('/creation/api/generate-image', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({
+                prompt: prompt,
+                model_name: model
+            })
+        });
+        
+        const data = await res.json();
+        if (data.success) {
+            imageContainer.innerHTML = `<img src="${data.image_url}" class="result-image" alt="Generated Character">`;
+            document.getElementById('downloadLink').href = data.image_url;
+        } else {
+            alert("생성 실패: " + (data.error || "알 수 없는 오류"));
+            imageContainer.innerHTML = '<p class="text-danger small p-3">이미지 생성에 실패했습니다.</p>';
+        }
+    } catch (e) {
+        alert("통신 오류가 발생했습니다.");
+        imageContainer.innerHTML = '';
+    } finally {
+        btn.disabled = false;
+        btn.innerHTML = '<i class="fas fa-wand-sparkles me-2"></i> 캐릭터 이미지 생성 시작';
+    }
+}
+
+async function loadGlobalPrompt() {
+    try {
+        const res = await fetch('/creation/api/character/global-prompt');
+        const data = await res.json();
+        if (data.prompt) {
+            document.getElementById('genPrompt').value = data.prompt;
+        }
+    } catch (e) {}
+}
+
+async function saveGlobalPrompt() {
+    const prompt = document.getElementById('genPrompt').value;
+    try {
+        const res = await fetch('/creation/api/character/global-prompt', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({ prompt: prompt })
+        });
+        if (res.ok) alert("캐릭터 제작 기본 프롬프트로 저장되었습니다.");
+    } catch (e) {
+        alert("저장 실패");
+    }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    loadModels();
+    loadNovelProjects();
+    loadGlobalPrompt();
+});
+</script>
+{% endblock %}

templates/webtoon_conti_dashboard.html

@@ -110,9 +110,13 @@
         border: none;
         box-shadow: 0 4px 10px rgba(26, 115, 232, 0.3);
     }
-    .btn-generate:hover {
-        box-shadow: 0 6px 15px rgba(26, 115, 232, 0.4);
-        transform: translateY(-1px);
+    .novel-input-column {
+        display: flex;
+        flex-direction: column;
+    }
+    #novelText {
+        flex-grow: 1;
+        min-height: 500px;
     }
 </style>
 {% endblock %}
@@ -174,9 +178,9 @@
         </div>
     </div>
     
-    <div class="row g-4">
-        <div class="col-lg-8">
-            <textarea id="novelText" class="form-control border-0 bg-light p-4" rows="10" 
+    <div class="row g-4 align-items-stretch">
+        <div class="col-lg-8 novel-input-column">
+            <textarea id="novelText" class="form-control border-0 bg-light p-4 h-100" 
                       style="border-radius: 12px; font-size: 14px; line-height: 1.6;"
                       placeholder="웹소설의 특정 장면이나 에피소드 텍스트를 입력하세요."></textarea>
         </div>
@@ -188,12 +192,35 @@
                         <option value="">-- 프로젝트 선택 --</option>
                     </select>
                 </div>
+                <div class="mb-3">
+                    <label class="form-label small fw-bold text-secondary">회차 불러오기 (다중 선택 가능)</label>
+                    <div id="episodeList" class="bg-white border rounded p-2" style="max-height: 200px; overflow-y: auto;">
+                        <p class="text-muted small mb-0 p-2">프로젝트를 먼저 선택해주세요.</p>
+                    </div>
+                </div>
+                
+                <div class="mb-3">
+                    <div class="d-flex justify-content-between align-items-center mb-1">
+                        <label class="form-label small fw-bold text-secondary mb-0">분석 참조 프롬프트</label>
+                        <button class="btn btn-sm p-0 text-primary" onclick="savePrompts()" title="프롬프트 저장">
+                            <i class="fas fa-save"></i>
+                        </button>
+                    </div>
+                    <textarea id="analysisPrompt" class="form-control border-0 shadow-sm small" rows="3" 
+                              placeholder="분석 시 참고할 추가 지침을 입력하세요."></textarea>
+                </div>
+                
                 <div class="mb-4">
-                    <label class="form-label small fw-bold text-secondary">에피소드 불러오기</label>
-                    <select id="episodeSelect" class="form-select border-0 shadow-sm" disabled onchange="loadEpisodeContent(this.value)">
-                        <option value="">-- 에피소드 선택 --</option>
-                    </select>
+                    <div class="d-flex justify-content-between align-items-center mb-1">
+                        <label class="form-label small fw-bold text-secondary mb-0">그림 콘티용 프롬프트</label>
+                        <button class="btn btn-sm p-0 text-primary" onclick="savePrompts()" title="프롬프트 저장">
+                            <i class="fas fa-save"></i>
+                        </button>
+                    </div>
+                    <textarea id="genPrompt" class="form-control border-0 shadow-sm small" rows="3" 
+                              placeholder="이미지 생성 시 참고할 추가 스타일 지침을 입력하세요."></textarea>
                 </div>
+
                 <button class="db-btn db-btn-primary w-100 py-3 fw-bold" onclick="startExtraction()">
                     <i class="fas fa-wand-sparkles me-2"></i> 분석 및 콘티 생성 시작
                 </button>
@@ -352,7 +379,7 @@ document.getElementById('genModelSelect').addEventListener('change', function()
 
 async function loadNovelProjects() {
     try {
-        const res = await fetch('/api/files?sort=uploaded_at_desc');
+        const res = await fetch('/api/files?sort=uploaded_at_desc&public_only=true');
         const data = await res.json();
         const files = data.files || [];
         const select = document.getElementById('projectSelect');
@@ -370,43 +397,136 @@ async function loadNovelProjects() {
 }
 
 async function loadEpisodes(fileId) {
-    const select = document.getElementById('episodeSelect');
-    select.innerHTML = '<option value="">-- 에피소드 선택 --</option>';
+    const listContainer = document.getElementById('episodeList');
+    listContainer.innerHTML = '<div class="text-center p-2"><div class="spinner-border spinner-border-sm text-primary"></div></div>';
     
     currentFileId = fileId;
 
     if (!fileId) {
-        select.disabled = true;
+        listContainer.innerHTML = '<p class="text-muted small mb-0 p-2">프로젝트를 먼저 선택해주세요.</p>';
         return;
     }
 
     try {
-        const res = await fetch(`/api/analysis/episodes/${fileId}`);
+        // 1. 회차별 분석 정보(EpisodeAnalysis)와 GraphRAG(GraphEntity) 정보를 함께 고려하기 위해
+        // 먼저 GraphRAG API를 ���해 존재하는 회차 목록을 가져옵니다.
+        const res = await fetch(`/api/files/${fileId}/graph`);
         const data = await res.json();
-        const episodes = data.episodes || [];
         
-        episodes.forEach(ep => {
-            const opt = document.createElement('option');
-            opt.value = ep.id;
-            opt.textContent = ep.episode_title;
-            select.appendChild(opt);
+        // GraphRAG에 등록된 회차 목록 (episodes)
+        const graphEpisodes = data.episodes || [];
+        
+        // 2. 기존 EpisodeAnalysis API에서도 회차 목록을 가져옵니다.
+        const res2 = await fetch(`/api/analysis/episodes/${fileId}`);
+        const data2 = await res2.json();
+        const analysisEpisodes = data2.episodes || [];
+        
+        // 두 소스를 통합하여 유니크한 회차 목록 생성
+        // analysisEpisodes는 [{id, episode_title, ...}] 형태고, graphEpisodes는 ['1화', '2화', ...] 형태임
+        const allEpisodes = [];
+        
+        // 먼저 EpisodeAnalysis 데이터를 기반으로 목록 구성
+        analysisEpisodes.forEach(ep => {
+            allEpisodes.push({
+                id: ep.id,
+                title: ep.episode_title,
+                source: 'analysis'
+            });
+        });
+        
+        // GraphRAG에만 있고 EpisodeAnalysis에는 없는 회차 추가 (필요시)
+        graphEpisodes.forEach(title => {
+            if (!allEpisodes.find(e => e.title === title)) {
+                allEpisodes.push({
+                    id: `graph-${title}`,
+                    title: title,
+                    source: 'graph'
+                });
+            }
+        });
+        
+        if (allEpisodes.length === 0) {
+            listContainer.innerHTML = '<p class="text-muted small mb-0 p-2">회차 정보가 없습니다.</p>';
+            return;
+        }
+
+        // 자연어 정렬 (1화, 2화, 10화 순서 등)
+        allEpisodes.sort((a, b) => {
+            return a.title.localeCompare(b.title, undefined, {numeric: true, sensitivity: 'base'});
         });
-        select.disabled = false;
+
+        listContainer.innerHTML = allEpisodes.map(ep => `
+            <div class="form-check p-1 ms-4">
+                <input class="form-check-input episode-checkbox" type="checkbox" 
+                       value="${ep.id}" 
+                       data-title="${ep.title}"
+                       data-source="${ep.source}"
+                       id="ep-${ep.id}" onchange="updateContentFromSelection()">
+                <label class="form-check-label small" for="ep-${ep.id}">
+                    ${ep.title} ${ep.source === 'graph' ? '<span class="badge bg-info ms-1" style="font-size: 8px;">Graph</span>' : ''}
+                </label>
+            </div>
+        `).join('');
     } catch (e) {
         console.error("Episode load error:", e);
+        listContainer.innerHTML = '<p class="text-danger small mb-0 p-2">회차 로드 실패</p>';
     }
 }
 
-async function loadEpisodeContent(episodeId) {
-    if (!episodeId) return;
+async function updateContentFromSelection() {
+    const checkedNodes = Array.from(document.querySelectorAll('.episode-checkbox:checked'));
+    if (checkedNodes.length === 0) {
+        return;
+    }
+    
+    // 가장 최근에 체크된 노드
+    const lastNode = checkedNodes[checkedNodes.length - 1];
+    const source = lastNode.getAttribute('data-source');
+    const id = lastNode.value;
+    const title = lastNode.getAttribute('data-title');
+
+    if (source === 'analysis') {
+        await loadEpisodeContent(id);
+    } else if (source === 'graph') {
+        await loadGraphEpisodeContent(currentFileId, title);
+    }
+}
+
+async function loadGraphEpisodeContent(fileId, episodeTitle) {
     try {
-        const res = await fetch(`/api/analysis/episode/${episodeId}`);
+        const res = await fetch(`/api/files/${fileId}/graph`);
         const data = await res.json();
-        if (data.analysis_content) {
-            document.getElementById('novelText').value = data.analysis_content;
+        
+        const entities = data.entities_by_episode[episodeTitle] || {characters: [], locations: []};
+        const relationships = data.relationships_by_episode[episodeTitle] || [];
+        const events = data.events_by_episode[episodeTitle] || [];
+        
+        let content = `[${episodeTitle} GraphRAG 분석 내용]\n\n`;
+        
+        if (entities.characters.length > 0) {
+            content += "■ 주요 인물:\n" + entities.characters.map(c => `- ${c.entity_name}: ${c.description || ''} (역할: ${c.role || '미정'})`).join('\n') + "\n\n";
+        }
+        
+        if (events.length > 0) {
+            content += "■ 주요 사건:\n" + events.map(e => `- ${e.event_name}: ${e.description}`).join('\n') + "\n\n";
+        }
+        
+        if (relationships.length > 0) {
+            content += "■ 관계도:\n" + relationships.map(r => `- ${r.source} -> ${r.target}: ${r.description || r.relationship_type}`).join('\n') + "\n";
+        }
+
+        const textarea = document.getElementById('novelText');
+        if (textarea.value && !textarea.value.includes(episodeTitle)) {
+            if (confirm(`'${episodeTitle}'의 GraphRAG 분석 내용을 기존 텍스트에 추가할까요?`)) {
+                textarea.value += "\n\n" + content;
+            } else {
+                textarea.value = content;
+            }
+        } else {
+            textarea.value = content;
         }
     } catch (e) {
-        console.error("Content load error:", e);
+        console.error("Graph content load error:", e);
     }
 }
 
@@ -416,10 +536,17 @@ async function startExtraction() {
 
     const analysisModel = document.getElementById('analysisModelSelect').value;
     const genModel = document.getElementById('genModelSelect').value;
+    const analysisPrompt = document.getElementById('analysisPrompt').value;
+    const genPrompt = document.getElementById('genPrompt').value;
     
     if (!analysisModel) return alert("분석 모델을 선택해주세요.");
     if (!genModel) return alert("콘티 생성 모델을 선택해주세요.");
 
+    // 선택된 회차 정보 목록
+    const checkedNodes = Array.from(document.querySelectorAll('.episode-checkbox:checked'));
+    const episodeIds = checkedNodes.filter(n => n.getAttribute('data-source') === 'analysis').map(n => parseInt(n.value));
+    const graphEpisodeTitles = checkedNodes.filter(n => n.getAttribute('data-source') === 'graph').map(n => n.getAttribute('data-title'));
+
     // 참조 프로젝트 확인
     if (!currentFileId && !document.getElementById('projectSelect').value) {
         if (!confirm("참조할 웹소설 프로젝트가 선택되지 않았습니다. 캐릭터/배경 설정 없이 분석을 진행할까요?\n(프로젝트를 선택하면 더 정확한 캐릭터 묘사가 가능합니다.)")) {
@@ -439,7 +566,10 @@ async function startExtraction() {
                 body: JSON.stringify({
                     title: "콘티 분석: " + (text.substring(0, 15) + "..."),
                     file_id: currentFileId || 0,
-                    description: text.substring(0, 100)
+                    episode_id: episodeIds.length > 0 ? episodeIds[0] : null, 
+                    description: text.substring(0, 100),
+                    analysis_prompt: analysisPrompt,
+                    gen_prompt: genPrompt
                 })
             });
             
@@ -460,9 +590,13 @@ async function startExtraction() {
             body: JSON.stringify({
                 text: text,
                 file_id: currentFileId || 0,
+                episode_ids: episodeIds, 
+                graph_episode_titles: graphEpisodeTitles, // GraphRAG 회차 제목들 추가
                 project_id: currentProjectId,
                 analysis_model: analysisModel,
-                gen_model: genModel
+                gen_model: genModel,
+                analysis_prompt: analysisPrompt,
+                gen_prompt: genPrompt
             })
         });
         
@@ -485,6 +619,16 @@ async function loadProjectDetails(projectId) {
     const res = await fetch(`/webtoon-conti/api/projects/${projectId}`);
     const data = await res.json();
     
+    // 프롬프트 정보 로드
+    if (data.project) {
+        if (data.project.analysis_prompt) {
+            document.getElementById('analysisPrompt').value = data.project.analysis_prompt;
+        }
+        if (data.project.gen_prompt) {
+            document.getElementById('genPrompt').value = data.project.gen_prompt;
+        }
+    }
+
     document.getElementById('panelListHeader').classList.remove('d-none');
     document.getElementById('panelListHeader').classList.add('d-flex');
     document.getElementById('panelCount').innerText = data.panels.length;
@@ -562,6 +706,7 @@ function renderSample(s, finalPath) {
 
 async function generateSamples(panelId) {
     const model = document.getElementById('genModelSelect').value;
+    const genPrompt = document.getElementById('genPrompt').value;
     const container = document.getElementById(`samples-${panelId}`);
     
     const isDirectAI = model && (model.toLowerCase().includes('imagen') || model.toLowerCase().includes('gemini'));
@@ -580,7 +725,8 @@ async function generateSamples(panelId) {
             body: JSON.stringify({ 
                 panel_id: panelId, 
                 sample_count: 3,
-                model: model 
+                model: model,
+                gen_prompt: genPrompt
             })
         });
         
@@ -709,6 +855,50 @@ async function openLoadModal() {
     modal.show();
 }
 
+async function loadGlobalPrompts() {
+    try {
+        const res = await fetch('/webtoon-conti/api/global-prompts');
+        const data = await res.json();
+        if (data.analysis_prompt) document.getElementById('analysisPrompt').value = data.analysis_prompt;
+        if (data.gen_prompt) document.getElementById('genPrompt').value = data.gen_prompt;
+    } catch (e) {
+        console.error("Global prompts load error:", e);
+    }
+}
+
+async function savePrompts() {
+    const analysisPrompt = document.getElementById('analysisPrompt').value;
+    const genPrompt = document.getElementById('genPrompt').value;
+    
+    try {
+        // 1. 먼저 전역 설정으로 저장 (프로젝트 유무와 관계없이)
+        await fetch('/webtoon-conti/api/global-prompts', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({
+                analysis_prompt: analysisPrompt,
+                gen_prompt: genPrompt
+            })
+        });
+
+        // 2. 현재 작업 중인 프로젝트가 있다면 프로젝트에도 저장
+        if (currentProjectId) {
+            await fetch(`/webtoon-conti/api/projects/${currentProjectId}/prompts`, {
+                method: 'PUT',
+                headers: {'Content-Type': 'application/json'},
+                body: JSON.stringify({
+                    analysis_prompt: analysisPrompt,
+                    gen_prompt: genPrompt
+                })
+            });
+        }
+        
+        alert("프롬프트 설정이 기본값으로 저장되었습니다.");
+    } catch (e) {
+        alert("프롬프트 저장 중 오류가 발생했습니다: " + e.message);
+    }
+}
+
 function loadProjectAndCloseModal(id) {
     const modalEl = document.getElementById('loadProjectModal');
     const modal = bootstrap.Modal.getInstance(modalEl);
@@ -725,6 +915,7 @@ function resetPage() {
 document.addEventListener('DOMContentLoaded', () => {
     loadModels();
     loadNovelProjects();
+    loadGlobalPrompts(); // 전역 프롬프트 불러오기 추가
 });
 </script>
 {% endblock %}

templates/webtoon_line_art_challenge.html

@@ -0,0 +1,648 @@
+{% extends "creation_base.html" %}
+
+{% block title %}웹툰 선화 도전 - SOYMEDIA{% endblock %}
+
+{% block nav %}
+    {% set admin_nav_title = '웹툰 선화 도전' %}
+    {% set admin_nav_icon = '🎨' %}
+    {% include '_admin_nav.html' %}
+{% endblock %}
+
+{% block extra_css %}
+<style>
+    .character-card {
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        background: white;
+        margin-bottom: 1.5rem;
+        overflow: hidden;
+        transition: all 0.3s;
+    }
+    .character-card:hover {
+        box-shadow: 0 4px 15px rgba(0,0,0,0.1);
+        transform: translateY(-2px);
+    }
+    .character-header {
+        padding: 1rem 1.5rem;
+        background: #f8f9fa;
+        border-bottom: 1px solid var(--border);
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+    }
+    .character-body {
+        padding: 1.5rem;
+    }
+    .gen-input-column {
+        display: flex;
+        flex-direction: column;
+    }
+    #genPrompt {
+        flex-grow: 1;
+        min-height: 400px;
+    }
+    .result-image-container {
+        width: 100%;
+        max-width: 800px;
+        margin: 0 auto;
+        border-radius: 12px;
+        overflow: hidden;
+        background: #f0f0f0;
+        min-height: 400px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        border: 1px solid var(--border);
+        box-shadow: var(--shadow);
+    }
+    .result-image {
+        max-width: 100%;
+        height: auto;
+        display: block;
+    }
+    .character-item {
+        display: flex;
+        align-items: center;
+        gap: 12px;
+        padding: 12px !important;
+        transition: background 0.2s;
+    }
+    .character-item:hover {
+        background-color: #f0f7ff;
+    }
+    .character-item-img {
+        width: 50px;
+        height: 50px;
+        border-radius: 8px;
+        object-fit: cover;
+        background: #eee;
+        flex-shrink: 0;
+    }
+    .character-item-info {
+        flex-grow: 1;
+        overflow: hidden;
+    }
+    .character-item-name {
+        font-weight: 600;
+        font-size: 14px;
+        color: var(--text-primary);
+        margin-bottom: 2px;
+    }
+    .character-item-desc {
+        font-size: 12px;
+        color: var(--text-secondary);
+        white-space: nowrap;
+        text-overflow: ellipsis;
+        overflow: hidden;
+    }
+    .character-img-gallery {
+        display: flex;
+        gap: 4px;
+        margin-top: 4px;
+        overflow-x: auto;
+        padding-bottom: 4px;
+    }
+    .character-img-gallery img {
+        width: 30px;
+        height: 30px;
+        border-radius: 4px;
+        object-fit: cover;
+        cursor: pointer;
+        border: 1px solid transparent;
+    }
+    .character-img-gallery img:hover {
+        border-color: var(--accent);
+    }
+    
+    /* 그림 콘티 갤러리 스타일 */
+    .conty-gallery {
+        display: grid;
+        grid-template-columns: repeat(auto-fill, minmax(100px, 1fr));
+        gap: 12px;
+        margin-top: 12px;
+    }
+    .conty-item {
+        position: relative;
+        aspect-ratio: 1;
+        border-radius: 8px;
+        overflow: hidden;
+        border: 2px solid transparent;
+        cursor: pointer;
+        transition: all 0.2s;
+    }
+    .conty-item:hover {
+        transform: scale(1.02);
+    }
+    .conty-item.selected {
+        border-color: var(--accent);
+        box-shadow: 0 0 0 2px rgba(26, 115, 232, 0.2);
+    }
+    .conty-item img {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+    }
+    .conty-item .conty-remove {
+        position: absolute;
+        top: 4px;
+        right: 4px;
+        background: rgba(220, 35, 67, 0.8);
+        color: white;
+        border: none;
+        border-radius: 4px;
+        width: 20px;
+        height: 20px;
+        font-size: 12px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        opacity: 0;
+        transition: opacity 0.2s;
+    }
+    .conty-item:hover .conty-remove {
+        opacity: 1;
+    }
+    .conty-selection-badge {
+        position: absolute;
+        bottom: 4px;
+        left: 4px;
+        background: var(--accent);
+        color: white;
+        padding: 2px 6px;
+        border-radius: 4px;
+        font-size: 10px;
+        font-weight: bold;
+        display: none;
+    }
+    .conty-item.selected .conty-selection-badge {
+        display: block;
+    }
+</style>
+{% endblock %}
+
+{% block content %}
+<!-- 상단 헤더 영역 -->
+<div class="dashboard-header d-flex justify-content-between align-items-center mb-4">
+    <div>
+        <h1 class="title-main mb-1">웹툰 선화 도전</h1>
+        <p class="text-meta mb-0">웹툰의 선화 스타일을 실험하고 고퀄리티 라인 아트를 생성합니다. <br />
+            * '선화 생성 프롬프트'에 자주 사용하시는 명령어나 설정을 저장하실 수 있습니다. <br />
+            * 캐릭터 ��석 모델을 사용하여 원작 설정을 바탕으로 최적화된 선화 프롬프트를 구성할 수 있습니다.
+        </p>
+    </div>
+</div>
+
+<!-- AI 설정 바 -->
+<div class="clean-card mb-4 py-2 px-4 d-flex align-items-center gap-4" style="cursor: default;">
+    <div class="d-flex align-items-center gap-2">
+        <label for="analysisModelSelect" class="small fw-bold text-secondary mb-0">
+            <i class="fas fa-search me-1 text-primary"></i> 분석 모델:
+        </label>
+        <select id="analysisModelSelect" class="form-select form-select-sm border-0 bg-transparent shadow-none" style="width: auto; min-width: 180px; font-weight: 600;">
+            <option value="">모델 로딩 중...</option>
+        </select>
+    </div>
+    <div class="vr"></div>
+    <div class="d-flex align-items-center gap-2">
+        <label for="modelSelect" class="small fw-bold text-secondary mb-0">
+            <i class="fas fa-paint-brush me-1 text-success"></i> 생성 모델:
+        </label>
+        <select id="modelSelect" class="form-select form-select-sm border-0 bg-transparent shadow-none" style="width: auto; min-width: 180px; font-weight: 600;">
+            <option value="">모델 로딩 중...</option>
+        </select>
+    </div>
+    <button class="btn btn-sm text-muted p-0 hover-rotate" onclick="loadModels()">
+        <i class="fas fa-sync-alt"></i>
+    </button>
+</div>
+
+<div class="row g-4 align-items-stretch mb-5">
+    <!-- 왼쪽: 프롬프트 입력 -->
+    <div class="col-lg-8 gen-input-column">
+        <div class="clean-card h-100 p-4">
+            <div class="d-flex justify-content-between align-items-center mb-3">
+                <h2 class="h5 fw-bold mb-0">선화 생성 프롬프트</h2>
+                <div class="d-flex gap-2">
+                    <button class="btn btn-sm btn-outline-primary" onclick="saveGlobalPrompt()">
+                        <i class="fas fa-save me-1"></i> 기본값으로 저장
+                    </button>
+                </div>
+            </div>
+            <textarea id="genPrompt" class="form-control border-0 bg-light p-4" 
+                      style="border-radius: 12px; font-size: 14px; line-height: 1.6; min-height: 300px;"
+                      placeholder="생성할 선화의 스타일, 구도, 캐릭터 특징 등을 입력하세요."></textarea>
+            
+            <!-- 그림 콘티 업로드 및 관리 섹션 -->
+            <div class="mt-4 pt-4 border-top">
+                <div class="d-flex justify-content-between align-items-center mb-3">
+                    <h3 class="h6 fw-bold mb-0"><i class="fas fa-images me-2 text-primary"></i>사용할 그림 콘티 (참조 이미지)</h3>
+                    <div class="d-flex gap-2">
+                        <input type="file" id="contyUpload" class="d-none" accept="image/*" multiple onchange="uploadContyImages(this.files)">
+                        <button class="btn btn-sm btn-outline-secondary" onclick="document.getElementById('contyUpload').click()">
+                            <i class="fas fa-upload me-1"></i> 콘티 업로드
+                        </button>
+                    </div>
+                </div>
+                <div id="contyGallery" class="conty-gallery">
+                    <div class="text-center w-100 py-4 text-muted border rounded-3 bg-light" style="grid-column: 1/-1;">
+                        <i class="fas fa-cloud-upload-alt fa-2x mb-2 d-block"></i>
+                        업로드된 콘티가 없습니다. 선화 제작의 기반이 될 그림 콘티를 업로드해주세요.
+                    </div>
+                </div>
+                <p class="text-muted small mt-2"><i class="fas fa-info-circle me-1"></i> 업로드된 콘티 중 하나를 선택하면 선화 생성 시 참조 이미지로 사용됩니다.</p>
+            </div>
+            
+            <div class="mt-4">
+                <button id="generateBtn" class="db-btn db-btn-primary w-100 py-3 fw-bold" onclick="generateLineArt()">
+                    <i class="fas fa-wand-sparkles me-2"></i> 선화 이미지 생성 시작
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- 오른쪽: 설정 및 참조 -->
+    <div class="col-lg-4">
+        <div class="clean-card p-4 h-100">
+            <h2 class="h5 fw-bold mb-4">참조 설정</h2>
+            
+            <div class="mb-4">
+                <label class="form-label small fw-bold text-secondary">참조 웹소설 프로젝트</label>
+                <select id="projectSelect" class="form-select border-0 shadow-sm mb-2" onchange="loadCharacters(this.value)">
+                    <option value="">-- 프로젝트 선택 --</option>
+                </select>
+                <p class="text-muted small mb-0"><i class="fas fa-info-circle me-1"></i> 프로젝트를 선택하면 등록된 메인 캐릭터 목록이 나타납니다.</p>
+            </div>
+
+            <div class="mb-4">
+                <div class="d-flex justify-content-between align-items-center mb-2">
+                    <label class="form-label small fw-bold text-secondary mb-0">캐릭터 목록</label>
+                    <div class="form-check form-switch">
+                        <input class="form-check-input" type="checkbox" id="includeCharImages" checked>
+                        <label class="form-check-label small text-muted" for="includeCharImages">이미지 정보 포함</label>
+                    </div>
+                </div>
+                <div id="characterList" class="bg-light border rounded p-2" style="max-height: 300px; overflow-y: auto; min-height: 100px;">
+                    <p class="text-muted small mb-0 p-2 text-center">프로젝트를 먼저 선택해주세요.</p>
+                </div>
+            </div>
+        </div>
+    </div>
+</div>
+
+<!-- 하단 결과 영역 -->
+<div id="resultArea" class="d-none mb-5">
+    <div class="clean-card p-4">
+        <div class="d-flex justify-content-between align-items-center mb-4">
+            <h2 class="h5 fw-bold mb-0">선화 생성 결과</h2>
+            <a id="downloadLink" href="#" class="db-btn db-btn-outline py-2" download>
+                <i class="fas fa-download"></i> 이미지 다운로드
+            </a>
+        </div>
+        <div class="result-image-container" id="imageContainer">
+            <div class="text-center py-5">
+                <div class="spinner-border text-primary mb-3" role="status"></div>
+                <p class="text-muted mb-0" id="loadingText">이미지를 생성하고 있습니다. 잠시만 기다려주세요...</p>
+            </div>
+        </div>
+    </div>
+</div>
+
+<script>
+let currentFileId = null;
+const defaultAnalysisModel = "{{ default_analysis_model }}";
+let uploadedContyImages = [];
+let selectedContyImageUrl = null;
+
+async function loadModels() {
+    const genSelect = document.getElementById('modelSelect');
+    const analysisSelect = document.getElementById('analysisModelSelect');
+    try {
+        const response = await fetch('/api/ollama/models?all=true');
+        const data = await response.json();
+        
+        if (data.models && data.models.length > 0) {
+            const optionsHtml = ['<option value="">모델 선택...</option>'];
+            const analysisOptionsHtml = ['<option value="">모델 선택...</option>'];
+            
+            // Gemini 모델 그룹
+            const geminiModels = data.models.filter(m => m.type === 'gemini');
+            if (geminiModels.length > 0) {
+                optionsHtml.push('<optgroup label="✨ Google Gemini">');
+                analysisOptionsHtml.push('<optgroup label="✨ Google Gemini">');
+                geminiModels.forEach(m => {
+                    const label = m.name.startsWith('gemini:') ? m.name.substring(7) : m.name;
+                    const genSelected = m.name.includes('gemini-3-pro-image-preview') ? 'selected' : '';
+                    
+                    // 분석 모델 기본값 설정
+                    let analysisSelected = '';
+                    if (defaultAnalysisModel) {
+                        if (m.name === defaultAnalysisModel || m.name === `gemini:${defaultAnalysisModel}`) {
+                            analysisSelected = 'selected';
+                        }
+                    } else if (m.name.includes('gemini-1.5-flash')) {
+                        analysisSelected = 'selected';
+                    }
+                    
+                    optionsHtml.push(`<option value="${m.name}" ${genSelected}>${label}</option>`);
+                    analysisOptionsHtml.push(`<option value="${m.name}" ${analysisSelected}>${label}</option>`);
+                });
+                optionsHtml.push('</optgroup>');
+                analysisOptionsHtml.push('</optgroup>');
+            }
+            
+            // Ollama 모델 그룹
+            const ollamaModels = data.models.filter(m => m.type !== 'gemini');
+            if (ollamaModels.length > 0) {
+                optionsHtml.push('<optgroup label="🤖 Ollama (Local)">');
+                analysisOptionsHtml.push('<optgroup label="🤖 Ollama (Local)">');
+                ollamaModels.forEach(m => {
+                    let analysisSelected = (m.name === defaultAnalysisModel) ? 'selected' : '';
+                    optionsHtml.push(`<option value="${m.name}">${m.name}</option>`);
+                    analysisOptionsHtml.push(`<option value="${m.name}" ${analysisSelected}>${m.name}</option>`);
+                });
+                optionsHtml.push('</optgroup>');
+                analysisOptionsHtml.push('</optgroup>');
+            }
+            
+            genSelect.innerHTML = optionsHtml.join('');
+            analysisSelect.innerHTML = analysisOptionsHtml.join('');
+        }
+    } catch (error) {
+        console.error('모델 로드 오류:', error);
+        genSelect.innerHTML = '<option value="">로드 실패</option>';
+        analysisSelect.innerHTML = '<option value="">로드 실패</option>';
+    }
+}
+
+async function loadNovelProjects() {
+    const select = document.getElementById('projectSelect');
+    try {
+        const res = await fetch('/api/files?sort=uploaded_at_desc&public_only=true');
+        const data = await res.json();
+        
+        if (data.files && data.files.length > 0) {
+            data.files.forEach(f => {
+                const opt = document.createElement('option');
+                opt.value = f.id;
+                opt.textContent = f.original_filename;
+                select.appendChild(opt);
+            });
+        }
+    } catch (e) {
+        console.error("Project load error:", e);
+    }
+}
+
+async function loadCharacters(fileId) {
+    if (!fileId) return;
+    currentFileId = fileId;
+    const list = document.getElementById('characterList');
+    const promptArea = document.getElementById('genPrompt');
+    list.innerHTML = '<div class="text-center p-3"><div class="spinner-border spinner-border-sm text-primary"></div></div>';
+    
+    try {
+        const res = await fetch('/creation/api/character/extract-main', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({ file_id: fileId })
+        });
+        const data = await res.json();
+        
+        // 전역 변수에 프로젝트 배경 정보 저장 (분석 시 사용)
+        window.projectContext = `세계관: ${data.world_view || '정보 없음'}\n줄거리: ${data.story || '정보 없음'}\n기타: ${data.others || '정보 없음'}`;
+
+        // 1. Parent Chunk 정보(세계관, 기타) 및 캐릭터 정보를 프롬프트에 추가
+        let contextPrompt = '';
+        if (data.world_view || data.others) {
+            if (data.world_view) contextPrompt += `### 세계관 설명\n${data.world_view}\n\n`;
+            if (data.others) contextPrompt += `### 기타 설정\n${data.others}\n\n`;
+        }
+        
+        // 2. 캐릭터 목록 정보 추가
+        if (data.characters && data.characters.length > 0) {
+            contextPrompt += `### 캐릭터 정보 목록\n`;
+            data.characters.forEach(c => {
+                contextPrompt += `- [${c.name}]: ${c.description || '정보 없음'}\n`;
+            });
+            contextPrompt += `\n`;
+        }
+
+        if (contextPrompt && confirm("선택한 프로젝트의 '세계관/설정' 및 '캐릭터 정보'를 선화 프롬프트에 추가할까요?")) {
+            promptArea.value = contextPrompt + promptArea.value;
+        }
+
+        if (data.characters && data.characters.length > 0) {
+            list.innerHTML = data.characters.map((c, idx) => {
+                const mainImg = c.image_path ? `/uploads/${c.image_path}` : '';
+                const hasImages = c.images && c.images.length > 0;
+                
+                return `
+                    <div class="border-bottom character-item cursor-default" 
+                         data-char-index="${idx}">
+                        ${mainImg ? `<img src="${mainImg}" class="character-item-img">` : `<div class="character-item-img d-flex align-items-center justify-content-center text-muted"><i class="fas fa-user"></i></div>`}
+                        <div class="character-item-info">
+                            <div class="character-item-name">${c.name}</div>
+                            <div class="character-item-desc text-muted small">${c.description || '설명 없음'}</div>
+                            ${hasImages ? `
+                                <div class="character-img-gallery mt-1">
+                                    ${c.images.map(img => `<img src="/uploads/${img.image_path}" onclick="event.stopPropagation(); window.open('/uploads/${img.image_path}', '_blank')" title="이미지 크게 보기">`).join('')}
+                                </div>
+                            ` : ''}
+                        </div>
+                    </div>
+                `;
+            }).join('');
+            
+            window.extractedCharacters = data.characters;
+        } else {
+            list.innerHTML = '<p class="text-muted small mb-0 p-2 text-center">분석된 캐릭터가 없습니다.</p>';
+        }
+    } catch (e) {
+        list.innerHTML = '<p class="text-danger small mb-0 p-2 text-center">로드 실패</p>';
+    }
+}
+
+async function loadGlobalLineArtPrompt() {
+    try {
+        const res = await fetch('/creation/api/line-art-challenge/global-prompt');
+        const data = await res.json();
+        if (data.prompt) {
+            document.getElementById('genPrompt').value = data.prompt;
+        }
+    } catch (e) {
+        console.error("Prompt load error:", e);
+    }
+}
+
+async function uploadContyImages(files) {
+    if (!files || files.length === 0) return;
+    
+    for (const file of files) {
+        const formData = new FormData();
+        formData.append('image', file);
+        
+        try {
+            const response = await fetch('/creation/api/upload-image', {
+                method: 'POST',
+                body: formData
+            });
+            const data = await response.json();
+            
+            if (data.success) {
+                uploadedContyImages.push(data.image_url);
+                // 첫 이미지면 자동 선택
+                if (!selectedContyImageUrl) {
+                    selectedContyImageUrl = data.image_url;
+                }
+            } else {
+                alert(`업로드 실패: ${data.error}`);
+            }
+        } catch (error) {
+            console.error('Upload error:', error);
+            alert('업로드 중 오류가 발생했습니다.');
+        }
+    }
+    renderContyGallery();
+}
+
+function renderContyGallery() {
+    const gallery = document.getElementById('contyGallery');
+    if (uploadedContyImages.length === 0) {
+        gallery.innerHTML = `
+            <div class="text-center w-100 py-4 text-muted border rounded-3 bg-light" style="grid-column: 1/-1;">
+                <i class="fas fa-cloud-upload-alt fa-2x mb-2 d-block"></i>
+                업로드된 콘티가 없습니다. 선화 제작의 기반이 될 그림 콘티를 업로드해주세요.
+            </div>
+        `;
+        return;
+    }
+    
+    gallery.innerHTML = uploadedContyImages.map(url => `
+        <div class="conty-item ${url === selectedContyImageUrl ? 'selected' : ''}" onclick="selectContyImage('${url}')">
+            <img src="${url}" alt="Conty">
+            <div class="conty-selection-badge">선택됨</div>
+            <button class="conty-remove" onclick="event.stopPropagation(); removeContyImage('${url}')">
+                <i class="fas fa-times"></i>
+            </button>
+        </div>
+    `).join('');
+}
+
+function selectContyImage(url) {
+    selectedContyImageUrl = (selectedContyImageUrl === url) ? null : url;
+    renderContyGallery();
+}
+
+function removeContyImage(url) {
+    uploadedContyImages = uploadedContyImages.filter(u => u !== url);
+    if (selectedContyImageUrl === url) {
+        selectedContyImageUrl = null;
+    }
+    renderContyGallery();
+}
+
+async function generateLineArt() {
+    const prompt = document.getElementById('genPrompt').value.trim();
+    const model = document.getElementById('modelSelect').value;
+    const btn = document.getElementById('generateBtn');
+    const resultArea = document.getElementById('resultArea');
+    const imageContainer = document.getElementById('imageContainer');
+    const includeCharImages = document.getElementById('includeCharImages').checked;
+    
+    if (!prompt) return alert("프롬프트를 입력해주세요.");
+    if (!model) return alert("모델을 선택해주세요.");
+    
+    btn.disabled = true;
+    btn.innerHTML = '<span class="spinner-border spinner-border-sm me-2"></span>선화 생성 중...';
+    
+    resultArea.classList.remove('d-none');
+    imageContainer.innerHTML = `
+        <div class="text-center py-5">
+            <div class="spinner-border text-primary mb-3" role="status"></div>
+            <p class="text-muted mb-0">고퀄리티 선화를 생성하고 있습니다. 잠시만 기다려주세요...</p>
+        </div>
+    `;
+    
+    resultArea.scrollIntoView({ behavior: 'smooth' });
+    
+    // 이미지 URL 리스트 수집
+    const imageUrls = [];
+    
+    // 1. 선택된 그림 콘티 이미지를 첫 번째로 추가 (가장 중요)
+    if (selectedContyImageUrl) {
+        imageUrls.push(selectedContyImageUrl);
+    }
+    
+    // 2. 캐릭터 이미지 정보 포함 시 추가
+    if (includeCharImages && window.extractedCharacters && window.extractedCharacters.length > 0) {
+        window.extractedCharacters.forEach(c => {
+            if (c.image_path) {
+                // 중복 방지하며 추가
+                const fullPath = `/uploads/${c.image_path}`;
+                if (!imageUrls.includes(fullPath)) {
+                    imageUrls.push(fullPath);
+                }
+            }
+        });
+    }
+    
+    try {
+        const res = await fetch('/creation/api/generate-image', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({
+                prompt: prompt,
+                model_name: model,
+                image_urls: imageUrls // 수집된 모든 이미지 URL 전달
+            })
+        });
+        
+        const data = await res.json();
+        if (data.success) {
+            imageContainer.innerHTML = `<img src="${data.image_url}" class="result-image" alt="Generated Line Art">`;
+            document.getElementById('downloadLink').href = data.image_url;
+        } else {
+            alert("생성 실패: " + (data.error || "알 수 없는 오류"));
+            imageContainer.innerHTML = '<p class="text-danger small p-3">이미지 생성에 실패했습니다.</p>';
+        }
+    } catch (e) {
+        console.error("Generation error:", e);
+        alert("통신 오류가 발생했습니다.");
+        imageContainer.innerHTML = '<p class="text-danger small p-3">통신 오류가 발생했습니다.</p>';
+    } finally {
+        btn.disabled = false;
+        btn.innerHTML = '<i class="fas fa-wand-sparkles me-2"></i> 선화 이미지 생성 시작';
+    }
+}
+
+async function loadGlobalPrompt() {
+    try {
+        const res = await fetch('/creation/api/line-art-challenge/global-prompt');
+        const data = await res.json();
+        if (data.prompt) {
+            document.getElementById('genPrompt').value = data.prompt;
+        }
+    } catch (e) {}
+}
+
+async function saveGlobalPrompt() {
+    const prompt = document.getElementById('genPrompt').value;
+    try {
+        const res = await fetch('/creation/api/line-art-challenge/global-prompt', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({ prompt: prompt })
+        });
+        if (res.ok) alert("선화 도전 기본 프롬프트로 저장되었습니다.");
+    } catch (e) {
+        alert("저장 실패");
+    }
+}
+
+document.addEventListener('DOMContentLoaded', () => {
+    loadModels();
+    loadNovelProjects();
+    loadGlobalPrompt();
+});
+</script>
+{% endblock %}