Update app.py

app.py

@@ -486,16 +486,29 @@ class ScreenplayGenerationSystem:
         }
 
     def call_llm_streaming(self, messages: List[Dict[str, str]], max_tokens: int = 8000) -> Generator[str, None, None]:
+        """LLM 호출 - 개선된 버전"""
         try:
+            # 한국어 강제 및 완전성 보장을 위한 시스템 메시지 강화
+            if messages and messages[0].get("role") == "system":
+                messages[0]["content"] = messages[0]["content"] + """
+
+【절대 준수 사항】
+1. 모든 응답을 완전한 한국어로 작성하세요.
+2. 영어 단어나 문장을 절대 사용하지 마세요.
+3. ... 이나 미완성 문장을 작성하지 마세요.
+4. 모든 문장을 완전하게 마무리하세요.
+5. 시나리오는 영화 포맷이며, 연극이 아닙니다.
+"""
+            
             payload = {
                 "model": self.model_id,
                 "messages": messages,
                 "max_tokens": max_tokens,
-                "temperature": 0.7,
-                "top_p": 0.9,
-                "top_k": 40,
-                "presence_penalty": 0.3,
-                "frequency_penalty": 0.3,
+                "temperature": 0.6,  # 더 일관성 있게 낮춤
+                "top_p": 0.85,  # 더 보수적으로
+                "top_k": 30,  # 더 제한적으로
+                "presence_penalty": 0.4,  # 반복 방지 강화
+                "frequency_penalty": 0.4,
                 "stream": True
             }
             
@@ -514,6 +527,8 @@ class ScreenplayGenerationSystem:
                 return
             
             buffer = ""
+            incomplete_check = 0
+            
             for line in response.iter_lines():
                 if not line:
                     continue
@@ -525,20 +540,41 @@ class ScreenplayGenerationSystem:
                     
                     data_str = line_str[6:]
                     if data_str == "[DONE]":
+                        # 마지막에 불완전한 내용 체크
+                        if buffer and "..." in buffer[-100:]:
+                            buffer = buffer.replace("...", "")
+                        if buffer:
+                            yield buffer
                         break
                     
                     data = json.loads(data_str)
                     if "choices" in data and len(data["choices"]) > 0:
                         content = data["choices"][0].get("delta", {}).get("content", "")
                         if content:
+                            # 영어 감지 및 필터링
+                            if any(ord(c) < 128 and c.isalpha() for c in content):
+                                # 영어가 포함된 경우 스킵하거나 경고
+                                logger.warning(f"English detected in content: {content[:50]}")
+                                # INT. EXT. 같은 시나리오 포맷은 허용
+                                if not any(term in content for term in ["INT.", "EXT.", "CUT TO", "FADE"]):
+                                    continue
+                            
                             buffer += content
-                            if len(buffer) >= 100 or '\n' in buffer:
+                            
+                            # 충분한 버퍼가 쌓이면 yield
+                            if len(buffer) >= 200 or '\n\n' in buffer:
+                                # 불완전한 ... 제거
+                                buffer = buffer.replace("......", "").replace(".....", "")
                                 yield buffer
                                 buffer = ""
-                except:
+                                
+                except Exception as e:
+                    logger.error(f"Line processing error: {e}")
                     continue
             
+            # 남은 버퍼 처리
             if buffer:
+                buffer = buffer.replace("......", "").replace(".....", "")
                 yield buffer
                 
         except Exception as e:
@@ -705,11 +741,17 @@ class ScreenplayGenerationSystem:
 
     def generate_act(self, session_id: str, act_name: str, planning_data: Dict, 
                     previous_acts: Dict) -> Generator[Tuple[ActProgress, str], None, None]:
-        """막별 시나리오 생성"""
+        """막별 시나리오 생성 - 개선된 버전"""
+        
         try:
             self.current_session_id = session_id
             self.planning_data = planning_data
             
+            # 세션 정보 복원
+            session_data = ScreenplayDatabase.get_session_data(session_id)
+            if session_data:
+                self.original_query = session_data.get('user_query', '')
+            
             stages = ACT_WRITING_STAGES.get(act_name, [])
             act_progress = ActProgress(
                 act_name=act_name,
@@ -732,29 +774,49 @@ class ScreenplayGenerationSystem:
                     # 역할별 프롬프트 생성
                     prompt = self._create_act_prompt(role, act_name, act_content, planning_data, previous_acts, stage_type)
                     
-                    # LLM 호출
+                    # 한국어 및 영화 포맷 강조
+                    system_message = f"""당신은 {role}입니다.
+{EXPERT_ROLES[role]['description']}
+
+【절대 규칙】
+1. 모든 내용을 한국어로 작성하세요.
+2. 영화 시나리오 포맷을 사용하세요 (연극 아님).
+3. 기획안 내용을 100% 반영하세요.
+4. 영어 사용 금지 (INT. EXT. 등 포맷 용어 제외).
+5. 완전한 문장으로 작성 (... 사용 금지)."""
+                    
                     messages = [
-                        {"role": "system", "content": f"당신은 {role}입니다. {EXPERT_ROLES[role]['description']}"},
+                        {"role": "system", "content": system_message},
                         {"role": "user", "content": prompt}
                     ]
                     
                     expert_output = ""
-                    for chunk in self.call_llm_streaming(messages, max_tokens=10000):
+                    line_count = 0
+                    
+                    for chunk in self.call_llm_streaming(messages, max_tokens=12000):
                         if chunk and not chunk.startswith("❌"):
-                            expert_output += chunk
+                            # 영어 필터링 (포맷 용어 제외)
+                            cleaned_chunk = self._clean_output(chunk)
+                            expert_output += cleaned_chunk
+                            line_count = len(expert_output.split('\n'))
+                            
                             # 실시간 업데이트
-                            yield act_progress, f"✏️ {role}: 작업 중..."
+                            yield act_progress, f"✏️ {role}: 작업 중... ({line_count}줄 작성)"
                     
                     # 웹 검색 고증
                     if role == "고증전문가" and self.web_searcher.enabled:
                         verification = self.web_searcher.verify_facts(act_content, act_name)
                         expert_output += f"\n\n【웹 검증 결과】\n{json.dumps(verification, ensure_ascii=False, indent=2)}"
                     
+                    # 출력 검증 및 정리
+                    if stage_type in ["초고", "완성"]:
+                        expert_output = self._validate_and_clean_screenplay(expert_output)
+                    
                     # 피드백 저장
                     feedback = ExpertFeedback(
                         role=role,
                         stage=f"{act_name}_{stage_type}",
-                        feedback=expert_output[:500],
+                        feedback=f"{role} 작업 완료. {line_count}줄 작성.",
                         suggestions=self._extract_suggestions(expert_output),
                         score=85.0 + random.uniform(-5, 10)
                     )
@@ -767,7 +829,7 @@ class ScreenplayGenerationSystem:
                     elif stage_type == "초고":
                         act_content = expert_output
                     
-                    yield act_progress, f"✅ {role} 작업 완료"
+                    yield act_progress, f"✅ {role} 작업 완료 ({line_count}줄)"
                     
                     time.sleep(0.5)
                     
@@ -776,50 +838,258 @@ class ScreenplayGenerationSystem:
                     break
                 except Exception as e:
                     logger.error(f"Error in act stage {idx}: {e}")
+                    yield act_progress, f"⚠️ {role} 작업 중 오류 발생"
                     continue
             
             # 막 완성
             act_progress.status = "complete"
             ScreenplayDatabase.save_act_content(session_id, act_name, act_content)
             
-            yield act_progress, f"✅ {act_name} 완성!"
+            # 최종 페이지 수 계산
+            page_count = len(act_content.split('\n')) / 58
+            yield act_progress, f"✅ {act_name} 완성! (약 {page_count:.1f}페이지)"
             
         except Exception as e:
             logger.error(f"Act generation error: {e}\n{traceback.format_exc()}")
             act_progress.status = "error"
             yield act_progress, f"❌ 오류: {str(e)}"
+    
+    def _clean_output(self, text: str) -> str:
+        """출력 텍스트 정리"""
+        # 영어 단어 제거 (시나리오 포맷 제외)
+        format_terms = ["INT.", "EXT.", "CUT TO:", "FADE IN:", "FADE OUT:", "DISSOLVE TO:"]
+        
+        lines = text.split('\n')
+        cleaned_lines = []
+        
+        for line in lines:
+            # 포맷 용어는 유지
+            if any(term in line for term in format_terms):
+                cleaned_lines.append(line)
+            else:
+                # 영어 감지 및 제거
+                if not self._contains_english(line):
+                    # 불완전한 부분 제거
+                    line = line.replace("......", "").replace(".....", "").replace("...", "")
+                    cleaned_lines.append(line)
+                else:
+                    # 영어가 포함된 줄은 스킵하거나 경고
+                    logger.warning(f"Skipping English line: {line[:50]}")
+        
+        return '\n'.join(cleaned_lines)
+    
+    def _contains_english(self, text: str) -> bool:
+        """영어 포함 여부 확인 (포맷 용어 제외)"""
+        format_terms = ["INT", "EXT", "CUT", "FADE", "DISSOLVE"]
+        
+        # 포맷 용어 제거 후 확인
+        test_text = text
+        for term in format_terms:
+            test_text = test_text.replace(term, "")
+        
+        # 알파벳 연속 3개 이상이면 영어로 판단
+        import re
+        english_pattern = re.compile(r'[a-zA-Z]{3,}')
+        return bool(english_pattern.search(test_text))
+    
+    def _validate_and_clean_screenplay(self, content: str) -> str:
+        """시나리오 검증 및 정리"""
+        if not content:
+            return ""
+        
+        lines = content.split('\n')
+        cleaned = []
+        
+        for line in lines:
+            # 빈 줄은 유지
+            if not line.strip():
+                cleaned.append(line)
+                continue
+            
+            # 불완전한 부분 제거
+            if "..." in line and not line.strip().endswith('.'):
+                continue
+            
+            # 영어 체크 (포맷 제외)
+            if self._contains_english(line):
+                logger.warning(f"Removing English line: {line[:50]}")
+                continue
+            
+            cleaned.append(line)
+        
+        return '\n'.join(cleaned)
+    
+    @staticmethod
+    def get_session_data(session_id: str) -> Optional[Dict]:
+        """세션 데이터 조회"""
+        with ScreenplayDatabase.get_db() as conn:
+            row = conn.cursor().execute(
+                'SELECT * FROM screenplay_sessions WHERE session_id = ?',
+                (session_id,)
+            ).fetchone()
+            if row:
+                return dict(row)
+        return None
 
     def _create_act_prompt(self, role: str, act_name: str, current_content: str, 
                           planning_data: Dict, previous_acts: Dict, stage_type: str) -> str:
-        """막 작성 프롬프트 생성"""
+        """막 작성 프롬프트 생성 - 개선된 버전"""
+        
+        # 기획안에서 핵심 정보 추출
+        title = ""
+        genre = ""
+        screenplay_type = ""
+        logline = ""
+        synopsis = ""
+        characters = ""
+        
+        for key, value in planning_data.items():
+            if "프로듀서" in key and value:
+                # 제목과 로그라인 추출
+                if "제목" in value:
+                    title_match = re.search(r'제목[:\s]*([^\n]+)', value)
+                    if title_match:
+                        title = title_match.group(1).strip()
+                if "로그라인" in value:
+                    logline_match = re.search(r'로그라인[:\s]*([^\n]+)', value)
+                    if logline_match:
+                        logline = logline_match.group(1).strip()
+            elif "스토리" in key and value:
+                synopsis = value[:1000]
+            elif "캐릭터" in key and value:
+                characters = value[:1000]
+        
+        # 원본 요청 정보 강조
+        core_info = f"""
+【핵심 정보 - 절대 준수】
+원본 요청: {self.original_query}
+제목: {title}
+로그라인: {logline}
+장르: {genre if genre else '드라마'}
+형식: {screenplay_type if screenplay_type else '영화'}
+
+⚠️ 중요: 위 정보를 절대적으로 준수하세요. 다른 이야기로 바꾸지 마세요.
+⚠️ 중요: 모든 내용을 한국어로만 작성하세요. 영어 사용 금지.
+⚠️ 중요: 표준 시나리오 포맷을 정확히 준수하세요.
+"""
         
         if role == "스토리작가":
             if stage_type == "초고":
                 return f"""【{act_name} 초고 작성】
-원본 요청: {self.original_query}
+{core_info}
 
-기획안 요약:
-{self._summarize_planning(planning_data)}
+【기획안 내용】
+시놉시스:
+{synopsis}
 
-이전 막:
+캐릭터:
+{characters}
+
+【이전 막 내용】
 {self._summarize_previous_acts(previous_acts)}
 
-목표: 1000줄 이상의 {act_name} 초고를 작성하세요.
-표준 시나리오 포맷을 사용하세요."""
+【작성 요구사항】
+1. 반드시 한국어로만 작성
+2. 표준 시나리오 포맷:
+   INT. 장소 - 시간  (또는 EXT. 장소 - 시간)
+   
+   장면 설명은 현재형으로 작성.
+   
+   캐릭터명 (대문자)
+   대사는 자연스러운 한국어로.
+
+3. 분량: 최소 1000줄 이상
+4. 각 씬: 5-7페이지 분량
+5. 기획안 내용 100% 반영
+
+절대 영어를 사용하지 마세요.
+절대 다른 이야기로 바꾸지 마세요.
+절대 연극이나 다른 형식으로 작성하지 마세요.
+
+{act_name}을 완전한 시나리오 형식으로 작성하세요."""
+            
             else:  # 완성
                 return f"""【{act_name} 최종 완성】
+{core_info}
+
 이전 전문가들의 피드백을 반영하여 최종본을 작성하세요.
-목표: 1200줄 이상"""
+
+【필수 사항】
+1. 한국어로만 작성
+2. 영화 시나리오 포맷 준수
+3. 기획안 스토리 유지
+4. 1200줄 이상
+
+깨진 부분이나 ... 같은 미완성 부분 없이 완전하게 작성하세요."""
         
         elif role == "고증전문가":
             return f"""【{act_name} 사실 확인】
-다음 내용을 검토하고 사실 오류를 찾으세요:
+{core_info}
+
+다음 시나리오를 검토하세요:
 {current_content[:2000]}...
 
-역사적, 과학적, 문화적 정확성을 확인하세요."""
+【검토 사항】
+1. 사실 오류 확인
+2. 시대 고증
+3. 영어 사용 부분을 한국어로 수정
+4. 깨진 텍스트나 ... 부분 수정
+
+모든 수정 사항을 한국어로 제시하세요."""
+        
+        elif role == "편집자":
+            return f"""【{act_name} 편집】
+{core_info}
+
+【편집 지침】
+1. 영어가 있다면 모두 한국어로 변경
+2. 깨진 부분(...) 완성
+3. 기획안과 일치하지 않는 내용 수정
+4. 시나리오 포맷 교정
+
+편집된 버전을 완전한 한국어로 제시하세요."""
+        
+        elif role == "감독":
+            return f"""【{act_name} 연출 노트】
+{core_info}
+
+【연출 강화】
+1. 시각적 디테일 추가
+2. 카메라 앵글 제안
+3. 분위기 묘사 강화
+
+모든 연출 노트를 한국어로 작성하세요.
+영화 시나리오임을 명확히 하세요."""
+        
+        elif role == "대화전문가":
+            return f"""【{act_name} 대사 개선】
+{core_info}
+
+【대사 수정】
+1. 모든 대사를 자연스러운 한국어로
+2. 영어 대사가 있다면 한국어로 번역
+3. 캐릭터별 말투 차별화
+4. 어색한 번역투 제거
+
+완전한 한국어 대사로 수정하세요."""
         
-        # 다른 역할들...
-        return f"【{role} 작업】\n{act_name}을(를) 검토하고 개선하세요."
+        elif role == "비평가":
+            return f"""【{act_name} 검토】
+{core_info}
+
+【평가 항목】
+1. 기획안과의 일치도 (최우선)
+2. 한국어 사용 (영어 혼용 금지)
+3. 시나리오 포맷 준수
+4. 스토리 완성도
+
+문제점과 개선 사항을 구체적으로 제시하세요."""
+        
+        return f"""【{role} 작업】
+{core_info}
+
+{act_name}을(를) 검토하고 개선하세요.
+반드시 한국어로만 작성하고, 기획안 내용을 충실히 반영하세요."""
 
     def _summarize_planning(self, planning_data: Dict) -> str:
         """기획안 요약"""