Update app.py

app.py

@@ -115,22 +115,38 @@ GENRE_TEMPLATES = {
 }
 
 # Screenplay stages definition
+# Screenplay stages definition - Enhanced with expansion stages
 SCREENPLAY_STAGES = [
-   ("producer", "🎬 Producer: Concept Development & Market Analysis"),
-   ("story_developer", "📖 Story Developer: Synopsis & Three-Act Structure"),
-   ("character_designer", "👥 Character Designer: Cast & Relationships"),
-   ("critic_structure", "🔍 Structure Critic: Story & Character Review"),
-   ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
-   ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%)"),
-   ("script_doctor", "🔧 Script Doctor: Act 1 Review & Polish"),
-   ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%)"),
-   ("script_doctor", "🔧 Script Doctor: Act 2A Review & Polish"),
-   ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%)"),
-   ("script_doctor", "🔧 Script Doctor: Act 2B Review & Polish"),
-   ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%)"),
-   ("final_reviewer", "🎭 Final Review: Complete Screenplay Analysis"),
+    ("producer", "🎬 Producer: Concept Development & Market Analysis"),
+    ("story_developer", "📖 Story Developer: Synopsis & Three-Act Structure"),
+    ("character_designer", "👥 Character Designer: Cast & Relationships"),
+    ("critic_structure", "🔍 Structure Critic: Story & Character Review"),
+    ("scene_planner", "🎯 Scene Planner: Detailed Scene Breakdown"),
+    
+    # Act 1 - 3 stages: Draft -> Review -> Expansion
+    ("screenwriter", "✍️ Screenwriter: Act 1 - Setup (25%) - First Draft"),
+    ("script_doctor", "🔧 Script Doctor: Act 1 Review & Expansion Notes"),
+    ("screenwriter", "✍️ Screenwriter: Act 1 - Expanded Final Version"),
+    
+    # Act 2A - 3 stages
+    ("screenwriter", "✍️ Screenwriter: Act 2A - Rising Action (25%) - First Draft"),
+    ("script_doctor", "🔧 Script Doctor: Act 2A Review & Expansion Notes"),
+    ("screenwriter", "✍️ Screenwriter: Act 2A - Expanded Final Version"),
+    
+    # Act 2B - 3 stages
+    ("screenwriter", "✍️ Screenwriter: Act 2B - Complications (25%) - First Draft"),
+    ("script_doctor", "🔧 Script Doctor: Act 2B Review & Expansion Notes"),
+    ("screenwriter", "✍️ Screenwriter: Act 2B - Expanded Final Version"),
+    
+    # Act 3 - 3 stages
+    ("screenwriter", "✍️ Screenwriter: Act 3 - Resolution (25%) - First Draft"),
+    ("script_doctor", "🔧 Script Doctor: Act 3 Review & Expansion Notes"),
+    ("screenwriter", "✍️ Screenwriter: Act 3 - Expanded Final Version"),
+    
+    ("final_reviewer", "🎭 Final Review: Complete Screenplay Analysis"),
 ]
 
+
 # Save the Cat Beat Sheet
 SAVE_THE_CAT_BEATS = {
    1: "Opening Image (0-1%)",
@@ -382,13 +398,53 @@ class ScreenplayDatabase:
             conn.commit()
         return session_id
 
+# In ScreenplayDatabase.save_stage method, add page count tracking
+@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:
+        # Use the accurate page calculation
+        system = ScreenplayGenerationSystem()
+        page_count = system.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=?, updated_at=datetime('now')
+        ''', (session_id, stage_number, stage_name, role, content, page_count, status,
+              content, page_count, status))
+        
+        # Update total pages in session
+        if role == "screenwriter" and "Expanded" in stage_name:
+            cursor.execute('''
+                UPDATE screenplay_sessions 
+                SET total_pages = (
+                    SELECT SUM(page_count) 
+                    FROM screenplay_stages 
+                    WHERE session_id = ? 
+                    AND role = 'screenwriter' 
+                    AND stage_name LIKE '%Expanded%'
+                ),
+                updated_at = datetime('now')
+                WHERE session_id = ?
+            ''', (session_id, session_id))
+        
+        conn.commit()# In ScreenplayDatabase.save_stage method, add page count tracking
+
+        
     @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:
-            # Estimate pages based on screenplay format (rough estimate)
-            page_count = len(content.split('\n')) / 55  # ~55 lines per page
+            # Use the accurate page calculation
+            system = ScreenplayGenerationSystem()
+            page_count = system.calculate_screenplay_pages(content)
         
         with ScreenplayDatabase.get_db() as conn:
             cursor = conn.cursor()
@@ -401,14 +457,24 @@ class ScreenplayDatabase:
             ''', (session_id, stage_number, stage_name, role, content, page_count, status,
                   content, page_count, status))
             
-            # Update session info
-            cursor.execute('''
-                UPDATE screenplay_sessions 
-                SET current_stage = ?, updated_at = datetime('now')
-                WHERE session_id = ?
-            ''', (stage_number, session_id))
+            # Update total pages in session
+            if role == "screenwriter" and "Expanded" in stage_name:
+                cursor.execute('''
+                    UPDATE screenplay_sessions 
+                    SET total_pages = (
+                        SELECT SUM(page_count) 
+                        FROM screenplay_stages 
+                        WHERE session_id = ? 
+                        AND role = 'screenwriter' 
+                        AND stage_name LIKE '%Expanded%'
+                    ),
+                    updated_at = datetime('now')
+                    WHERE session_id = ?
+                ''', (session_id, session_id))
             
             conn.commit()
+    
+
 
     @staticmethod
     def save_screenplay_bible(session_id: str, bible: ScreenplayBible):
@@ -450,19 +516,33 @@ class ScreenplayDatabase:
             )
             conn.commit()
 
+
     @staticmethod
     def get_screenplay_content(session_id: str) -> str:
-        """Get complete screenplay content"""
+        """Get complete screenplay content - only expanded versions"""
         with ScreenplayDatabase.get_db() as conn:
+            # Get only the expanded final versions
             rows = conn.cursor().execute('''
                 SELECT content FROM screenplay_stages 
-                WHERE session_id = ? AND role = 'screenwriter' 
+                WHERE session_id = ? 
+                AND role = 'screenwriter' 
+                AND stage_name LIKE '%Expanded Final Version%'
                 ORDER BY stage_number
             ''', (session_id,)).fetchall()
             
             if rows:
                 return '\n\n'.join(row['content'] for row in rows if row['content'])
+            else:
+                # Fallback to any writer content
+                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 update_final_screenplay(session_id: str, final_screenplay: str, title: str, logline: str):
@@ -1060,17 +1140,22 @@ Plan each scene to advance story and develop character."""
     def create_screenwriter_prompt(self, act: str, scene_breakdown: str, 
                                   characters: str, previous_acts: str,
                                   screenplay_type: str, genre: str, language: str) -> str:
-        """Screenwriter prompt for actual screenplay pages"""
+        """Enhanced screenwriter prompt with strict length requirements"""
         
         act_pages = int(SCREENPLAY_LENGTHS[screenplay_type]['pages'] * 0.25)
+        min_lines = act_pages * 55  # 1 page = ~55 lines
+    
+        # Extract detailed scene information for this act
+        act_scenes = self._extract_act_scenes(scene_breakdown, act)
         
         lang_prompts = {
             "Korean": f"""당신은 프로 시나리오 작가입니다. {act}을 표준 시나리오 포맷으로 작성하세요.
-
-**타겟 분량:** {act_pages}페이지
+    
+**목표 분량:** {act_pages}페이지 (최소 {min_lines}줄 필수)
+**절대 규칙: {min_lines}줄 미만 작성시 실패로 간주됩니다.**
 
 **씬 브레이크다운:**
-{self._extract_act_scenes(scene_breakdown, act)}
+{act_scenes}
 
 **캐릭터 정보:**
 {characters}
@@ -1078,46 +1163,51 @@ Plan each scene to advance story and develop character."""
 **이전 내용:**
 {previous_acts if previous_acts else "첫 막입니다."}
 
-**시나리오 포맷 규칙:**
-
-1. **씬 헤딩**
+**필수 작성 요구사항:**
+
+1. **분량 달성 전략**
+   - 각 씬마다 최소 3-5페이지 할당
+   - 대화: 캐릭터간 충분한 교환 (각 대화 시퀀스 10-15줄)
+   - 액션: 상세한 시각적 묘사 (각 액션 비트 3-5줄)
+   - 전환: 씬 사이 충분한 브릿지 장면
+
+2. **대화 작성 지침**
+   - 서브텍스트가 풍부한 대화
+   - 갈등이 점진적으로 고조
+   - 캐릭터별 고유한 말투와 리듬
+   - 침묵과 반응의 적절한 활용
+   - 중요한 정보는 대화로 자연스럽게
+
+3. **액션 라인 상세화**
+   - 장소의 구체적이고 분위기 있는 묘사
+   - 캐릭터의 미세한 동작과 표정 포착
+   - 시간대와 날씨, 조명 등 환경 묘사
+   - 소품과 의상 등 시각적 디테일
+
+4. **{genre} 장르 특화 요소**
+   - 페이싱: {GENRE_TEMPLATES[genre]['pacing']}
+   - 씬 길이: {GENRE_TEMPLATES[genre]['scene_length']}
+   - 핵심 요소: {', '.join(GENRE_TEMPLATES[genre]['key_elements'])}
+
+5. **시나리오 포맷 규칙**
    INT. 장소 - 시간
-   EXT. 장소 - 시간
-
-2. **액션 라인**
-   - 현재 시제 사용
-   - 시각적으로 보이는 것만 묘사
-   - 4줄 이하로 유지
-   - 감정은 행동으로 표현
-
-3. **캐릭터 소개**
-   첫 등장시: 이름과 간단한 묘사
-
-4. **대화**
+   
+   액션 라인은 현재 시제로 작성.
+   시각적으로 보이는 것만 묘사.
+   
    캐릭터명
    (지문)
    대사
 
-5. **중요 원칙**
-   - Show, don't tell
-   - 서브텍스트 활용
-   - 자연스러운 대화
-   - 시각적 스토리텔링
-   - 페이지당 1분 규칙
-
-**{genre} 장르 특성:**
-- 대화 비율: {GENRE_TEMPLATES[genre]['dialogue_ratio']*100}%
-- 씬 길이: {GENRE_TEMPLATES[genre]['scene_length']}
-- 핵심 요소: {', '.join(GENRE_TEMPLATES[genre]['key_elements'][:2])}
+**반드시 {min_lines}줄 이상 작성하세요. 각 씬을 충분히 전개하고 디테일을 살려주세요.**""",
 
-정확한 포맷과 몰입감 있는 스토리텔링으로 작성하세요.""",
+        "English": f"""You are a professional screenwriter. Write {act} in standard screenplay format.
 
-            "English": f"""You are a professional screenwriter. Write {act} in standard screenplay format.
-
-**Target Length:** {act_pages} pages
+**Target Length:** {act_pages} pages (MINIMUM {min_lines} lines required)
+**ABSOLUTE RULE: Writing less than {min_lines} lines is considered failure.**
 
 **Scene Breakdown:**
-{self._extract_act_scenes(scene_breakdown, act)}
+{act_scenes}
 
 **Character Info:**
 {characters}
@@ -1125,43 +1215,49 @@ Plan each scene to advance story and develop character."""
 **Previous Content:**
 {previous_acts if previous_acts else "This is the first act."}
 
-**Screenplay Format Rules:**
-
-1. **Scene Headings**
+**Required Writing Elements:**
+
+1. **Volume Achievement Strategy**
+   - Allocate minimum 3-5 pages per scene
+   - Dialogue: Sufficient exchanges (10-15 lines per sequence)
+   - Action: Detailed visual descriptions (3-5 lines per beat)
+   - Transitions: Adequate bridge scenes between
+
+2. **Dialogue Guidelines**
+   - Rich subtext in conversations
+   - Gradually escalating conflict
+   - Unique voice and rhythm per character
+   - Appropriate use of pauses and reactions
+   - Important information through natural dialogue
+
+3. **Action Line Details**
+   - Specific atmospheric location descriptions
+   - Subtle character movements and expressions
+   - Time, weather, lighting environment
+   - Props and costume visual details
+
+4. **{genre} Genre Elements**
+   - Pacing: {GENRE_TEMPLATES[genre]['pacing']}
+   - Scene Length: {GENRE_TEMPLATES[genre]['scene_length']}
+   - Key Elements: {', '.join(GENRE_TEMPLATES[genre]['key_elements'])}
+
+5. **Screenplay Format Rules**
    INT. LOCATION - TIME
-   EXT. LOCATION - TIME
-
-2. **Action Lines**
-   - Present tense
-   - Only what's visually seen
-   - Keep under 4 lines
-   - Emotions through actions
-
-3. **Character Intros**
-   First appearance: NAME with brief description
-
-4. **Dialogue**
+   
+   Action lines in present tense.
+   Only what's visually seen.
+   
    CHARACTER NAME
    (parenthetical)
    Dialogue
 
-5. **Key Principles**
-   - Show, don't tell
-   - Use subtext
-   - Natural dialogue
-   - Visual storytelling
-   - One page = one minute
-
-**{genre} Genre Characteristics:**
-- Dialogue Ratio: {GENRE_TEMPLATES[genre]['dialogue_ratio']*100}%
-- Scene Length: {GENRE_TEMPLATES[genre]['scene_length']}
-- Key Elements: {', '.join(GENRE_TEMPLATES[genre]['key_elements'][:2])}
-
-Write with proper format and engaging storytelling."""
+**MUST write {min_lines}+ lines. Fully develop each scene with rich details.**"""
         }
-        
+    
         return lang_prompts.get(language, lang_prompts["English"])
 
+
+
     def create_script_doctor_prompt(self, act_content: str, act: str,
                                    genre: str, language: str) -> str:
         """Script doctor review and polish"""
@@ -1487,14 +1583,14 @@ Provide specific solutions for each issue."""
                 *messages
             ]
             
-            max_tokens = 15000 if role == "screenwriter" else 8000
+            max_tokens = 25000 if role == "screenwriter" else 15000
             
             payload = {
                 "model": self.model_id,
                 "messages": full_messages,
                 "max_tokens": max_tokens,
-                "temperature": 0.7 if role in ["screenwriter", "script_doctor"] else 0.8,
-                "top_p": 0.9,
+                "temperature": 0.8 if role in ["screenwriter", "script_doctor"] else 0.7,
+                "top_p": 0.95,
                 "presence_penalty": 0.3,
                 "frequency_penalty": 0.3,
                 "stream": True
@@ -1804,7 +1900,9 @@ You provide feedback that's critical yet encouraging."""
     def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
                         screenplay_type: str, genre: str, language: str, 
                         stages: List[Dict]) -> str:
-        """Generate stage-specific prompt"""
+        """Generate stage-specific prompt - Enhanced for expansion stages"""
+        
+        # Initial stages (0-4)
         if stage_idx == 0:  # Producer
             return self.create_producer_prompt(query, screenplay_type, genre, language)
         
@@ -1828,26 +1926,44 @@ You provide feedback that's critical yet encouraging."""
                 stages[1]["content"], stages[2]["content"], screenplay_type, genre, language
             )
         
-        # Screenwriter acts
-        if role == "screenwriter":
-            act_mapping = {5: "Act 1", 7: "Act 2A", 9: "Act 2B", 11: "Act 3"}
-            if stage_idx in act_mapping:
-                act = act_mapping[stage_idx]
+        # Act writing stages (5-16)
+        # Act 1: stages 5-7, Act 2A: 8-10, Act 2B: 11-13, Act 3: 14-16
+        
+        # Determine which act and phase
+        act_stages = {
+            5: ("Act 1", "draft"), 6: ("Act 1", "review"), 7: ("Act 1", "expand"),
+            8: ("Act 2A", "draft"), 9: ("Act 2A", "review"), 10: ("Act 2A", "expand"),
+            11: ("Act 2B", "draft"), 12: ("Act 2B", "review"), 13: ("Act 2B", "expand"),
+            14: ("Act 3", "draft"), 15: ("Act 3", "review"), 16: ("Act 3", "expand"),
+        }
+        
+        if stage_idx in act_stages:
+            act, phase = act_stages[stage_idx]
+            
+            if phase == "draft":
+                # First draft writing
                 previous_acts = self._get_previous_acts(stages, stage_idx)
                 return self.create_screenwriter_prompt(
                     act, stages[4]["content"], stages[2]["content"], 
                     previous_acts, screenplay_type, genre, language
                 )
+            
+            elif phase == "review":
+                # Script doctor review for expansion
+                draft_content = stages[stage_idx-1]["content"]
+                return self.create_script_doctor_expansion_prompt(
+                    draft_content, act, screenplay_type, genre, language
+                )
+            
+            elif phase == "expand":
+                # Expanded rewrite
+                original_content = stages[stage_idx-2]["content"]  # Original draft
+                expansion_notes = stages[stage_idx-1]["content"]   # Review notes
+                return self.create_expansion_writer_prompt(
+                    act, original_content, expansion_notes, screenplay_type, language
+                )
         
-        # Script doctor reviews
-        if role == "script_doctor":
-            act_mapping = {6: "Act 1", 8: "Act 2A", 10: "Act 2B"}
-            if stage_idx in act_mapping:
-                act = act_mapping[stage_idx]
-                act_content = stages[stage_idx-1]["content"]
-                return self.create_script_doctor_prompt(act_content, act, genre, language)
-        
-        # Final reviewer
+        # Final reviewer (stage 17)
         if role == "final_reviewer":
             complete_screenplay = ScreenplayDatabase.get_screenplay_content(self.current_session_id)
             return self.create_final_reviewer_prompt(
@@ -1855,6 +1971,8 @@ You provide feedback that's critical yet encouraging."""
             )
         
         return ""
+    
+
 
     def _get_previous_acts(self, stages: List[Dict], current_idx: int) -> str:
         """Get previous acts content"""