Update app.py

app.py

@@ -1868,107 +1868,86 @@ 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"""
-        # More flexible pattern that handles various formats
+    def _extract_field(content: str, field_pattern: str) -> Optional[str]:
         pattern = rf'{field_pattern}[:\s]*([^\n]+?)(?=\n[A-Z가-힣]|$)'
         match = re.search(pattern, content, re.IGNORECASE | re.DOTALL)
-        if match and match.group(1):  # Check if group(1) exists and is not None
+        if match and match.group(1):
             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 = re.sub(r'\*\*', '', value)           # **bold** 제거
+            value = re.sub(r'^\s*[-•]\s*', '', value)    # 글머리표 제거
+            value = re.sub(r'[,.:;]+$', '', value)       # 행 끝 구두점 제거
+            return value.strip() or 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*',
-            r'^\s*[-*•]\s*([^,\n]+?)(?:\s*\([^)]+\))?\s*',
-            r'^([^,\n]+?)(?:\s*\([^)]+\))?\s*'
+            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 and name_match.group(1):
-                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
-        
-        # Helper function to extract clean fields
-        def extract_clean_field(patterns):
-            if isinstance(patterns, str):
-                patterns = [patterns]
-            
-            for pattern in patterns:
-                # Improved pattern with better capturing groups
-                match = re.search(rf'{pattern}[:\s]*([^\n*]+?)(?=\n|$)', content, re.IGNORECASE | re.DOTALL)
-                if match and match.group(1):
-                    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 with safer extraction
-        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,
             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}")
-        return profile
+    
+ 
 
     def _extract_personality_traits(self, content: str) -> List[str]:
         """Extract personality traits from content"""