AGI-Screenplay-Pro

Running

App Files Files Community

openfree commited on Aug 8

Commit

3335e97

verified ·

1 Parent(s): 7e3f44f

Update app.py

Browse files

Files changed (1) hide show

app.py +647 -607

app.py CHANGED Viewed

@@ -17,238 +17,197 @@ from dataclasses import dataclass, field, asdict
 from collections import defaultdict
 import random
-# --- Logging setup ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
-# --- Environment variables and constants ---
 FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
 API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
 MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
-DB_PATH = "screenplay_sessions_v2.db"
-# Enhanced screenplay length settings
 SCREENPLAY_LENGTHS = {
-   "movie": {"pages": 120, "description": "Feature Film (110-130 pages)", "min_pages": 110},
-   "tv_drama": {"pages": 60, "description": "TV Drama Episode (55-65 pages)", "min_pages": 55},
-   "ott_series": {"pages": 50, "description": "OTT Series Episode (45-55 pages)", "min_pages": 45},
-   "short_film": {"pages": 20, "description": "Short Film (15-25 pages)", "min_pages": 15}
 }
-# --- Environment validation ---
 if not FIREWORKS_API_KEY:
-   logger.error("FIREWORKS_API_KEY not set. Application will not work properly.")
    FIREWORKS_API_KEY = "dummy_token_for_testing"
-if not BRAVE_SEARCH_API_KEY:
-   logger.warning("BRAVE_SEARCH_API_KEY not set. Web search features will be disabled.")
-# --- Global variables ---
 db_lock = threading.Lock()
-# Enhanced genre templates
 GENRE_TEMPLATES = {
-   "action": {
-       "pacing": "fast",
-       "scene_length": "short",
        "dialogue_ratio": 0.3,
-       "key_elements": ["set pieces", "physical conflict", "urgency", "stakes escalation", "hero moments"],
-       "structure_beats": ["explosive opening", "pursuit/chase", "confrontation", "climactic battle", "hero's triumph"],
        "scene_density": 1.2,
        "action_description_ratio": 0.6
    },
-   "thriller": {
-       "pacing": "fast",
-       "scene_length": "short",
        "dialogue_ratio": 0.35,
-       "key_elements": ["suspense", "twists", "paranoia", "time pressure", "revelations"],
-       "structure_beats": ["hook", "mystery deepens", "false victory", "revelation", "final confrontation"],
        "scene_density": 1.1,
        "action_description_ratio": 0.5
    },
-   "drama": {
-       "pacing": "moderate",
-       "scene_length": "medium",
        "dialogue_ratio": 0.55,
-       "key_elements": ["character depth", "emotional truth", "relationships", "internal conflict", "transformation"],
-       "structure_beats": ["status quo", "catalyst", "debate", "commitment", "complications", "crisis", "resolution"],
        "scene_density": 0.9,
        "action_description_ratio": 0.3
    },
-   "comedy": {
-       "pacing": "fast",
-       "scene_length": "short",
        "dialogue_ratio": 0.65,
-       "key_elements": ["setup/payoff", "timing", "character comedy", "escalation", "running gags"],
-       "structure_beats": ["funny opening", "complication", "misunderstandings multiply", "chaos peak", "resolution with callback"],
        "scene_density": 1.0,
        "action_description_ratio": 0.35
    },
-   "horror": {
-       "pacing": "variable",
-       "scene_length": "mixed",
        "dialogue_ratio": 0.3,
-       "key_elements": ["atmosphere", "dread", "jump scares", "gore/psychological", "isolation"],
-       "structure_beats": ["normal world", "first sign", "investigation", "first attack", "survival", "final confrontation"],
        "scene_density": 1.0,
        "action_description_ratio": 0.55
    },
-   "sci-fi": {
-       "pacing": "moderate",
-       "scene_length": "medium",
        "dialogue_ratio": 0.45,
-       "key_elements": ["world building", "technology", "concepts", "visual spectacle", "philosophical questions"],
-       "structure_beats": ["ordinary world", "discovery", "new world", "complications", "understanding", "choice", "new normal"],
        "scene_density": 0.95,
        "action_description_ratio": 0.45
    },
-   "romance": {
-       "pacing": "moderate",
-       "scene_length": "medium",
        "dialogue_ratio": 0.6,
-       "key_elements": ["chemistry", "obstacles", "emotional moments", "intimacy", "vulnerability"],
-       "structure_beats": ["meet cute", "attraction", "first conflict", "deepening", "crisis/breakup", "grand gesture", "together"],
        "scene_density": 0.85,
        "action_description_ratio": 0.25
    }
 }
-# Enhanced screenplay stages
-SCREENPLAY_STAGES = [
-    ("producer", "🎬 Producer: Concept Development & Market Analysis"),
-    ("story_developer", "📖 Story Developer: Extended Synopsis & Three-Act Structure"),
-    ("character_designer", "👥 Character Designer: Deep Character Profiles"),
-    ("world_builder", "🌍 World Builder: Setting & Atmosphere"),
-    ("critic_structure", "🔍 Structure Critic: Story Review"),
-    ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
-    # Act 1 - 4 stages
-    ("screenwriter", "✍️ Act 1 - Setup (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Act 1 - Polish & Expand"),
-    ("script_doctor", "🔧 Act 1 - Review & Notes"),
-    ("screenwriter", "✍️ Act 1 - Final Extended Version"),
-    # Act 2A - 4 stages
-    ("screenwriter", "✍️ Act 2A - Rising Action (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Act 2A - Polish & Expand"),
-    ("script_doctor", "🔧 Act 2A - Review & Notes"),
-    ("screenwriter", "✍️ Act 2A - Final Extended Version"),
-    # Act 2B - 4 stages
-    ("screenwriter", "✍️ Act 2B - Complications (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Act 2B - Polish & Expand"),
-    ("script_doctor", "🔧 Act 2B - Review & Notes"),
-    ("screenwriter", "✍️ Act 2B - Final Extended Version"),
-    # Act 3 - 4 stages
-    ("screenwriter", "✍️ Act 3 - Resolution (25%) - Initial Draft"),
-    ("screenwriter", "✍️ Act 3 - Polish & Expand"),
-    ("script_doctor", "🔧 Act 3 - Review & Notes"),
-    ("screenwriter", "✍️ Act 3 - Final Extended Version"),
-    ("dialogue_specialist", "💬 Dialogue Enhancement"),
-    ("final_reviewer", "🎭 Final Review & Polish"),
 ]
-# Save the Cat Beat Sheet
-SAVE_THE_CAT_BEATS = {
-   1: {"name": "Opening Image", "percentage": "0-1%"},
-   2: {"name": "Setup", "percentage": "1-10%"},
-   3: {"name": "Theme Stated", "percentage": "5%"},
-   4: {"name": "Catalyst", "percentage": "10%"},
-   5: {"name": "Debate", "percentage": "10-20%"},
-   6: {"name": "Break into Two", "percentage": "20%"},
-   7: {"name": "B Story", "percentage": "22%"},
-   8: {"name": "Fun and Games", "percentage": "20-50%"},
-   9: {"name": "Midpoint", "percentage": "50%"},
-   10: {"name": "Bad Guys Close In", "percentage": "50-75%"},
-   11: {"name": "All Is Lost", "percentage": "75%"},
-   12: {"name": "Dark Night of the Soul", "percentage": "75-80%"},
-   13: {"name": "Break into Three", "percentage": "80%"},
-   14: {"name": "Finale", "percentage": "80-99%"},
-   15: {"name": "Final Image", "percentage": "99-100%"}
-}
-# --- Data classes ---
-@dataclass
-class ScreenplayBible:
-   """Enhanced screenplay bible"""
-   title: str = ""
-   logline: str = ""
-   genre: str = ""
-   subgenre: str = ""
-   tone: str = ""
-   themes: List[str] = field(default_factory=list)
-   protagonist: Dict[str, Any] = field(default_factory=dict)
-   antagonist: Dict[str, Any] = field(default_factory=dict)
-   supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
-   three_act_structure: Dict[str, str] = field(default_factory=dict)
-   save_the_cat_beats: Dict[int, str] = field(default_factory=dict)
-   time_period: str = ""
-   primary_locations: List[Dict[str, str]] = field(default_factory=list)
-   world_rules: List[str] = field(default_factory=list)
-   visual_style: str = ""
-   key_imagery: List[str] = field(default_factory=list)
 @dataclass
-class SceneBreakdown:
-   """Scene information"""
-   scene_number: int
-   act: int
-   location: str
-   time_of_day: str
-   characters: List[str]
-   purpose: str
-   conflict: str
-   page_count: float
-   beat: str = ""
-   transition: str = "CUT TO:"
 @dataclass
-class CharacterProfile:
-   """Character profile"""
-   name: str
-   role: str
-   archetype: str
-   want: str
-   need: str
-   backstory: str
-   personality: List[str]
-   speech_pattern: str
-   character_arc: str
-   relationships: Dict[str, str] = field(default_factory=dict)
-   first_appearance: str = ""
-# --- Core logic classes ---
-class ScreenplayTracker:
-    """Screenplay tracker"""
-    def __init__(self):
-        self.screenplay_bible = ScreenplayBible()
-        self.scenes: List[SceneBreakdown] = []
-        self.characters: Dict[str, CharacterProfile] = {}
-        self.page_count = 0
-        self.act_pages = {"1": 0, "2A": 0, "2B": 0, "3": 0}
-    def add_scene(self, scene: SceneBreakdown):
-        self.scenes.append(scene)
-        self.page_count += scene.page_count
-    def add_character(self, character: CharacterProfile):
-        self.characters[character.name] = character
-        if character.role == "protagonist":
-            self.screenplay_bible.protagonist = asdict(character)
-        elif character.role == "antagonist":
-            self.screenplay_bible.antagonist = asdict(character)
-        elif character.role == "supporting":
-            self.screenplay_bible.supporting_cast[character.name] = asdict(character)
-    def update_bible(self, key: str, value: Any):
-        if hasattr(self.screenplay_bible, key):
-            setattr(self.screenplay_bible, key, value)
 class ScreenplayDatabase:
-    """Database management"""
     @staticmethod
     def init_db():
         with sqlite3.connect(DB_PATH) as conn:
@@ -262,18 +221,13 @@ class ScreenplayDatabase:
                     screenplay_type TEXT NOT NULL,
                     genre TEXT NOT NULL,
                     target_pages INTEGER,
-                    language TEXT NOT NULL,
                     title TEXT,
                     logline TEXT,
-                    synopsis TEXT,
-                    three_act_structure TEXT,
-                    character_profiles TEXT,
-                    scene_breakdown TEXT,
-                    screenplay_bible TEXT,
-                    final_screenplay TEXT,
                     created_at TEXT DEFAULT (datetime('now')),
                     updated_at TEXT DEFAULT (datetime('now')),
-                    status TEXT DEFAULT 'active',
                     current_stage INTEGER DEFAULT 0,
                     total_pages REAL DEFAULT 0
                 )
@@ -283,28 +237,15 @@ class ScreenplayDatabase:
                 CREATE TABLE IF NOT EXISTS screenplay_stages (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     session_id TEXT NOT NULL,
                     stage_number INTEGER NOT NULL,
                     stage_name TEXT NOT NULL,
-                    role TEXT NOT NULL,
                     content TEXT,
                     page_count REAL DEFAULT 0,
                     status TEXT DEFAULT 'pending',
                     created_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id),
-                    UNIQUE(session_id, stage_number)
-                )
-            ''')
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS screenplay_themes_library (
-                    theme_id TEXT PRIMARY KEY,
-                    theme_text TEXT NOT NULL,
-                    screenplay_type TEXT NOT NULL,
-                    genre TEXT NOT NULL,
-                    language TEXT NOT NULL,
-                    title TEXT,
-                    logline TEXT,
-                    generated_at TEXT DEFAULT (datetime('now'))
                 )
             ''')
@@ -322,101 +263,68 @@ class ScreenplayDatabase:
                 conn.close()
     @staticmethod
-    def create_session(user_query: str, screenplay_type: str, genre: str, language: str) -> str:
         session_id = hashlib.md5(f"{user_query}{screenplay_type}{datetime.now()}".encode()).hexdigest()
         target_pages = SCREENPLAY_LENGTHS[screenplay_type]["pages"]
         with ScreenplayDatabase.get_db() as conn:
             conn.cursor().execute(
                 '''INSERT INTO screenplay_sessions
-                   (session_id, user_query, screenplay_type, genre, target_pages, language)
-                   VALUES (?, ?, ?, ?, ?, ?)''',
-                (session_id, user_query, screenplay_type, genre, target_pages, language)
             )
             conn.commit()
         return session_id
     @staticmethod
-    def save_stage(session_id: str, stage_number: int, stage_name: str,
-                   role: str, content: str, status: str = 'complete'):
-        page_count = 0
-        if role == "screenwriter" and content:
-            page_count = ScreenplayGenerationSystem.calculate_screenplay_pages(content)
         with ScreenplayDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute('''
-                INSERT INTO screenplay_stages
-                (session_id, stage_number, stage_name, role, content, page_count, status)
-                VALUES (?, ?, ?, ?, ?, ?, ?)
-                ON CONFLICT(session_id, stage_number)
-                DO UPDATE SET content=?, page_count=?, status=?, created_at=datetime('now')
-            ''', (session_id, stage_number, stage_name, role, content, page_count, status,
-                  content, page_count, status))
             conn.commit()
     @staticmethod
-    def get_screenplay_content(session_id: str) -> str:
-        with ScreenplayDatabase.get_db() as conn:
-            rows = conn.cursor().execute('''
-                SELECT content FROM screenplay_stages
-                WHERE session_id = ?
-                AND role = 'screenwriter'
-                AND stage_name LIKE '%Final%'
-                ORDER BY stage_number
-            ''', (session_id,)).fetchall()
-            if rows:
-                return '\n\n'.join(row['content'] for row in rows if row['content'])
-            else:
-                rows = conn.cursor().execute('''
-                    SELECT content FROM screenplay_stages
-                    WHERE session_id = ? AND role = 'screenwriter'
-                    ORDER BY stage_number
-                ''', (session_id,)).fetchall()
-                return '\n\n'.join(row['content'] for row in rows if row['content'])
-        return ""
-    @staticmethod
-    def get_active_sessions() -> List[Dict]:
         with ScreenplayDatabase.get_db() as conn:
-            rows = conn.cursor().execute(
-                '''SELECT session_id, title, user_query, screenplay_type, genre,
-                          created_at, current_stage, total_pages
-                   FROM screenplay_sessions
-                   WHERE status = 'active'
-                   ORDER BY updated_at DESC
-                   LIMIT 10'''
-            ).fetchall()
-            return [dict(row) for row in rows]
     @staticmethod
-    def save_random_theme(theme_text: str, screenplay_type: str, genre: str, language: str) -> str:
-        theme_id = hashlib.md5(f"{theme_text}{datetime.now()}".encode()).hexdigest()[:12]
         with ScreenplayDatabase.get_db() as conn:
-            conn.cursor().execute('''
-                INSERT INTO screenplay_themes_library
-                (theme_id, theme_text, screenplay_type, genre, language)
-                VALUES (?, ?, ?, ?, ?)
-            ''', (theme_id, theme_text, screenplay_type, genre, language))
             conn.commit()
-        return theme_id
 class ScreenplayGenerationSystem:
-    """Professional screenplay generation system"""
     def __init__(self):
         self.api_key = FIREWORKS_API_KEY
         self.api_url = API_URL
         self.model_id = MODEL_ID
-        self.screenplay_tracker = ScreenplayTracker()
         self.current_session_id = None
         ScreenplayDatabase.init_db()
     def create_headers(self):
         if not self.api_key or self.api_key == "dummy_token_for_testing":
-            raise ValueError("Valid FIREWORKS_API_KEY is required")
         return {
             "Accept": "application/json",
@@ -424,109 +332,13 @@ class ScreenplayGenerationSystem:
             "Authorization": f"Bearer {self.api_key}"
         }
-    def create_producer_prompt(self, user_query: str, screenplay_type: str,
-                              genre: str, language: str) -> str:
-        lang_prompts = {
-            "Korean": f"""당신은 할리우드 프로듀서입니다. {screenplay_type} 컨셉을 개발하세요.
-**요청사항:** {user_query}
-**타입:** {SCREENPLAY_LENGTHS[screenplay_type]['description']}
-**장르:** {genre}
-**필수 제공 항목:**
-1. **제목 (TITLE)** - 기억하기 쉽고 마케팅 가능한 제목
-2. **로그라인 (LOGLINE)** - 25단어 이내 한 문장
-3. **장르 분���** - 주 장르와 서브 장르
-4. **타겟 관객** - 연령대와 관심사
-5. **비교 작품 (COMPS)** - 성공한 유사 프로젝트 3개
-6. **고유 판매 포인트 (USP)** - 독특한 점
-7. **비주얼 컨셉** - 핵심 이미지 3개""",
-            "English": f"""You are a Hollywood producer. Develop a {screenplay_type} concept.
-**Request:** {user_query}
-**Type:** {SCREENPLAY_LENGTHS[screenplay_type]['description']}
-**Genre:** {genre}
-**Required Elements:**
-1. **TITLE** - Memorable and marketable
-2. **LOGLINE** - One sentence, 25 words max
-3. **GENRE ANALYSIS** - Primary and sub-genre
-4. **TARGET AUDIENCE** - Age range and interests
-5. **COMPARABLE FILMS (COMPS)** - 3 successful similar projects
-6. **UNIQUE SELLING POINT (USP)** - What makes it unique
-7. **VISUAL CONCEPT** - 3 key visual images"""
-        }
-        return lang_prompts.get(language, lang_prompts["English"])
-    def create_screenwriter_prompt(self, act: str, scene_breakdown: str,
-                                  characters: str, previous_acts: str,
-                                  screenplay_type: str, genre: str, language: str,
-                                  is_polish: bool = False, is_final: bool = False) -> str:
-        act_pages = int(SCREENPLAY_LENGTHS[screenplay_type]['pages'] * 0.25)
-        min_lines = int(act_pages * 65)  # Enhanced for longer content
-        if is_final:
-            min_lines = int(min_lines * 1.4)
-            instruction_focus = "final polished extended version"
-        elif is_polish:
-            min_lines = int(min_lines * 1.2)
-            instruction_focus = "enhanced expanded version"
-        else:
-            instruction_focus = "complete detailed draft"
-        lang_prompts = {
-            "Korean": f"""프로 시나리오 작가로서 {act}의 {instruction_focus}을 작성하세요.
-**목표:** {act_pages}페이지 (최소 {min_lines}줄 필수)
-**씬 정보:** {scene_breakdown}
-**캐릭터:** {characters}
-**이전 내용:** {previous_acts if previous_acts else "첫 막입니다."}
-각 씬마다:
-- 최소 5-7페이지 분량
-- 충분한 대화와 액션
-- 디테일한 묘사
-- 감정적 깊이
-반드시 {min_lines}줄 이상 작성하세요.""",
-            "English": f"""As a professional screenwriter, write the {instruction_focus} of {act}.
-**Target:** {act_pages} pages (minimum {min_lines} lines required)
-**Scene Info:** {scene_breakdown}
-**Characters:** {characters}
-**Previous:** {previous_acts if previous_acts else "This is Act 1."}
-For each scene:
-- Minimum 5-7 pages
-- Sufficient dialogue and action
-- Detailed descriptions
-- Emotional depth
-MUST write {min_lines}+ lines."""
-        }
-        return lang_prompts.get(language, lang_prompts["English"])
-    def call_llm_streaming(self, messages: List[Dict[str, str]], role: str,
-                          language: str) -> Generator[str, None, None]:
         try:
-            system_content = f"You are a professional {role} creating high-quality screenplay content."
-            full_messages = [
-                {"role": "system", "content": system_content},
-                *messages
-            ]
             payload = {
                 "model": self.model_id,
-                "messages": full_messages,
-                "max_tokens": 15000,
-                "temperature": 0.8 if role == "screenwriter" else 0.7,
                 "top_p": 1,
                 "top_k": 40,
                 "presence_penalty": 0.2,
@@ -545,7 +357,7 @@ MUST write {min_lines}+ lines."""
             )
             if response.status_code != 200:
-                yield f"❌ API Error: {response.status_code}"
                 return
             buffer = ""
@@ -577,108 +389,290 @@ MUST write {min_lines}+ lines."""
                 yield buffer
         except Exception as e:
-            yield f"❌ Error: {str(e)}"
-    @staticmethod
-    def calculate_screenplay_pages(content: str) -> float:
-        if not content:
-            return 0.0
-        lines = content.split('\n')
-        total_lines = len(lines)
-        return total_lines / 58.0
-    def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
-                                language: str) -> Generator[Tuple[str, List[Dict], str], None, None]:
         try:
-            self.current_session_id = ScreenplayDatabase.create_session(
-                query, screenplay_type, genre, language
-            )
-            stages = []
-            for stage_idx in range(len(SCREENPLAY_STAGES)):
-                role, stage_name = SCREENPLAY_STAGES[stage_idx]
-                if stage_idx >= len(stages):
-                    stages.append({
-                        "name": stage_name,
-                        "status": "active",
-                        "content": "",
-                        "page_count": 0
-                    })
-                else:
-                    stages[stage_idx]["status"] = "active"
-                yield f"🔄 Processing {stage_name}...", stages, self.current_session_id
-                # Generate prompt based on stage
-                if stage_idx == 0:  # Producer
-                    prompt = self.create_producer_prompt(query, screenplay_type, genre, language)
-                elif "Act" in stage_name and role == "screenwriter":
-                    # Determine act and phase
-                    act = "Act 1" if stage_idx < 10 else "Act 2A" if stage_idx < 14 else "Act 2B" if stage_idx < 18 else "Act 3"
-                    is_polish = "Polish" in stage_name
-                    is_final = "Final" in stage_name
-                    prompt = self.create_screenwriter_prompt(
-                        act, "", "", "", screenplay_type, genre, language, is_polish, is_final
-                    )
                 else:
-                    prompt = f"Generate content for {stage_name}"
-                stage_content = ""
-                for chunk in self.call_llm_streaming(
-                    [{"role": "user", "content": prompt}],
-                    role, language
-                ):
-                    stage_content += chunk
-                    stages[stage_idx]["content"] = stage_content
-                    if role == "screenwriter":
-                        stages[stage_idx]["page_count"] = len(stage_content.split('\n')) / 58
-                    yield f"🔄 {stage_name} in progress...", stages, self.current_session_id
-                stages[stage_idx]["status"] = "complete"
-                ScreenplayDatabase.save_stage(
-                    self.current_session_id, stage_idx, stage_name, role,
-                    stage_content, "complete"
-                )
-                yield f"✅ {stage_name} completed", stages, self.current_session_id
-            final_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
-            yield f"✅ Screenplay completed!", stages, self.current_session_id
-        except Exception as e:
-            logger.error(f"Error: {e}")
-            yield f"❌ Error: {e}", stages if 'stages' in locals() else [], self.current_session_id
-# Utility functions
-def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
-    themes = {
-        'action': ['revenge mission', 'heist gone wrong', 'rescue operation'],
-        'thriller': ['conspiracy uncovered', 'false accusation', 'witness protection'],
-        'drama': ['family reunion', 'terminal diagnosis', 'second chance'],
-        'comedy': ['mistaken identity', 'wedding disaster', 'odd couple'],
-        'horror': ['haunted location', 'ancient curse', 'survival'],
-        'sci-fi': ['time paradox', 'AI awakening', 'space colony'],
-        'romance': ['enemies to lovers', 'second chance', 'forbidden love']
-    }
-    theme_list = themes.get(genre, themes['drama'])
-    selected = random.choice(theme_list)
-    if language == "Korean":
-        return f"**컨셉:** {selected}\n갈등과 캐릭터 성장이 있는 이야기"
-    else:
-        return f"**Concept:** {selected}\nA story with conflict and character growth"
 def format_screenplay_display(screenplay_text: str) -> str:
     if not screenplay_text:
-        return "No screenplay content yet."
-    formatted = "# 🎬 Screenplay\n\n"
-    # Format scene headings
     formatted_text = re.sub(
         r'^(INT\.|EXT\.).*$',
         r'**\g<0>**',
@@ -686,79 +680,69 @@ def format_screenplay_display(screenplay_text: str) -> str:
         flags=re.MULTILINE
     )
-    # Format character names
     formatted_text = re.sub(
-        r'^([A-Z][A-Z\s]+)$',
         r'**\g<0>**',
         formatted_text,
         flags=re.MULTILINE
     )
-    # Calculate pages
     page_count = len(screenplay_text.splitlines()) / 58
-    formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted_text
     return formatted
-def format_stages_display(stages: List[Dict]) -> str:
-    markdown = "## 🎬 Production Progress\n\n"
-    completed = sum(1 for s in stages if s.get('status') == 'complete')
-    total = len(stages)
-    markdown += f"**Progress: {completed}/{total} stages complete**\n\n"
-    total_pages = sum(s.get('page_count', 0) for s in stages if s.get('page_count'))
-    if total_pages > 0:
-        markdown += f"**Current Page Count: {total_pages:.1f} pages**\n\n"
-    markdown += "---\n\n"
-    for i, stage in enumerate(stages):
-        status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
-        markdown += f"{status_icon} **{stage['name']}**"
-        if stage.get('page_count', 0) > 0:
-            markdown += f" ({stage['page_count']:.1f} pages)"
-        markdown += "\n"
-        if stage['content'] and stage['status'] == 'complete':
-            preview = stage['content'][:200] + "..." if len(stage['content']) > 200 else stage['content']
-            markdown += f"> {preview}\n\n"
-        elif stage['status'] == 'active':
-            markdown += "> *In progress...*\n\n"
-    return markdown
-def process_query(query: str, screenplay_type: str, genre: str, language: str) -> Generator[Tuple[str, str, str, str], None, None]:
-    if not query.strip():
-        yield "", "", "❌ Please enter a screenplay concept.", ""
-        return
-    system = ScreenplayGenerationSystem()
-    stages_markdown = ""
-    screenplay_display = ""
-    for status, stages, session_id in system.process_screenplay_stream(
-        query, screenplay_type, genre, language
-    ):
-        stages_markdown = format_stages_display(stages)
-        if stages and all(s.get("status") == "complete" for s in stages[-4:]):
-            screenplay_text = ScreenplayDatabase.get_screenplay_content(session_id)
-            screenplay_display = format_screenplay_display(screenplay_text)
-        yield stages_markdown, screenplay_display, status, session_id
-def get_active_sessions_list() -> List[str]:
-    sessions = ScreenplayDatabase.get_active_sessions()
-    return [
-        f"{s['session_id'][:8]}... - {s.get('title', s['user_query'][:30])}... "
-        f"({s['screenplay_type']}/{s['genre']}) [{s['total_pages']:.1f} pages]"
-        for s in sessions
-    ]
-# Create Gradio interface
 def create_interface():
     css = """
     .main-header {
@@ -772,13 +756,22 @@ def create_interface():
     }
     .header-title {
-        font-size: 3.5rem;
         margin-bottom: 1rem;
         text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
     }
-    #screenplay-output {
-        font-family: 'Courier New', monospace;
         white-space: pre-wrap;
         background: white;
         padding: 2rem;
@@ -787,180 +780,227 @@ def create_interface():
         max-height: 800px;
         overflow-y: auto;
     }
     """
-    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="AI Screenplay Generator Pro") as interface:
         gr.HTML("""
         <div class="main-header">
-            <h1 class="header-title">🎬 AI Screenplay Generator Pro</h1>
             <p style="font-size: 1.2rem; opacity: 0.95;">
-                Professional screenplay generation powered by advanced AI<br>
-                Create feature films, TV shows, and streaming content with extended scenes and rich dialogue
             </p>
         </div>
         """)
         current_session_id = gr.State(None)
         with gr.Tabs():
-            with gr.Tab("✍️ Write Screenplay"):
                 with gr.Row():
-                    with gr.Column(scale=3):
                         query_input = gr.Textbox(
-                            label="📝 Screenplay Concept",
-                            placeholder="""Describe your screenplay idea. For example:
-- A detective with memory loss must solve their own attempted murder
-- Two rival food truck owners forced to work together
-- A space station AI develops consciousness during a critical mission
-- A family reunion turns into a murder mystery during a hurricane""",
-                            lines=6
                         )
                     with gr.Column(scale=1):
                         screenplay_type = gr.Radio(
                             choices=list(SCREENPLAY_LENGTHS.keys()),
-                            value="movie",
-                            label="📽️ Screenplay Type",
-                            info="Choose your format"
                         )
                         genre_select = gr.Dropdown(
                             choices=list(GENRE_TEMPLATES.keys()),
-                            value="drama",
-                            label="🎭 Primary Genre",
-                            info="Select main genre"
-                        )
-                        language_select = gr.Radio(
-                            choices=["English", "Korean"],
-                            value="English",
-                            label="🌍 Language"
                         )
                 with gr.Row():
-                    random_btn = gr.Button("🎲 Random Concept", scale=1)
-                    clear_btn = gr.Button("🗑️ Clear", scale=1)
-                    submit_btn = gr.Button("🎬 Start Writing", variant="primary", scale=2)
                 status_text = gr.Textbox(
-                    label="📊 Status",
                     interactive=False,
-                    value="Ready to create your screenplay"
                 )
-                with gr.Row():
-                    with gr.Column():
-                        with gr.Tab("🎭 Writing Progress"):
-                            stages_display = gr.Markdown(
-                                value="*Your screenplay journey will unfold here...*"
-                            )
-                        with gr.Tab("📄 Screenplay"):
-                            screenplay_output = gr.Markdown(
-                                value="*Your formatted screenplay will appear here...*"
-                            )
-                            with gr.Row():
-                                format_select = gr.Radio(
-                                    choices=["PDF", "FDX", "FOUNTAIN", "TXT"],
-                                    value="TXT",
-                                    label="Export Format"
-                                )
-                                download_btn = gr.Button("📥 Download", variant="secondary")
                 gr.Examples(
                     examples=[
-                        ["A burned-out teacher discovers her students are being replaced by AI duplicates"],
-                        ["Two funeral home employees accidentally release a ghost who helps them solve murders"],
-                        ["A time-loop forces a wedding planner to relive the worst wedding"],
-                        ["An astronaut returns to Earth to find everyone has forgotten space exists"]
                     ],
                     inputs=query_input,
-                    label="💡 Example Concepts"
                 )
-            with gr.Tab("📚 Saved Projects"):
-                gr.Markdown("### 📁 Your Screenplay Projects")
                 with gr.Row():
-                    session_dropdown = gr.Dropdown(
-                        label="Active Sessions",
-                        choices=[],
-                        interactive=True,
-                        scale=3
-                    )
-                    refresh_btn = gr.Button("🔄 Refresh", scale=1)
-                    load_btn = gr.Button("📂 Load", scale=1)
-        # Event handlers
-        def handle_submit(query, s_type, genre, lang, session_id):
             if not query:
-                yield "", "", "❌ Please enter a concept", session_id
                 return
-            yield from process_query(query, s_type, genre, lang)
-        def handle_random(s_type, genre, lang):
-            return generate_random_screenplay_theme(s_type, genre, lang)
         def handle_clear():
-            return "", "", "Ready to create your screenplay", None
-        def handle_download(screenplay_text, format_type):
-            if not screenplay_text:
                 return None
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            filename = f"screenplay_{timestamp}.txt"
             with open(filename, 'w', encoding='utf-8') as f:
-                f.write(screenplay_text)
             return filename
-        # Connect events
-        submit_btn.click(
-            fn=handle_submit,
-            inputs=[query_input, screenplay_type, genre_select, language_select, current_session_id],
-            outputs=[stages_display, screenplay_output, status_text, current_session_id]
         )
         random_btn.click(
             fn=handle_random,
-            inputs=[screenplay_type, genre_select, language_select],
             outputs=[query_input]
         )
         clear_btn.click(
             fn=handle_clear,
-            outputs=[stages_display, screenplay_output, status_text, current_session_id]
-        )
-        refresh_btn.click(
-            fn=get_active_sessions_list,
-            outputs=[session_dropdown]
         )
         download_btn.click(
             fn=handle_download,
-            inputs=[screenplay_output, format_select],
-            outputs=[gr.File(label="Download")]
-        )
-        interface.load(
-            fn=get_active_sessions_list,
-            outputs=[session_dropdown]
         )
     return interface
-# Main
 if __name__ == "__main__":
     logger.info("=" * 60)
-    logger.info("AI Screenplay Generator Pro Starting...")
-    logger.info(f"Using Fireworks AI: {MODEL_ID}")
-    logger.info(f"Max tokens: 15000")
     logger.info("=" * 60)
     ScreenplayDatabase.init_db()
     interface = create_interface()

 from collections import defaultdict
 import random
+# --- 로깅 설정 ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
+# --- 환경 변수 및 상수 ---
 FIREWORKS_API_KEY = os.getenv("FIREWORKS_API_KEY", "")
 BRAVE_SEARCH_API_KEY = os.getenv("BRAVE_SEARCH_API_KEY", "")
 API_URL = "https://api.fireworks.ai/inference/v1/chat/completions"
 MODEL_ID = "accounts/fireworks/models/qwen3-235b-a22b-instruct-2507"
+DB_PATH = "screenplay_sessions_korean.db"
+# 시나리오 길이 설정
 SCREENPLAY_LENGTHS = {
+   "영화": {"pages": 120, "description": "장편 영화 (110-130페이지)", "min_pages": 110},
+   "드라마": {"pages": 60, "description": "TV 드라마 (55-65페이지)", "min_pages": 55},
+   "웹드라마": {"pages": 50, "description": "웹/OTT 시리즈 (45-55페이지)", "min_pages": 45},
+   "단편": {"pages": 20, "description": "단편 영화 (15-25페이지)", "min_pages": 15}
 }
+# 환경 검증
 if not FIREWORKS_API_KEY:
+   logger.error("FIREWORKS_API_KEY가 설정되지 않았습니다.")
    FIREWORKS_API_KEY = "dummy_token_for_testing"
+# 글로벌 변수
 db_lock = threading.Lock()
+# 장르 템플릿
 GENRE_TEMPLATES = {
+   "액션": {
+       "pacing": "빠름",
+       "scene_length": "짧음",
        "dialogue_ratio": 0.3,
+       "key_elements": ["액션 시퀀스", "물리적 갈등", "긴박감", "위기 고조", "영웅적 순간"],
+       "structure_beats": ["폭발적 오프닝", "추격", "대결", "클라이맥스 전투", "영웅의 승리"],
        "scene_density": 1.2,
        "action_description_ratio": 0.6
    },
+   "스릴러": {
+       "pacing": "빠름",
+       "scene_length": "짧음",
        "dialogue_ratio": 0.35,
+       "key_elements": ["서스펜스", "반전", "편집증", "시간 압박", "진실 폭로"],
+       "structure_beats": ["훅", "미스터리 심화", "거짓 승리", "진실 폭로", "최종 대결"],
        "scene_density": 1.1,
        "action_description_ratio": 0.5
    },
+   "드라마": {
+       "pacing": "보통",
+       "scene_length": "중간",
        "dialogue_ratio": 0.55,
+       "key_elements": ["캐릭터 깊이", "감정적 진실", "관계", "내적 갈등", "변화"],
+       "structure_beats": ["일상", "촉매", "고민", "결심", "복잡화", "위기", "해결"],
        "scene_density": 0.9,
        "action_description_ratio": 0.3
    },
+   "코미디": {
+       "pacing": "빠름",
+       "scene_length": "짧음",
        "dialogue_ratio": 0.65,
+       "key_elements": ["셋업과 페이오프", "타이밍", "캐릭터 코미디", "상황 고조", "러닝 개그"],
+       "structure_beats": ["웃긴 오프닝", "복잡화", "오해 증폭", "혼돈의 정점", "해결과 콜백"],
        "scene_density": 1.0,
        "action_description_ratio": 0.35
    },
+   "공포": {
+       "pacing": "가변적",
+       "scene_length": "혼합",
        "dialogue_ratio": 0.3,
+       "key_elements": ["분위기", "공포감", "점프 스케어", "심리적 공포", "고립"],
+       "structure_beats": ["평범한 일상", "첫 징조", "조사", "첫 공격", "생존", "최종 대결"],
        "scene_density": 1.0,
        "action_description_ratio": 0.55
    },
+   "SF": {
+       "pacing": "보통",
+       "scene_length": "중간",
        "dialogue_ratio": 0.45,
+       "key_elements": ["세계관 구축", "기술", "개념", "시각적 스펙터클", "철학적 질문"],
+       "structure_beats": ["일상 세계", "발견", "새로운 세계", "복잡화", "이해", "선택", "새로운 일상"],
        "scene_density": 0.95,
        "action_description_ratio": 0.45
    },
+   "로맨스": {
+       "pacing": "보통",
+       "scene_length": "중간",
        "dialogue_ratio": 0.6,
+       "key_elements": ["케미스트리", "장애물", "감정적 순간", "친밀감", "취약성"],
+       "structure_beats": ["만남", "끌림", "첫 갈등", "깊어짐", "위기/이별", "화해", "결합"],
        "scene_density": 0.85,
        "action_description_ratio": 0.25
+   },
+   "판타지": {
+       "pacing": "보통",
+       "scene_length": "중간",
+       "dialogue_ratio": 0.4,
+       "key_elements": ["마법 체계", "영웅의 여정", "신화적 요소", "세계관", "성장"],
+       "structure_beats": ["평범한 세계", "소명", "거부", "멘토", "첫 시험", "시련", "보상", "귀환"],
+       "scene_density": 1.0,
+       "action_description_ratio": 0.5
    }
 }
+# 시나리오 단계 (기획 단계와 작성 단계 분리)
+PLANNING_STAGES = [
+    ("컨셉 개발", "🎬 프로듀서: 핵심 컨셉 및 시장성 분석"),
+    ("스토리 구성", "📖 스토리 개발: 시놉시스 및 3막 구조"),
+    ("캐릭터 설계", "👥 캐릭터 디자이너: 인물 프로필 및 관계도"),
+    ("세계관 구축", "🌍 세계관: 배경, 분위기, 비주얼 설정"),
+    ("씬 구성", "🎯 씬 플래너: 상세 씬 브레이크다운"),
+]
+WRITING_STAGES = [
+    ("1막 초고", "✍️ 1막 - 설정 (25%) - 초고 작성"),
+    ("1막 수정", "📝 1막 - 확장 및 다듬기"),
+    ("1막 검토", "🔧 1막 - 전문가 검토"),
+    ("1막 완성", "✅ 1막 - 최종 완성본"),
+    ("2막A 초고", "✍️ 2막A - 상승 (25%) - 초고 작성"),
+    ("2막A 수정", "📝 2막A - 확장 및 다듬기"),
+    ("2막A 검토", "🔧 2막A - 전문가 검토"),
+    ("2막A 완성", "✅ 2막A - 최종 완성본"),
+    ("2막B 초고", "✍️ 2막B - 복잡화 (25%) - 초고 작성"),
+    ("2막B 수정", "📝 2막B - 확장 및 다듬기"),
+    ("2막B 검토", "🔧 2막B - 전문가 검토"),
+    ("2막B 완성", "✅ 2막B - 최종 완성본"),
+    ("3막 초고", "✍️ 3막 - 해결 (25%) - 초고 작성"),
+    ("3막 수정", "📝 3막 - 확장 및 다듬기"),
+    ("3막 검토", "🔧 3막 - 전문가 검토"),
+    ("3막 완성", "✅ 3막 - 최종 완성본"),
+    ("대사 강화", "💬 대사 전문가: 대사 개선 및 서브텍스트"),
+    ("최종 검토", "🎭 최종 리뷰: 전체 시나리오 분석 및 완성"),
 ]
+# 데이터 클래스
 @dataclass
+class ScreenplayPlan:
+    """시나리오 기획안"""
+    title: str = ""
+    logline: str = ""
+    genre: str = ""
+    subgenre: str = ""
+    themes: List[str] = field(default_factory=list)
+    # 시놉시스
+    synopsis: str = ""
+    extended_synopsis: str = ""
+    # 3막 구조
+    act1_summary: str = ""
+    act2a_summary: str = ""
+    act2b_summary: str = ""
+    act3_summary: str = ""
+    # 주요 캐릭터
+    protagonist: Dict[str, str] = field(default_factory=dict)
+    antagonist: Dict[str, str] = field(default_factory=dict)
+    supporting_characters: List[Dict[str, str]] = field(default_factory=list)
+    # 세계관
+    time_period: str = ""
+    locations: List[str] = field(default_factory=list)
+    atmosphere: str = ""
+    visual_style: str = ""
+    # 씬 구성
+    total_scenes: int = 0
+    scene_breakdown: List[Dict] = field(default_factory=list)
 @dataclass
+class ScreenplayBible:
+    """시나리오 바이블"""
+    title: str = ""
+    logline: str = ""
+    genre: str = ""
+    subgenre: str = ""
+    tone: str = ""
+    themes: List[str] = field(default_factory=list)
+    protagonist: Dict[str, Any] = field(default_factory=dict)
+    antagonist: Dict[str, Any] = field(default_factory=dict)
+    supporting_cast: Dict[str, Dict[str, Any]] = field(default_factory=dict)
+    three_act_structure: Dict[str, str] = field(default_factory=dict)
+    time_period: str = ""
+    primary_locations: List[Dict[str, str]] = field(default_factory=list)
+    visual_style: str = ""
+# 데이터베이스 클래스
 class ScreenplayDatabase:
     @staticmethod
     def init_db():
         with sqlite3.connect(DB_PATH) as conn:
                     screenplay_type TEXT NOT NULL,
                     genre TEXT NOT NULL,
                     target_pages INTEGER,
                     title TEXT,
                     logline TEXT,
+                    planning_data TEXT,
+                    screenplay_content TEXT,
                     created_at TEXT DEFAULT (datetime('now')),
                     updated_at TEXT DEFAULT (datetime('now')),
+                    status TEXT DEFAULT 'planning',
                     current_stage INTEGER DEFAULT 0,
                     total_pages REAL DEFAULT 0
                 )
                 CREATE TABLE IF NOT EXISTS screenplay_stages (
                     id INTEGER PRIMARY KEY AUTOINCREMENT,
                     session_id TEXT NOT NULL,
+                    stage_type TEXT NOT NULL,
                     stage_number INTEGER NOT NULL,
                     stage_name TEXT NOT NULL,
                     content TEXT,
                     page_count REAL DEFAULT 0,
                     status TEXT DEFAULT 'pending',
                     created_at TEXT DEFAULT (datetime('now')),
                     FOREIGN KEY (session_id) REFERENCES screenplay_sessions(session_id),
+                    UNIQUE(session_id, stage_type, stage_number)
                 )
             ''')
                 conn.close()
     @staticmethod
+    def create_session(user_query: str, screenplay_type: str, genre: str) -> str:
         session_id = hashlib.md5(f"{user_query}{screenplay_type}{datetime.now()}".encode()).hexdigest()
         target_pages = SCREENPLAY_LENGTHS[screenplay_type]["pages"]
         with ScreenplayDatabase.get_db() as conn:
             conn.cursor().execute(
                 '''INSERT INTO screenplay_sessions
+                   (session_id, user_query, screenplay_type, genre, target_pages)
+                   VALUES (?, ?, ?, ?, ?)''',
+                (session_id, user_query, screenplay_type, genre, target_pages)
             )
             conn.commit()
         return session_id
     @staticmethod
+    def save_planning_data(session_id: str, planning_data: Dict):
         with ScreenplayDatabase.get_db() as conn:
+            conn.cursor().execute(
+                '''UPDATE screenplay_sessions
+                   SET planning_data = ?, status = 'planned', updated_at = datetime('now')
+                   WHERE session_id = ?''',
+                (json.dumps(planning_data, ensure_ascii=False), session_id)
+            )
             conn.commit()
     @staticmethod
+    def get_planning_data(session_id: str) -> Optional[Dict]:
         with ScreenplayDatabase.get_db() as conn:
+            row = conn.cursor().execute(
+                'SELECT planning_data FROM screenplay_sessions WHERE session_id = ?',
+                (session_id,)
+            ).fetchone()
+            if row and row['planning_data']:
+                return json.loads(row['planning_data'])
+        return None
     @staticmethod
+    def save_screenplay_content(session_id: str, content: str, title: str, logline: str):
         with ScreenplayDatabase.get_db() as conn:
+            total_pages = len(content.split('\n')) / 58
+            conn.cursor().execute(
+                '''UPDATE screenplay_sessions
+                   SET screenplay_content = ?, title = ?, logline = ?,
+                       total_pages = ?, status = 'complete', updated_at = datetime('now')
+                   WHERE session_id = ?''',
+                (content, title, logline, total_pages, session_id)
+            )
             conn.commit()
+# 시나리오 생성 시스템
 class ScreenplayGenerationSystem:
     def __init__(self):
         self.api_key = FIREWORKS_API_KEY
         self.api_url = API_URL
         self.model_id = MODEL_ID
         self.current_session_id = None
+        self.current_plan = ScreenplayPlan()
         ScreenplayDatabase.init_db()
     def create_headers(self):
         if not self.api_key or self.api_key == "dummy_token_for_testing":
+            raise ValueError("유효한 FIREWORKS_API_KEY가 필요합니다")
         return {
             "Accept": "application/json",
             "Authorization": f"Bearer {self.api_key}"
         }
+    def call_llm_streaming(self, messages: List[Dict[str, str]], max_tokens: int = 8000) -> Generator[str, None, None]:
         try:
             payload = {
                 "model": self.model_id,
+                "messages": messages,
+                "max_tokens": max_tokens,
+                "temperature": 0.8,
                 "top_p": 1,
                 "top_k": 40,
                 "presence_penalty": 0.2,
             )
             if response.status_code != 200:
+                yield f"❌ API 오류: {response.status_code}"
                 return
             buffer = ""
                 yield buffer
         except Exception as e:
+            yield f"❌ 오류: {str(e)}"
+    def generate_planning(self, query: str, screenplay_type: str, genre: str,
+                         progress_callback=None) -> Generator[Tuple[str, float, Dict], None, None]:
+        """기획안 생성"""
         try:
+            self.current_session_id = ScreenplayDatabase.create_session(query, screenplay_type, genre)
+            planning_content = {}
+            total_stages = len(PLANNING_STAGES)
+            for idx, (stage_name, stage_desc) in enumerate(PLANNING_STAGES):
+                progress = (idx / total_stages) * 100
+                yield f"🔄 {stage_desc} 진행 중...", progress, planning_content
+                # 각 단계별 프롬프트 생성
+                if stage_name == "컨셉 개발":
+                    prompt = f"""당신은 할리우드 프로듀서입니다. 다음 요청으로 {screenplay_type} 시나리오 컨셉을 개발하세요.
+요청: {query}
+장르: {genre}
+다음을 포함하여 작성하세요:
+1. 제목
+2. 로그라인 (한 문장으로 핵심 갈등과 주인공 설명)
+3. 핵심 테마
+4. 타겟 관객
+5. 유사 작품 3개와 차별점
+6. 상업적 매력 포인트"""
+                elif stage_name == "스토리 구성":
+                    prompt = f"""이전 컨셉을 바탕으로 상세한 스토리 구조를 만드세요.
+1. 시놉시스 (500자)
+2. 확장 시놉시스 (1000자)
+3. 3막 구조:
+   - 1막 (설정): 주인공 소개, 일상, 사건 발생
+   - 2막A (상승): 새로운 세계, 시련 시작
+   - 2막B (복잡화): 갈등 심화, 위기 고조
+   - 3막 (해결): 클라이맥스, 결말"""
+                elif stage_name == "캐릭터 설계":
+                    prompt = f"""주요 캐릭터들을 상세히 설계하세요.
+주인공:
+- 이름과 나이
+- 외모와 성격
+- 목표 (WANT)
+- 필요 (NEED)
+- 성장 아크
+적대자:
+- 이름과 역할
+- 동기와 목표
+- 주인공과의 관계
+조연 3명:
+- 각자의 역할과 특징"""
+                elif stage_name == "세계관 구축":
+                    prompt = f"""시나리오의 세계관과 분위기를 구축하세요.
+1. 시대 배경
+2. 주요 장소 5곳
+3. 전체적 분위기와 톤
+4. 시각적 스타일
+5. 음향/음악 스타일"""
+                elif stage_name == "씬 구성":
+                    prompt = f"""전체 씬 구성을 계획하세요.
+{SCREENPLAY_LENGTHS[screenplay_type]['pages']}페이지 분량으로:
+- 1막: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (10-12개 씬)
+- 2막A: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (12-15개 씬)
+- 2막B: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (12-15개 씬)
+- 3막: 약 {int(SCREENPLAY_LENGTHS[screenplay_type]['pages']*0.25)}페이지 (8-10개 씬)
+각 씬마다:
+- 장소와 시간
+- 등장인물
+- 핵심 사건
+- 페이지 수"""
+                # LLM 호출
+                messages = [
+                    {"role": "system", "content": "당신은 전문 시나리오 작가입니다. 상세하고 창의적인 내용을 작성하세요."},
+                    {"role": "user", "content": prompt}
+                ]
+                content = ""
+                for chunk in self.call_llm_streaming(messages):
+                    content += chunk
+                    planning_content[stage_name] = content
+                    yield f"✅ {stage_desc} 완료", progress, planning_content
+                time.sleep(0.5)  # API 제한 고려
+            # 최종 기획안 저장
+            ScreenplayDatabase.save_planning_data(self.current_session_id, planning_content)
+            yield "✅ 기획안 완성!", 100, planning_content
+        except Exception as e:
+            yield f"❌ 오류 발생: {str(e)}", 0, {}
+    def generate_screenplay(self, session_id: str, planning_data: Dict,
+                          progress_callback=None) -> Generator[Tuple[str, float, str], None, None]:
+        """시나리오 작성"""
+        try:
+            total_stages = len(WRITING_STAGES)
+            screenplay_content = ""
+            act_contents = {"1막": "", "2막A": "", "2막B": "", "3막": ""}
+            for idx, (stage_name, stage_desc) in enumerate(WRITING_STAGES):
+                progress = (idx / total_stages) * 100
+                yield f"🔄 {stage_desc} 진행 중...", progress, screenplay_content
+                # 막 결정
+                current_act = ""
+                if "1막" in stage_name:
+                    current_act = "1막"
+                elif "2막A" in stage_name:
+                    current_act = "2막A"
+                elif "2막B" in stage_name:
+                    current_act = "2막B"
+                elif "3막" in stage_name:
+                    current_act = "3막"
+                # 작성 단계별 프롬프트
+                if "초고" in stage_name:
+                    prompt = self._create_writing_prompt(current_act, planning_data, act_contents, "초고")
+                elif "수정" in stage_name:
+                    prompt = self._create_writing_prompt(current_act, planning_data, act_contents, "수정")
+                elif "검토" in stage_name:
+                    prompt = self._create_review_prompt(current_act, act_contents[current_act])
+                elif "완성" in stage_name:
+                    prompt = self._create_writing_prompt(current_act, planning_data, act_contents, "완성")
+                elif "대사 강화" in stage_name:
+                    prompt = self._create_dialogue_prompt(screenplay_content)
+                elif "최종 검토" in stage_name:
+                    prompt = self._create_final_review_prompt(screenplay_content)
                 else:
+                    continue
+                # LLM 호출
+                messages = [
+                    {"role": "system", "content": "당신은 전문 시나리오 작가입니다. 표준 시나리오 포맷으로 작성하세요."},
+                    {"role": "user", "content": prompt}
+                ]
+                content = ""
+                for chunk in self.call_llm_streaming(messages, max_tokens=15000):
+                    content += chunk
+                    # 막 내용 업데이트
+                    if current_act and "완성" in stage_name:
+                        act_contents[current_act] = content
+                        screenplay_content = "\n\n".join([act_contents[act] for act in ["1막", "2막A", "2막B", "3막"] if act_contents[act]])
+                    yield f"✏️ {stage_desc} 작성 중...", progress, screenplay_content
+                time.sleep(0.5)
+            # 최종 저장
+            title = planning_data.get("컨셉 개발", "").split("제목")[1].split("\n")[0].strip() if "컨셉 개발" in planning_data else "무제"
+            logline = planning_data.get("컨셉 개발", "").split("로그라인")[1].split("\n")[0].strip() if "컨셉 개발" in planning_data else ""
+            ScreenplayDatabase.save_screenplay_content(session_id, screenplay_content, title, logline)
+            yield "✅ 시나리오 완성!", 100, screenplay_content
+        except Exception as e:
+            yield f"❌ 오류 발생: {str(e)}", 0, ""
+    def _create_writing_prompt(self, act: str, planning_data: Dict, previous_acts: Dict, phase: str) -> str:
+        """작성 프롬프트 생성"""
+        story_structure = planning_data.get("스토리 구성", "")
+        characters = planning_data.get("캐릭터 설계", "")
+        scenes = planning_data.get("씬 구성", "")
+        if phase == "초고":
+            min_lines = 800
+            instruction = "초고를 작성하세요"
+        elif phase == "수정":
+            min_lines = 1000
+            instruction = "내용을 확장하고 다듬으세요"
+        else:  # 완성
+            min_lines = 1200
+            instruction = "최종 완성본을 작성하세요"
+        prompt = f"""{act} {instruction}.
+목표 분량: 최소 {min_lines}줄
+스토리 구조:
+{story_structure}
+캐릭터:
+{characters}
+씬 구성:
+{scenes}
+이전 막 내용:
+{previous_acts if previous_acts else "첫 막입니다"}
+요구사항:
+1. 표준 시나리오 포맷 사용
+2. INT./EXT. 장소 - 시간
+3. 캐릭터명은 대문자
+4. 대사는 자연스럽게
+5. 액션은 현재형으로 시각적으로
+6. 각 씬마다 충분한 분량 (5-7페이지)
+반드시 {min_lines}줄 이상 작성하세요."""
+        return prompt
+    def _create_review_prompt(self, act: str, content: str) -> str:
+        """검토 프롬프트"""
+        return f"""{act}를 검토하고 개선점을 제시하세요.
+검토 내용:
+{content[:2000]}...
+검토 항목:
+1. 스토리 논리성
+2. 캐릭터 일관성
+3. 대사 자연스러움
+4. 페이싱
+5. 시각적 명확성
+구체적인 개선 제안을 하세요."""
+    def _create_dialogue_prompt(self, screenplay: str) -> str:
+        """대사 강화 프롬프트"""
+        return f"""전체 시나리오의 대사를 검토하고 개선하세요.
+개선 포인트:
+1. 캐릭터별 고유한 말투
+2. 서브텍스트 추가
+3. 불필요한 설명 제거
+4. 감정적 진정성
+5. 장르에 맞는 톤
+주요 개선이 필요한 대사들을 찾아 수정안을 제시하세요."""
+    def _create_final_review_prompt(self, screenplay: str) -> str:
+        """최종 검토 프롬프트"""
+        return f"""완성된 시나리오를 최종 검토하세요.
+평가 항목:
+1. 전체 구조와 페이싱
+2. 캐릭터 아크
+3. 테마 전달
+4. 상업성
+5. 제작 가능성
+총평과 함께 최종 개선 사항을 제시하세요."""
+# 유틸리티 함수
+def format_planning_display(planning_data: Dict) -> str:
+    """기획안 표시 포맷"""
+    if not planning_data:
+        return "기획안이 아직 생성되지 않았습니다."
+    formatted = "# 📋 시나리오 기획안\n\n"
+    for stage_name, content in planning_data.items():
+        formatted += f"## {stage_name}\n\n"
+        formatted += content + "\n\n"
+        formatted += "---\n\n"
+    return formatted
 def format_screenplay_display(screenplay_text: str) -> str:
+    """시나리오 표시 포맷"""
     if not screenplay_text:
+        return "시나리오가 아직 작성되지 않았습니다."
+    formatted = "# 🎬 시나리오\n\n"
+    # 씬 헤딩 강조
     formatted_text = re.sub(
         r'^(INT\.|EXT\.).*$',
         r'**\g<0>**',
         flags=re.MULTILINE
     )
+    # 캐릭터명 강조
     formatted_text = re.sub(
+        r'^([가-힣A-Z][가-힣A-Z\s]+)$',
         r'**\g<0>**',
         formatted_text,
         flags=re.MULTILINE
     )
+    # 페이지 수 계산
     page_count = len(screenplay_text.splitlines()) / 58
+    formatted = f"**총 페이지: {page_count:.1f}**\n\n" + formatted_text
     return formatted
+def generate_random_concept(screenplay_type: str, genre: str) -> str:
+    """랜덤 컨셉 생성"""
+    concepts = {
+        '액션': [
+            "은퇴한 특수요원이 납치된 딸을 구하기 위해 다시 현장으로 복귀한다",
+            "평범한 택시기사가 우연히 국제 테러 조직의 음모에 휘말린다",
+            "부패 경찰과 맞서 싸우는 정의로운 형사의 고독한 싸움"
+        ],
+        '스릴러': [
+            "기억을 잃은 남자가 자신이 연쇄살인범이라는 증거를 발견한다",
+            "실종된 아이를 찾는 과정에서 마을의 끔찍한 비밀이 드러난다",
+            "완벽한 알리바이를 가진 용의자를 쫓는 검사의 집요한 추적"
+        ],
+        '드라마': [
+            "말기 암 환자가 마지막 소원으로 가족과의 화해를 시도한다",
+            "재개발로 사라질 동네를 지키려는 주민들의 마지막 싸움",
+            "입양아가 생모를 찾아가는 가슴 아픈 여정"
+        ],
+        '코미디': [
+            "결혼식장을 운영하는 커플이 자신들의 이혼을 숨기며 일한다",
+            "복권에 당첨된 가족이 서로 돈을 차지하려 음모를 꾸민다",
+            "실수로 대통령 경호원이 된 평범한 회사원의 좌충우돌 이야기"
+        ],
+        '공포': [
+            "폐병원에서 밤새 생존해야 하는 의대생들의 공포 체험",
+            "거울 속에서 나타나는 또 다른 자신과 마주한 여자",
+            "저주받은 골동품을 판매한 후 벌어지는 기이한 사건들"
+        ],
+        'SF': [
+            "시간 여행으로 과거를 바꾸려다 더 큰 재앙을 만든 과학자",
+            "인공지능이 인간의 감정을 학습하며 벌어지는 예상치 못한 사건",
+            "외계 신호를 해독한 언어학자가 인류의 운명을 결정해야 한다"
+        ],
+        '로맨스': [
+            "첫사랑과 20년 만에 재회한 두 사람의 두 번째 기회",
+            "계약결혼으로 시작했다가 진짜 사랑에 빠진 커플",
+            "서로 다른 시대를 살아가는 두 사람의 편지를 통한 사랑"
+        ],
+        '판타지': [
+            "평범한 고등학생이 판타지 세계의 선택받은 용사가 된다",
+            "도시에 나타난 용과 소통할 수 있는 유일한 사람",
+            "마법이 사라진 세계에서 마지막 마법사가 되어버린 청년"
+        ]
+    }
+    genre_concepts = concepts.get(genre, concepts['드라마'])
+    return random.choice(genre_concepts)
+# Gradio 인터페이스
 def create_interface():
     css = """
     .main-header {
     }
     .header-title {
+        font-size: 3rem;
         margin-bottom: 1rem;
         text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
     }
+    .planning-section {
+        background: #f8f9fa;
+        padding: 1.5rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+        max-height: 600px;
+        overflow-y: auto;
+    }
+    .screenplay-output {
+        font-family: 'Nanum Gothic Coding', 'Courier New', monospace;
         white-space: pre-wrap;
         background: white;
         padding: 2rem;
         max-height: 800px;
         overflow-y: auto;
     }
+    .progress-bar {
+        background: #e0e0e0;
+        border-radius: 10px;
+        height: 30px;
+        position: relative;
+        margin: 1rem 0;
+    }
+    .progress-fill {
+        background: linear-gradient(90deg, #667eea, #764ba2);
+        height: 100%;
+        border-radius: 10px;
+        transition: width 0.3s ease;
+    }
     """
+    with gr.Blocks(theme=gr.themes.Soft(), css=css, title="AI 시나리오 작가") as interface:
         gr.HTML("""
         <div class="main-header">
+            <h1 class="header-title">🎬 AI 시나리오 작가</h1>
             <p style="font-size: 1.2rem; opacity: 0.95;">
+                전문가 수준의 한국어 시나리오를 AI가 작성합니다<br>
+                영화, 드라마, 웹드라마, 단편 시나리오를 완벽하게 구성합니다
             </p>
         </div>
         """)
         current_session_id = gr.State(None)
+        current_planning_data = gr.State({})
         with gr.Tabs():
+            with gr.Tab("📝 새 시나리오"):
                 with gr.Row():
+                    with gr.Column(scale=2):
                         query_input = gr.Textbox(
+                            label="💡 시나리오 아이디어",
+                            placeholder="""원하는 시나리오의 핵심 아이디어를 입력하세요. 예시:
+- 기억을 잃은 형사가 자신이 쫓던 연쇄살인범임을 알게 된다
+- 시간을 되돌릴 수 있는 능력을 얻은 의사가 환자를 구하려 한다
+- 가상현실 게임에 갇힌 프로게이머가 현실로 돌아가려 한다
+- 조선시대로 타임슬립한 현대 검사가 부정부패와 싸운다""",
+                            lines=5
                         )
                     with gr.Column(scale=1):
                         screenplay_type = gr.Radio(
                             choices=list(SCREENPLAY_LENGTHS.keys()),
+                            value="영화",
+                            label="📽️ 시나리오 유형"
                         )
                         genre_select = gr.Dropdown(
                             choices=list(GENRE_TEMPLATES.keys()),
+                            value="드라마",
+                            label="🎭 장르"
                         )
                 with gr.Row():
+                    random_btn = gr.Button("�� 랜덤 아이디어", scale=1)
+                    clear_btn = gr.Button("🗑️ 초기화", scale=1)
+                    planning_btn = gr.Button("📋 기획안 생성", variant="primary", scale=2)
+                # 진행 상태
+                progress_bar = gr.HTML(
+                    value='<div class="progress-bar"><div class="progress-fill" style="width: 0%"></div></div>'
+                )
                 status_text = gr.Textbox(
+                    label="📊 진행 상태",
                     interactive=False,
+                    value="아이디어를 입력하고 기획안 생성을 시작하세요"
                 )
+                # 기획안 섹션
+                with gr.Group():
+                    gr.Markdown("### 📋 시나리오 기획안")
+                    planning_display = gr.Markdown(
+                        value="*기획안이 여기에 표시됩니다...*",
+                        elem_classes=["planning-section"]
+                    )
+                    with gr.Row():
+                        edit_planning_btn = gr.Button("✏️ 기획안 수정", scale=1)
+                        save_planning_btn = gr.Button("💾 기획안 저장", scale=1)
+                        generate_screenplay_btn = gr.Button("🎬 시나리오 작성 시작", variant="primary", scale=2)
+                # 시나리오 출력
+                with gr.Group():
+                    gr.Markdown("### 📄 완성된 시나리오")
+                    screenplay_output = gr.Markdown(
+                        value="*시나리오가 여기에 표시됩니다...*",
+                        elem_classes=["screenplay-output"]
+                    )
+                    with gr.Row():
+                        download_btn = gr.Button("💾 다운로드 (TXT)", scale=1)
+                        pdf_btn = gr.Button("📑 PDF 변환", scale=1)
+                # 예시
                 gr.Examples(
                     examples=[
+                        ["기억을 잃은 형사가 자신이 쫓던 연쇄살인범임을 알게 된다"],
+                        ["시간을 되돌릴 수 있는 능력을 얻은 의사가 환자를 구하려 한다"],
+                        ["가상현실 게임에 갇힌 프로게이머가 현실로 돌아가려 한다"],
+                        ["조선시대로 타임슬립한 현대 검사가 부정부패와 싸운다"]
                     ],
                     inputs=query_input,
+                    label="💡 예시 아이디어"
                 )
+            with gr.Tab("📚 내 작품"):
+                gr.Markdown("""
+                ### 📁 저장된 시나리오
+                작업 중이거나 완성된 시나리오를 관리합니다.
+                """)
+                saved_list = gr.Dataframe(
+                    headers=["제목", "장르", "유형", "페이지", "상태", "수정일"],
+                    value=[],
+                    label="저장된 작품 목록"
+                )
                 with gr.Row():
+                    refresh_btn = gr.Button("🔄 새로고침")
+                    load_btn = gr.Button("📂 불러오기")
+                    delete_btn = gr.Button("🗑️ 삭제")
+        # 이벤트 핸들러
+        def handle_planning(query, s_type, genre):
             if not query:
+                yield "", "❌ 아이디어를 입력해주세요", "", {}
                 return
+            system = ScreenplayGenerationSystem()
+            for status, progress, planning_data in system.generate_planning(query, s_type, genre):
+                progress_html = f'<div class="progress-bar"><div class="progress-fill" style="width: {progress}%"></div></div>'
+                planning_display = format_planning_display(planning_data)
+                yield progress_html, status, planning_display, planning_data
+        def handle_screenplay_generation(session_id, planning_data):
+            if not planning_data:
+                yield "", "❌ 먼저 기획안을 생성해주세요", ""
+                return
+            system = ScreenplayGenerationSystem()
+            for status, progress, screenplay in system.generate_screenplay(session_id, planning_data):
+                progress_html = f'<div class="progress-bar"><div class="progress-fill" style="width: {progress}%"></div></div>'
+                screenplay_display = format_screenplay_display(screenplay)
+                yield progress_html, status, screenplay_display
+        def handle_random(s_type, genre):
+            return generate_random_concept(s_type, genre)
         def handle_clear():
+            empty_progress = '<div class="progress-bar"><div class="progress-fill" style="width: 0%"></div></div>'
+            return "", empty_progress, "준비됨", "", "", None, {}
+        def handle_download(screenplay_text):
+            if not screenplay_text or screenplay_text == "*시나리오가 여기에 표시됩니다...*":
                 return None
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"시나리오_{timestamp}.txt"
             with open(filename, 'w', encoding='utf-8') as f:
+                # 마크다운 제거
+                clean_text = re.sub(r'\*\*([^*]+)\*\*', r'\1', screenplay_text)
+                clean_text = re.sub(r'^#+ ', '', clean_text, flags=re.MULTILINE)
+                f.write(clean_text)
             return filename
+        # 이벤트 연결
+        planning_btn.click(
+            fn=handle_planning,
+            inputs=[query_input, screenplay_type, genre_select],
+            outputs=[progress_bar, status_text, planning_display, current_planning_data]
+        )
+        generate_screenplay_btn.click(
+            fn=handle_screenplay_generation,
+            inputs=[current_session_id, current_planning_data],
+            outputs=[progress_bar, status_text, screenplay_output]
         )
         random_btn.click(
             fn=handle_random,
+            inputs=[screenplay_type, genre_select],
             outputs=[query_input]
         )
         clear_btn.click(
             fn=handle_clear,
+            outputs=[query_input, progress_bar, status_text, planning_display,
+                    screenplay_output, current_session_id, current_planning_data]
         )
         download_btn.click(
             fn=handle_download,
+            inputs=[screenplay_output],
+            outputs=[gr.File(label="다운로드")]
         )
     return interface
+# 메인 실행
 if __name__ == "__main__":
     logger.info("=" * 60)
+    logger.info("AI 시나리오 작가 시작...")
+    logger.info("Fireworks AI 모델 사용")
     logger.info("=" * 60)
+    if not FIREWORKS_API_KEY or FIREWORKS_API_KEY == "dummy_token_for_testing":
+        logger.warning("⚠️ FIREWORKS_API_KEY를 설정해주세요!")
+        logger.warning("export FIREWORKS_API_KEY='your-api-key'")
     ScreenplayDatabase.init_db()
     interface = create_interface()