Update app-backup.py

app-backup.py

@@ -197,7 +197,6 @@ class SceneBreakdown:
 class CharacterProfile:
    """Detailed character profile"""
    name: str
-   age: int
    role: str  # protagonist, antagonist, supporting, etc.
    archetype: str
    want: str  # External goal
@@ -537,18 +536,6 @@ class ScreenplayDatabase:
         
         return theme_id
 
-    @staticmethod
-    def get_stages(session_id: str) -> List[Dict]:
-        """Get all stages for a session"""
-        with ScreenplayDatabase.get_db() as conn:
-            rows = conn.cursor().execute(
-                '''SELECT * FROM screenplay_stages 
-                   WHERE session_id = ? 
-                   ORDER BY stage_number''', 
-                (session_id,)
-            ).fetchall()
-            return [dict(row) for row in rows]
-
 class WebSearchIntegration:
    """Web search functionality for screenplay research"""
    def __init__(self):
@@ -878,7 +865,7 @@ Create specific, emotionally resonant story."""
 **필수 캐릭터 프로필:**
 
 1. **주인공 (PROTAGONIST)**
-   - 이름 & 나이:
+   - 이름:
    - 직업/역할:
    - 캐릭터 아크타입:
    - WANT (외적 목표):
@@ -891,7 +878,7 @@ Create specific, emotionally resonant story."""
    - 캐릭터 아크 (A→B):
 
 2. **적대자 (ANTAGONIST)**
-   - 이름 & 나이:
+   - 이름:
    - 직업/역할:
    - 악역 아크타입:
    - 목표 & 동기:
@@ -916,7 +903,7 @@ Create specific, emotionally resonant story."""
 
 5. **캐스팅 제안**
    - 각 주요 캐릭터별 이상적인 배우 타입
-   - 연령대, 외모, 연기 스타일
+   - 외모, 연기 스타일
 
 6. **대화 샘플**
    - 각 주요 캐릭터의 시그니처 대사 2-3개
@@ -935,7 +922,7 @@ Create specific, emotionally resonant story."""
 **Required Character Profiles:**
 
 1. **PROTAGONIST**
-   - Name & Age:
+   - Name:
    - Occupation/Role:
    - Character Archetype:
    - WANT (External Goal):
@@ -948,7 +935,7 @@ Create specific, emotionally resonant story."""
    - Character Arc (A→B):
 
 2. **ANTAGONIST**
-   - Name & Age:
+   - Name:
    - Occupation/Role:
    - Villain Archetype:
    - Goal & Motivation:
@@ -973,7 +960,7 @@ Create specific, emotionally resonant story."""
 
 5. **CASTING SUGGESTIONS**
    - Ideal actor type for each major character
-   - Age range, appearance, acting style
+   - Appearance, acting style
 
 6. **DIALOGUE SAMPLES**
    - 2-3 signature lines per major character
@@ -1104,7 +1091,7 @@ Plan each scene to advance story and develop character."""
    - 감정은 행동으로 표현
 
 3. **캐릭터 소개**
-   첫 등장시: 이름 (나이) 간단한 묘사
+   첫 등장시: 이름과 간단한 묘사
 
 4. **대화**
    캐릭터명
@@ -1151,7 +1138,7 @@ Plan each scene to advance story and develop character."""
    - Emotions through actions
 
 3. **Character Intros**
-   First appearance: NAME (age) brief description
+   First appearance: NAME with brief description
 
 4. **Dialogue**
    CHARACTER NAME
@@ -1482,8 +1469,6 @@ Provide specific solutions for each issue."""
             raise Exception(f"LLM Call Failed: {full_content}")
         return full_content
 
-
-
     def call_llm_streaming(self, messages: List[Dict[str, str]], role: str, 
                           language: str) -> Generator[str, None, None]:
         try:
@@ -1604,7 +1589,6 @@ Provide specific solutions for each issue."""
                                             yield buffer
                                             buffer = ""
                                             time.sleep(0.01)
-                    
                 except Exception as e:
                     logger.error(f"Error processing line {line_count}: {str(e)}")
                     logger.debug(f"Problematic line: {line_str[:100] if 'line_str' in locals() else 'N/A'}")
@@ -1634,8 +1618,6 @@ Provide specific solutions for each issue."""
             logger.error(traceback.format_exc())
             yield f"❌ Unexpected error: {str(e)}"
 
-
-
     def get_system_prompts(self, language: str) -> Dict[str, str]:
         """Role-specific system prompts"""
         
@@ -1726,9 +1708,7 @@ You provide feedback that's critical yet encouraging."""
         
         return base_prompts.get(language, base_prompts["English"])
 
-
-
-# --- Main process ---
+    # --- Main process ---
     def process_screenplay_stream(self, query: str, screenplay_type: str, genre: str,
                                 language: str, session_id: Optional[str] = None
                                 ) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
@@ -1889,279 +1869,296 @@ You provide feedback that's critical yet encouraging."""
         return "\n\n---\n\n".join(previous) if previous else ""
 
 
+    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
+            """Extract field value from content with improved parsing"""
+            pattern = rf'{field_pattern}[:\s]*([^\n]+?)(?=\n[A-Z가-힣]|$)'
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match and match.group(1):
+                value = match.group(1).strip()
+                value = re.sub(r'\*\*', '', value)           # **bold** 제거
+                value = re.sub(r'^\s*[-•]\s*', '', value)    # 글머리표 제거
+                value = re.sub(r'[,.:;]+$', '', value)       # 행 끝 구두점 제거
+                return value.strip() if value else None
+            return None
+
+    
+
+
     def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
         """Parse character profile from content"""
-        # Debug logging
         logger.debug(f"Parsing character profile for role: {role}")
         logger.debug(f"Content preview: {content[:200]}...")
-        
-        # Extract name first - handle various formats
-        name = f"Character_{role}"  # default
+    
+        # 1) 이름 추출 ─ 패턴 3종
+        name = f"Character_{role}"  # fallback
         name_patterns = [
-            r'(?:이름|Name)[:\s]*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?',
-            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?',
-            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?'
+            r'(?:이름|Name)[:\s]*([^\n,(]+)',         # "이름: 홍길동"
+            r'^\s*[-*•]\s*([^\n,(]+)',               # "- 홍길동"
+            r'^([^\n,(]+)'                           # 문단 첫 단어
         ]
-        
-        for pattern in name_patterns:
-            name_match = re.search(pattern, content, re.IGNORECASE | re.MULTILINE)
-            if name_match:
-                extracted_name = name_match.group(1).strip()
-                # Remove markdown and extra characters
-                extracted_name = re.sub(r'[*:\s]+$', '', extracted_name)
-                extracted_name = re.sub(r'^[*:\s]+', '', extracted_name)
-                if extracted_name and len(extracted_name) > 1:
-                    name = extracted_name
-                    break
-        
-        # Extract age with multiple patterns
-        age = 30  # default age
-        age_patterns = [
-            r'(\d+)\s*세',
-            r'(\d+)\s*살',
-            r',\s*(\d+)\s*[,\s]',
-            r'\((\d+)\)',
-            r'Age[:\s]*(\d+)',
-            r'나이[:\s]*(\d+)'
-        ]
-        
-        for pattern in age_patterns:
-            age_match = re.search(pattern, content, re.IGNORECASE)
-            if age_match:
-                try:
-                    extracted_age = int(age_match.group(1))
-                    if 10 <= extracted_age <= 100:  # Reasonable age range
-                        age = extracted_age
-                        logger.debug(f"Extracted age: {age}")
-                        break
-                except ValueError:
-                    continue
-        
-        # Helper function to extract clean fields
-        def extract_clean_field(patterns):
-            if isinstance(patterns, str):
-                patterns = [patterns]
-            
-            for pattern in patterns:
-                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, re.IGNORECASE | re.DOTALL)
-                if match:
-                    value = match.group(1).strip()
-                    # Clean up the value
-                    value = re.sub(r'^[-*•:\s]+', '', value)
-                    value = re.sub(r'[*]+', '', value)
-                    value = re.sub(r'\s+', ' ', value)
-                    if value:
-                        return value
+        for pat in name_patterns:
+            m = re.search(pat, content, re.IGNORECASE | re.MULTILINE)
+            if m and m.group(1).strip():
+                name = re.sub(r'[\*:\s]+', '', m.group(1).strip())  # 불필요 기호 제거
+                break
+    
+        # 2) 필드 추출용 헬퍼
+        def extract_clean_field(pats):
+            pats = [pats] if isinstance(pats, str) else pats
+            for p in pats:
+                m = re.search(rf'{p}[:\s]*([^\n*]+?)(?=\n|$)', content,
+                              re.IGNORECASE | re.DOTALL)
+                if m and m.group(1).strip():
+                    v = m.group(1).strip()
+                    v = re.sub(r'^[-*•:\s]+', '', v)   # 리스트·기호 제거
+                    v = v.replace('*', '').strip()
+                    return v
             return ""
-        
-        # Extract all fields
-        profile = CharacterProfile(
+    
+        # 3) Personality(여러 줄) 따로 파싱
+        def extract_traits():
+            section = re.search(r'(?:Personality|성격[^\n]*)\n((?:[-*•].+\n?)+)',
+                                content, re.IGNORECASE)
+            if not section:
+                return []
+            traits = [
+                re.sub(r'^[-*•]\s*', '', line.strip())
+                for line in section.group(1).splitlines() if line.strip()
+            ]
+            return traits[:5]
+    
+        # 4) CharacterProfile 생성
+        return CharacterProfile(
             name=name,
-            age=age,
             role=role,
-            archetype=extract_clean_field([
-                r"캐릭터 아크타입",
-                r"Character Archetype",
-                r"Archetype",
-                r"아크타입"
-            ]),
-            want=extract_clean_field([
-                r"WANT\s*\(외적 목표\)",
-                r"WANT",
-                r"외적 목표",
-                r"External Goal"
-            ]),
-            need=extract_clean_field([
-                r"NEED\s*\(내적 필요\)",
-                r"NEED",
-                r"내적 필요",
-                r"Internal Need"
-            ]),
-            backstory=extract_clean_field([
-                r"백스토리",
-                r"Backstory",
-                r"핵심 상처",
-                r"Core Wound"
-            ]),
-            personality=self._extract_personality_traits(content),
-            speech_pattern=extract_clean_field([
-                r"말투.*?패턴",
-                r"Speech Pattern",
-                r"언어 패턴",
-                r"말투"
-            ]),
-            character_arc=extract_clean_field([
-                r"캐릭터 아크",
-                r"Character Arc",
-                r"Arc",
-                r"변화"
-            ])
+            archetype=extract_clean_field(
+                [r"캐릭터 아크타입", r"Character Archetype", r"Archetype", r"아크타입"]
+            ),
+            want=extract_clean_field(
+                [r"WANT\s*\(외적 목표\)", r"WANT", r"외적 목표", r"External Goal"]
+            ),
+            need=extract_clean_field(
+                [r"NEED\s*\(내적 필요\)", r"NEED", r"내적 필요", r"Internal Need"]
+            ),
+            backstory=extract_clean_field(
+                [r"백스토리", r"Backstory", r"핵심 상처", r"Core Wound"]
+            ),
+            personality=extract_traits(),
+            speech_pattern=extract_clean_field(
+                [r"말투.*?패턴", r"Speech Pattern", r"언어 패턴", r"말투"]
+            ),
+            character_arc=extract_clean_field(
+                [r"캐릭터 아크", r"Character Arc", r"Arc", r"변화"]
+            ),
         )
-        
-        logger.debug(f"Parsed character: {profile.name}, age: {profile.age}")
-        return profile
-
-    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-        """Extract field value from content with improved parsing"""
-        # Use word boundary to prevent partial matches
-        pattern = rf'\b{field_pattern}\b[:\s]*([^\n]+?)(?=\n|$)'
-        match = re.search(pattern, content, re.IGNORECASE)
-        if match:
-            value = match.group(1).strip()
-            # Remove markdown formatting
-            value = re.sub(r'\*+', '', value)
-            # Remove list markers
-            value = re.sub(r'^\s*[-•*]\s*', '', value)
-            # Remove trailing punctuation
-            value = re.sub(r'[,.:;]$', '', value)
-            return value.strip()
-        return None
+    
+ 
 
     def _extract_personality_traits(self, content: str) -> List[str]:
-       """Extract personality traits from content"""
-       traits = []
-       # Look for personality section
-       personality_section = self._extract_field(content, r"(?:Personality|성격)[:\s]*")
-       if personality_section:
-           # Extract individual traits (usually listed)
-           trait_lines = personality_section.split('\n')
-           for line in trait_lines:
-               line = line.strip()
-               if line and not line.endswith(':'):
-                   # Remove list markers
-                   trait = re.sub(r'^\s*[-•*]\s*', '', line)
-                   if trait:
-                       traits.append(trait)
-       return traits[:5]  # Limit to 5 traits
+        """Extract personality traits from content"""
+        traits = []
+        # Look for personality section with multiple pattern options
+        personality_patterns = [
+            r"(?:Personality|성격 특성|성격)[:\s]*([^\n]+(?:\n(?![\w가-힣]+:)[^\n]+)*)",
+            r"성격[:\s]*(?:\n?[-•*]\s*[^\n]+)+"
+        ]
+        
+        for pattern in personality_patterns:
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match and match.group(1):
+                personality_section = match.group(1)
+                # Extract individual traits (usually listed)
+                trait_lines = personality_section.split('\n')
+                for line in trait_lines:
+                    line = line.strip()
+                    if line and not line.endswith(':'):
+                        # Remove list markers
+                        trait = re.sub(r'^\s*[-•*]\s*', '', line)
+                        trait = re.sub(r'^\d+\.\s*', '', trait)  # Remove numbered lists
+                        if trait and len(trait) > 2:  # Skip very short entries
+                            traits.append(trait)
+                if traits:  # If we found traits, stop looking
+                    break
+        
+        return traits[:5]  # Limit to 5 traits
 
     def _process_character_content(self, content: str):
-       """Process character designer output with better error handling"""
-       try:
-           # Extract protagonist
-           protagonist_section = self._extract_section(content, r"(?:PROTAGONIST|주인공)")
-           if protagonist_section:
-               protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-               self.screenplay_tracker.add_character(protagonist)
-               ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-           
-           # Extract antagonist
-           antagonist_section = self._extract_section(content, r"(?:ANTAGONIST|적대자)")
-           if antagonist_section:
-               antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-               self.screenplay_tracker.add_character(antagonist)
-               ScreenplayDatabase.save_character(self.current_session_id, antagonist)
-           
-           # Extract supporting characters
-           supporting_section = self._extract_section(content, r"(?:SUPPORTING CAST|조력자들)")
-           if supporting_section:
-               # Parse multiple supporting characters
-               self._parse_supporting_characters(supporting_section)
-               
-       except Exception as e:
-           logger.error(f"Error processing character content: {e}")
-           # Continue with default values rather than failing
-
-    def _parse_supporting_characters(self, content: str):
-       """Parse supporting characters from content"""
-       # Split by character markers (numbers or bullets)
-       char_sections = re.split(r'\n(?:\d+\.|[-•*])\s*', content)
-       
-       for i, section in enumerate(char_sections[1:], 1):  # Skip first empty split
-           if section.strip():
-               try:
-                   name = self._extract_field(section, r"(?:Name|이름)[:\s]*") or f"Supporting_{i}"
-                   role = self._extract_field(section, r"(?:Role|역할)[:\s]*") or "supporting"
-                   
-                   character = CharacterProfile(
-                       name=name,
-                       age=30,  # Default age for supporting characters
-                       role="supporting",
-                       archetype=role,
-                       want="",
-                       need="",
-                       backstory=self._extract_field(section, r"(?:Backstory|백스토리)[:\s]*") or "",
-                       personality=[],
-                       speech_pattern="",
-                       character_arc=""
-                   )
-                   
-                   self.screenplay_tracker.add_character(character)
-                   ScreenplayDatabase.save_character(self.current_session_id, character)
-                   
-               except Exception as e:
-                   logger.warning(f"Error parsing supporting character {i}: {e}")
-                   continue
+        """Process character designer output with better error handling"""
+        try:
+            # Extract protagonist
+            protagonist_section = self._extract_section(content, r"(?:PROTAGONIST|주인공)")
+            if protagonist_section:
+                try:
+                    protagonist = self._parse_character_profile(protagonist_section, "protagonist")
+                    self.screenplay_tracker.add_character(protagonist)
+                    ScreenplayDatabase.save_character(self.current_session_id, protagonist)
+                except Exception as e:
+                    logger.error(f"Error parsing protagonist: {e}")
+                    # Create a default protagonist to continue
+                    protagonist = CharacterProfile(
+                        name="Protagonist",
+                        role="protagonist",
+                        archetype="Hero",
+                        want="To achieve goal",
+                        need="To grow",
+                        backstory="Unknown",
+                        personality=["Determined"],
+                        speech_pattern="Normal",
+                        character_arc="Growth"
+                    )
+                    self.screenplay_tracker.add_character(protagonist)
+            
+            # Extract antagonist
+            antagonist_section = self._extract_section(content, r"(?:ANTAGONIST|적대자)")
+            if antagonist_section:
+                try:
+                    antagonist = self._parse_character_profile(antagonist_section, "antagonist")
+                    self.screenplay_tracker.add_character(antagonist)
+                    ScreenplayDatabase.save_character(self.current_session_id, antagonist)
+                except Exception as e:
+                    logger.error(f"Error parsing antagonist: {e}")
+                    # Create a default antagonist to continue
+                    antagonist = CharacterProfile(
+                        name="Antagonist",
+                        role="antagonist",
+                        archetype="Villain",
+                        want="To stop protagonist",
+                        need="Power",
+                        backstory="Unknown",
+                        personality=["Ruthless"],
+                        speech_pattern="Menacing",
+                        character_arc="Downfall"
+                    )
+                    self.screenplay_tracker.add_character(antagonist)
+            
+            # Extract supporting characters
+            supporting_section = self._extract_section(content, r"(?:SUPPORTING CAST|조력자들)")
+            if supporting_section:
+                # Parse multiple supporting characters
+                self._parse_supporting_characters(supporting_section)
+                
+        except Exception as e:
+            logger.error(f"Error processing character content: {e}")
+            # Continue with default values rather than failing
 
     def _extract_section(self, content: str, section_pattern: str) -> str:
-       """Extract section from content with improved pattern matching"""
-       # More flexible section extraction
-       pattern = rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)'
-       match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-       if match:
-           return match.group(1).strip()
-       
-       # Try alternative pattern
-       pattern2 = rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)'
-       match2 = re.search(pattern2, content, re.IGNORECASE | re.DOTALL)
-       if match2:
-           return match2.group(1).strip()
-       
-       return ""
-
-    def _process_producer_content(self, content: str):
-       """Process producer output with better extraction"""
-       try:
-           # Extract title with various formats
-           title_patterns = [
-               r'(?:TITLE|제목)[:\s]*\*?\*?([^\n*]+)\*?\*?',
-               r'\*\*(?:TITLE|제목)\*\*[:\s]*([^\n]+)',
-               r'Title[:\s]*([^\n]+)'
-           ]
-           
-           for pattern in title_patterns:
-               title_match = re.search(pattern, content, re.IGNORECASE)
-               if title_match:
-                   self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
-                   break
-           
-           # Extract logline with various formats
-           logline_patterns = [
-               r'(?:LOGLINE|로그라인)[:\s]*\*?\*?([^\n]+)',
-               r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+)',
-               r'Logline[:\s]*([^\n]+)'
-           ]
-           
-           for pattern in logline_patterns:
-               logline_match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-               if logline_match:
-                   # Get full logline (might be multi-line)
-                   logline_text = logline_match.group(1).strip()
-                   # Continue reading if it's incomplete
-                   if not logline_text.endswith('.'):
-                       next_lines = content[logline_match.end():].split('\n')
-                       for line in next_lines[:3]:  # Check next 3 lines
-                           if line.strip() and not re.match(r'^[A-Z가-힣\d]', line.strip()):
-                               logline_text += ' ' + line.strip()
-                           else:
-                               break
-                   self.screenplay_tracker.screenplay_bible.logline = logline_text
-                   break
-           
-           # Extract genre
-           genre_match = re.search(r'(?:Primary Genre|주 장르)[:\s]*([^\n]+)', content, re.IGNORECASE)
-           if genre_match:
-               self.screenplay_tracker.screenplay_bible.genre = genre_match.group(1).strip()
-           
-           # Save to database
-           ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
-                                                  self.screenplay_tracker.screenplay_bible)
-                                                  
-       except Exception as e:
-           logger.error(f"Error processing producer content: {e}")
-
-
+        """Extract section from content with improved pattern matching"""
+        # More flexible section extraction
+        patterns = [
+            # Pattern 1: Section header followed by content until next major section
+            rf'{section_pattern}[:\s]*\n?(.*?)(?=\n\n[A-Z가-힣]{{2,}}[:\s]|\n\n\d+\.|$)',
+            # Pattern 2: Section header with content until next section (alternative)
+            rf'{section_pattern}.*?\n((?:.*\n)*?)(?=\n[A-Z가-힣]{{2,}}:|$)',
+            # Pattern 3: More flexible pattern for Korean text
+            rf'{section_pattern}[:\s]*\n?((?:[^\n]+\n?)*?)(?=\n\n|\Z)'
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+            if match and match.group(1):
+                section_content = match.group(1).strip()
+                if section_content:  # Only return if we got actual content
+                    return section_content
+        
+        return ""
 
+    def _parse_supporting_characters(self, content: str):
+        """Parse supporting characters from content"""
+        # Split by character markers (numbers or bullets)
+        char_sections = re.split(r'\n(?:\d+\.|[-•*])\s*', content)
+        
+        for i, section in enumerate(char_sections[1:], 1):  # Skip first empty split
+            if section.strip():
+                try:
+                    # Try multiple name extraction patterns
+                    name = None
+                    name_patterns = [
+                        r"(?:이름|Name)[:\s]*([^,\n]+)",
+                        r"^([^:\n]+?)(?:\s*[-–]\s*|:\s*)",  # Name at start before dash or colon
+                        r"^([가-힣A-Za-z\s]+?)(?:\s*\(|$)"  # Korean/English name before parenthesis
+                    ]
+                    
+                    for pattern in name_patterns:
+                        name_match = re.search(pattern, section.strip(), re.IGNORECASE)
+                        if name_match and name_match.group(1):
+                            name = name_match.group(1).strip()
+                            if name and len(name) > 1:
+                                break
+                    
+                    if not name:
+                        name = f"Supporting_{i}"
+                    
+                    role_desc = self._extract_field(section, r"(?:Role|역할)[:\s]*") or "supporting"
+                    
+                    character = CharacterProfile(
+                        name=name,
+                        role="supporting",
+                        archetype=role_desc,
+                        want="",
+                        need="",
+                        backstory=self._extract_field(section, r"(?:Backstory|백스토리)[:\s]*") or "",
+                        personality=[],
+                        speech_pattern="",
+                        character_arc=""
+                    )
+                    
+                    self.screenplay_tracker.add_character(character)
+                    ScreenplayDatabase.save_character(self.current_session_id, character)
+                    
+                except Exception as e:
+                    logger.warning(f"Error parsing supporting character {i}: {e}")
+                    continue
 
+    def _process_producer_content(self, content: str):
+        """Process producer output with better extraction"""
+        try:
+            # Extract title with various formats
+            title_patterns = [
+                r'(?:TITLE|제목)[:\s]*\*?\*?([^\n*]+)\*?\*?',
+                r'\*\*(?:TITLE|제목)\*\*[:\s]*([^\n]+)',
+                r'Title[:\s]*([^\n]+)'
+            ]
+            
+            for pattern in title_patterns:
+                title_match = re.search(pattern, content, re.IGNORECASE)
+                if title_match:
+                    self.screenplay_tracker.screenplay_bible.title = title_match.group(1).strip()
+                    break
+            
+            # Extract logline with various formats
+            logline_patterns = [
+                r'(?:LOGLINE|로그라인)[:\s]*\*?\*?([^\n]+)',
+                r'\*\*(?:LOGLINE|로그라인)\*\*[:\s]*([^\n]+)',
+                r'Logline[:\s]*([^\n]+)'
+            ]
+            
+            for pattern in logline_patterns:
+                logline_match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
+                if logline_match:
+                    # Get full logline (might be multi-line)
+                    logline_text = logline_match.group(1).strip()
+                    # Continue reading if it's incomplete
+                    if not logline_text.endswith('.'):
+                        next_lines = content[logline_match.end():].split('\n')
+                        for line in next_lines[:3]:  # Check next 3 lines
+                            if line.strip() and not re.match(r'^[A-Z가-힣\d]', line.strip()):
+                                logline_text += ' ' + line.strip()
+                            else:
+                                break
+                    self.screenplay_tracker.screenplay_bible.logline = logline_text
+                    break
+            
+            # Extract genre
+            genre_match = re.search(r'(?:Primary Genre|주 장르)[:\s]*([^\n]+)', content, re.IGNORECASE)
+            if genre_match:
+                self.screenplay_tracker.screenplay_bible.genre = genre_match.group(1).strip()
+            
+            # Save to database
+            ScreenplayDatabase.save_screenplay_bible(self.current_session_id, 
+                                                   self.screenplay_tracker.screenplay_bible)
+                                                   
+        except Exception as e:
+            logger.error(f"Error processing producer content: {e}")
 
     def _process_story_content(self, content: str):
         """Process story developer output"""
@@ -2176,22 +2173,6 @@ You provide feedback that's critical yet encouraging."""
         ScreenplayDatabase.save_screenplay_bible(self.current_session_id,
                                                self.screenplay_tracker.screenplay_bible)
 
-    def _process_character_content(self, content: str):
-        """Process character designer output"""
-        # Extract protagonist
-        protagonist_section = self._extract_section(content, "PROTAGONIST|주인공")
-        if protagonist_section:
-            protagonist = self._parse_character_profile(protagonist_section, "protagonist")
-            self.screenplay_tracker.add_character(protagonist)
-            ScreenplayDatabase.save_character(self.current_session_id, protagonist)
-        
-        # Extract antagonist
-        antagonist_section = self._extract_section(content, "ANTAGONIST|적대자")
-        if antagonist_section:
-            antagonist = self._parse_character_profile(antagonist_section, "antagonist")
-            self.screenplay_tracker.add_character(antagonist)
-            ScreenplayDatabase.save_character(self.current_session_id, antagonist)
-
     def _process_scene_content(self, content: str):
         """Process scene planner output"""
         # Parse scene breakdown
@@ -2220,46 +2201,6 @@ You provide feedback that's critical yet encouraging."""
             self.screenplay_tracker.add_scene(scene)
             ScreenplayDatabase.save_scene(self.current_session_id, scene)
 
-    def _extract_section(self, content: str, section_pattern: str) -> str:
-        """Extract section from content"""
-        pattern = rf'(?:{section_pattern})[:\s]*(.+?)(?=\n(?:[A-Z]{{2,}}|[가-힣]{{2,}}):|\Z)'
-        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-        return match.group(1).strip() if match else ""
-
-    def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
-        """Parse character profile from content"""
-        # Extract character details using regex or string parsing
-        name = self._extract_field(content, "Name|이름") or f"Character_{role}"
-        age = int(self._extract_field(content, "Age|나이") or "30")
-        
-        return CharacterProfile(
-            name=name,
-            age=age,
-            role=role,
-            archetype=self._extract_field(content, "Archetype|아크타입") or "",
-            want=self._extract_field(content, "WANT|외적 목표") or "",
-            need=self._extract_field(content, "NEED|내적 필요") or "",
-            backstory=self._extract_field(content, "Backstory|백스토리") or "",
-            personality=[],  # Would be parsed from content
-            speech_pattern=self._extract_field(content, "Speech|말투") or "",
-            character_arc=self._extract_field(content, "Arc|아크") or ""
-        )
-
-    def _extract_field(self, content: str, field_pattern: str) -> Optional[str]:
-        """Extract field value from content with improved parsing"""
-        # More flexible pattern that handles various formats
-        pattern = rf'{field_pattern}(.+?)(?=\n[A-Z가-힣]|$)'
-        match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-        if match:
-            value = match.group(1).strip()
-            # Remove markdown formatting if present
-            value = re.sub(r'\*\*', '', value)
-            value = re.sub(r'^\s*[-•]\s*', '', value)
-            # Remove trailing punctuation
-            value = re.sub(r'[,.:;]$', '', value)
-            return value.strip()
-        return None
-
 # --- Utility functions ---
 def generate_random_screenplay_theme(screenplay_type: str, genre: str, language: str) -> str:
     """Generate random screenplay theme"""
@@ -2441,46 +2382,52 @@ def extract_logline_from_theme(theme_text: str) -> str:
    match = re.search(r'\*\*(?:Logline|로그라인):\*\*\s*(.+)', theme_text, re.IGNORECASE)
    return match.group(1).strip() if match else ""
 
+import re
+
 def format_screenplay_display(screenplay_text: str) -> str:
-   """Format screenplay for display"""
-   if not screenplay_text:
-       return "No screenplay content yet."
-   
-   formatted = "# 🎬 Screenplay\n\n"
-   
-   # Format scene headings
-   formatted_text = re.sub(
-       r'^(INT\.|EXT\.)(.*?)$',
-       r'**\1\2**',
-       screenplay_text,
-       flags=re.MULTILINE
-   )
-   
-   # Format character names (all caps on their own line)
-   formatted_text = re.sub(
-       r'^([A-Z][A-Z\s]+)$',
-       r'**\1**',
-       formatted_text,
-       flags=re.MULTILINE
-   )
-   
-   # Add spacing for readability
-   lines = formatted_text.split('\n')
-   formatted_lines = []
-   
-   for i, line in enumerate(lines):
-       formatted_lines.append(line)
-       # Add extra space after scene headings
-       if line.startswith('**INT.') or line.startswith('**EXT.'):
-           formatted_lines.append('')
-   
-   formatted += '\n'.join(formatted_lines)
-   
-   # Add page count
-   page_count = len(screenplay_text.split('\n')) / 55
-   formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted
-   
-   return formatted
+    """Convert raw screenplay text to a nicely formatted Markdown preview."""
+
+    if not screenplay_text:
+        return "No screenplay content yet."
+
+    # 1) 제목 영역
+    formatted = "# 🎬 Screenplay\n\n"
+
+    # 2) 씬 헤딩(INT./EXT. 라인) 볼드 처리
+    #    - ^  : 행의 시작
+    #    - .* : 행 전체
+    #    - re.MULTILINE : 각 줄마다 ^ $가 동작
+    formatted_text = re.sub(
+        r'^(INT\.|EXT\.).*$',             # 캡처: INT. 또는 EXT.으로 시작하는 한 줄
+        r'**\g<0>**',                     # 전체 행을 굵게
+        screenplay_text,
+        flags=re.MULTILINE
+    )
+
+    # 3) 대문자 전원(인물 이름) 볼드 처리
+    #    - [A-Z][A-Z\s]+$ : ALL-CAPS 글자와 공백만으로 이뤄진 행
+    formatted_text = re.sub(
+        r'^([A-Z][A-Z\s]+)$',
+        r'**\g<0>**',
+        formatted_text,
+        flags=re.MULTILINE
+    )
+
+    # 4) 가독성을 위해 INT./EXT. 뒤에 빈 줄 삽입
+    lines = formatted_text.splitlines()
+    pretty_lines = []
+    for line in lines:
+        pretty_lines.append(line)
+        if line.startswith("**INT.") or line.startswith("**EXT."):
+            pretty_lines.append("")        # 빈 줄 추가
+
+    formatted += "\n".join(pretty_lines)
+
+    # 5) 페이지 수(스크립트 규칙: 1 페이지 ≈ 55 라인) 계산
+    page_count = len(screenplay_text.splitlines()) / 55
+    formatted = f"**Total Pages: {page_count:.1f}**\n\n" + formatted
+    return formatted
+
 
 def format_stages_display(stages: List[Dict]) -> str:
    """Format stages display for screenplay"""
@@ -2926,4 +2873,4 @@ if __name__ == "__main__":
        server_port=7860,
        share=False,
        debug=True
-   )               
+   )