Update app.py

app.py

@@ -1891,25 +1891,38 @@ You provide feedback that's critical yet encouraging."""
 
     def _parse_character_profile(self, content: str, role: str) -> CharacterProfile:
         """Parse character profile from content"""
-        # Extract name first
-        name_match = re.search(r'(?:이름|Name)[:\s&]*\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?', content, re.IGNORECASE)
-        if name_match:
-            name = name_match.group(1).strip()
-            # Remove markdown formatting
-            name = re.sub(r'\*+', '', name)
-        else:
-            name = f"Character_{role}"
+        # 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
+        name_patterns = [
+            r'(?:이름|Name)[:\s]*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?',
+            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?',
+            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*,?\s*\d*세?'
+        ]
         
-        # Extract age with better parsing - handle various formats
+        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
-        
-        # Try different patterns to extract age
         age_patterns = [
-            r'(\d+)\s*세',  # 17세
-            r'(\d+)\s*살',  # 17살
-            r'(\d+)\s*years?\s*old',  # 17 years old
-            r'[,\s]\s*(\d+)\s*[,\s]',  # , 17 ,
-            r'\((\d+)\)',  # (17)
+            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:
@@ -1919,33 +1932,74 @@ You provide feedback that's critical yet encouraging."""
                     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
         
-        # Extract other fields with cleaner extraction
-        def extract_clean_field(pattern):
-            match = re.search(rf'{pattern}[:\s]*([^\n*]+)', content, re.IGNORECASE)
-            if match:
-                value = match.group(1).strip()
-                # Remove markdown and trailing punctuation
-                value = re.sub(r'\*+', '', value)
-                value = re.sub(r'[,.:;]$', '', value)
-                return value.strip()
+        # 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
             return ""
         
-        return CharacterProfile(
+        # Extract all fields
+        profile = CharacterProfile(
             name=name,
             age=age,
             role=role,
-            archetype=extract_clean_field(r"(?:캐릭터 아크타입|Character Archetype|Archetype)"),
-            want=extract_clean_field(r"(?:WANT|외적 목표)"),
-            need=extract_clean_field(r"(?:NEED|내적 필요)"),
-            backstory=extract_clean_field(r"(?:백스토리|Backstory|핵심 상처)"),
+            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"(?:말투.*?패턴|Speech Pattern)"),
-            character_arc=extract_clean_field(r"(?:캐릭터 아크|Character Arc|Arc)")
+            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"""