feat: 주요 개선사항 적용 - 코드 재사용, 다운로드, 사용자 정의 화자명

app.py

@@ -67,12 +67,12 @@ def initialize_models():
         logger.error(f"모델 초기화 실패: {e}")
         return False, f"❌ 초기화 실패: {str(e)}"
 
-def process_audio_file(audio_file, progress=gr.Progress()):
+def process_audio_file(audio_file, speaker1_name, speaker2_name, progress=gr.Progress()):
     """업로드된 오디오 파일을 처리합니다."""
     global text_processor, whisper_model
     
     if audio_file is None:
-        return "❌ 오디오 파일을 업로드해주세요.", "", "", "", "", ""
+        return "❌ 오디오 파일을 업로드해주세요.", "", "", "", "", "", None
     
     try:
         # 모델 초기화 (필요한 경우)
@@ -80,7 +80,7 @@ def process_audio_file(audio_file, progress=gr.Progress()):
             progress(0.05, desc="모델 초기화 중...")
             success, message = initialize_models()
             if not success:
-                return message, "", "", "", "", ""
+                return message, "", "", "", "", "", None
         
         # 오디오 파일 경로 확인
         audio_path = audio_file.name if hasattr(audio_file, 'name') else str(audio_file)
@@ -94,7 +94,7 @@ def process_audio_file(audio_file, progress=gr.Progress()):
         full_text = result['text'].strip()
         
         if not full_text:
-            return "❌ 오디오에서 텍스트를 추출할 수 없습니다.", "", "", "", "", ""
+            return "❌ 오디오에서 텍스트를 추출할 수 없습니다.", "", "", "", "", "", None
         
         language = result.get('language', 'unknown')
         logger.info(f"음성 인식 완료. 언어: {language}, 텍스트 길이: {len(full_text)}")
@@ -111,10 +111,20 @@ def process_audio_file(audio_file, progress=gr.Progress()):
         
         # 3단계: 텍스트 처리 (화자 분리 + 맞춤법 교정)
         progress(0.4, desc="AI 화자 분리 및 맞춤법 교정 중...")
-        text_result = text_processor.process_text(full_text, progress_callback=progress_callback)
+        
+        # 사용자 정의 화자 이름 적용
+        custom_speaker1 = speaker1_name.strip() if speaker1_name and speaker1_name.strip() else None
+        custom_speaker2 = speaker2_name.strip() if speaker2_name and speaker2_name.strip() else None
+        
+        text_result = text_processor.process_text(
+            full_text, 
+            progress_callback=progress_callback,
+            speaker1_name=custom_speaker1,
+            speaker2_name=custom_speaker2
+        )
         
         if not text_result.get("success", False):
-            return f"❌ 텍스트 처리 실패: {text_result.get('error', 'Unknown error')}", full_text, "", "", "", ""
+            return f"❌ 텍스트 처리 실패: {text_result.get('error', 'Unknown error')}", full_text, "", "", "", "", None
         
         # 결과 추출
         progress(0.95, desc="결과 정리 중...")
@@ -124,8 +134,21 @@ def process_audio_file(audio_file, progress=gr.Progress()):
         
         # 화자별 대화 추출
         conversations = text_result["conversations_by_speaker_corrected"]
-        speaker1_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get("화자1", []))])
-        speaker2_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get("화자2", []))])
+        speaker1_key = custom_speaker1 or "화자1"
+        speaker2_key = custom_speaker2 or "화자2"
+        
+        speaker1_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get(speaker1_key, []))])
+        speaker2_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get(speaker2_key, []))])
+        
+        # 다운로드 파일 생성
+        download_file = None
+        try:
+            text_processor.save_results_to_files(text_result)
+            zip_path = text_processor.create_download_zip(text_result)
+            if zip_path and os.path.exists(zip_path):
+                download_file = zip_path
+        except Exception as e:
+            logger.warning(f"다운로드 파일 생성 실패: {e}")
         
         progress(1.0, desc="처리 완료!")
         
@@ -135,22 +158,22 @@ def process_audio_file(audio_file, progress=gr.Progress()):
 - 처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
 - 감지된 언어: {language}
 - 텍스트 길이: {len(full_text)}자
-- 화자1 발언 수: {len(conversations.get('화자1', []))}개
-- 화자2 발언 수: {len(conversations.get('화자2', []))}개
+- {speaker1_key} 발언 수: {len(conversations.get(speaker1_key, []))}개
+- {speaker2_key} 발언 수: {len(conversations.get(speaker2_key, []))}개
 """
         
-        return status_message, original_text, separated_text, corrected_text, speaker1_text, speaker2_text
+        return status_message, original_text, separated_text, corrected_text, speaker1_text, speaker2_text, download_file
         
     except Exception as e:
         logger.error(f"오디오 파일 처리 중 오류: {e}")
-        return f"❌ 처리 중 오류가 발생했습니다: {str(e)}", "", "", "", "", ""
+        return f"❌ 처리 중 오류가 발생했습니다: {str(e)}", "", "", "", "", "", None
 
-def process_text_input(input_text, progress=gr.Progress()):
+def process_text_input(input_text, speaker1_name, speaker2_name, progress=gr.Progress()):
     """입력된 텍스트를 처리합니다."""
     global text_processor
     
     if not input_text or not input_text.strip():
-        return "❌ 처리할 텍스트를 입력해주세요.", "", "", "", "", ""
+        return "❌ 처리할 텍스트를 입력해주세요.", "", "", "", "", "", None
     
     try:
         # 텍스트 프로세서만 초기화
@@ -158,14 +181,14 @@ def process_text_input(input_text, progress=gr.Progress()):
             progress(0.1, desc="텍스트 프로세서 초기화 중...")
             
             google_api_key = os.getenv("GOOGLE_API_KEY")
-            if not google_api_key:
-                return "❌ Google API 키가 설정되지 않았습니다.", "", "", "", "", ""
+            if not google_api_key or not isinstance(google_api_key, str) or len(google_api_key.strip()) == 0:
+                return "❌ Google API 키가 설정되지 않았습니다.", "", "", "", "", "", None
             
             TextProcessor, processor_error = safe_import_processor()
             if TextProcessor is None:
-                return f"❌ TextProcessor 로딩 실패: {processor_error}", "", "", "", "", ""
+                return f"❌ TextProcessor 로딩 실패: {processor_error}", "", "", "", "", "", None
                 
-            text_processor = TextProcessor(google_api_key)
+            text_processor = TextProcessor(google_api_key.strip())
         
         # 모델 로딩
         progress(0.2, desc="AI 모델 로딩 중...")
@@ -179,10 +202,20 @@ def process_text_input(input_text, progress=gr.Progress()):
         
         # 텍스트 처리
         progress(0.3, desc="텍스트 처리 시작...")
-        result = text_processor.process_text(input_text, progress_callback=progress_callback)
+        
+        # 사용자 정의 화자 이름 적용
+        custom_speaker1 = speaker1_name.strip() if speaker1_name and speaker1_name.strip() else None
+        custom_speaker2 = speaker2_name.strip() if speaker2_name and speaker2_name.strip() else None
+        
+        result = text_processor.process_text(
+            input_text, 
+            progress_callback=progress_callback,
+            speaker1_name=custom_speaker1,
+            speaker2_name=custom_speaker2
+        )
         
         if not result.get("success", False):
-            return f"❌ 처리 실패: {result.get('error', 'Unknown error')}", "", "", "", "", ""
+            return f"❌ 처리 실패: {result.get('error', 'Unknown error')}", "", "", "", "", "", None
         
         # 결과 추출
         progress(0.95, desc="결과 정리 중...")
@@ -192,8 +225,21 @@ def process_text_input(input_text, progress=gr.Progress()):
         
         # 화자별 대화 추출
         conversations = result["conversations_by_speaker_corrected"]
-        speaker1_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get("화자1", []))])
-        speaker2_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get("화자2", []))])
+        speaker1_key = custom_speaker1 or "화자1"
+        speaker2_key = custom_speaker2 or "화자2"
+        
+        speaker1_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get(speaker1_key, []))])
+        speaker2_text = "\n\n".join([f"{i+1}. {utterance}" for i, utterance in enumerate(conversations.get(speaker2_key, []))])
+        
+        # 다운로드 파일 생성
+        download_file = None
+        try:
+            text_processor.save_results_to_files(result)
+            zip_path = text_processor.create_download_zip(result)
+            if zip_path and os.path.exists(zip_path):
+                download_file = zip_path
+        except Exception as e:
+            logger.warning(f"다운로드 파일 생성 실패: {e}")
         
         progress(1.0, desc="처리 완료!")
         
@@ -201,15 +247,15 @@ def process_text_input(input_text, progress=gr.Progress()):
 ✅ **텍스트 처리 완료!**
 - 텍스트명: {result['text_name']}
 - 처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}
-- 화자1 발언 수: {len(conversations.get('화자1', []))}개
-- 화자2 발언 수: {len(conversations.get('화자2', []))}개
+- {speaker1_key} 발언 수: {len(conversations.get(speaker1_key, []))}개
+- {speaker2_key} 발언 수: {len(conversations.get(speaker2_key, []))}개
 """
         
-        return status_message, original_text, separated_text, corrected_text, speaker1_text, speaker2_text
+        return status_message, original_text, separated_text, corrected_text, speaker1_text, speaker2_text, download_file
         
     except Exception as e:
         logger.error(f"텍스트 처리 중 오류: {e}")
-        return f"❌ 처리 중 오류가 발생했습니다: {str(e)}", "", "", "", "", ""
+        return f"❌ 처리 중 오류가 발생했습니다: {str(e)}", "", "", "", "", "", None
 
 def create_interface():
     """Gradio 인터페이스를 생성합니다."""
@@ -229,6 +275,12 @@ def create_interface():
         color: #2c3e50;
         margin-bottom: 20px;
     }
+    .speaker-config {
+        background-color: #f8f9fa;
+        padding: 15px;
+        border-radius: 8px;
+        margin: 10px 0;
+    }
     """
     
     with gr.Blocks(css=css, title="2인 대화 STT 처리기") as interface:
@@ -243,6 +295,24 @@ def create_interface():
         
         with gr.Row():
             with gr.Column(scale=1):
+                # 화자 이름 설정
+                gr.HTML('<div class="speaker-config">')
+                gr.Markdown("### 👥 화자 이름 설정 (선택사항)")
+                with gr.Row():
+                    speaker1_name = gr.Textbox(
+                        label="화자1 이름",
+                        placeholder="예: 김팀장, 홍길동 등 (비워두면 '화자1')",
+                        value="",
+                        scale=1
+                    )
+                    speaker2_name = gr.Textbox(
+                        label="화자2 이름", 
+                        placeholder="예: 이대리, 김영희 등 (비워두면 '화자2')",
+                        value="",
+                        scale=1
+                    )
+                gr.HTML('</div>')
+                
                 # 입력 섹션
                 with gr.Tabs():
                     with gr.TabItem("🎤 오디오 업로드"):
@@ -273,9 +343,16 @@ def create_interface():
                 
                 # 상태 표시
                 status_output = gr.Markdown(
-                    "### 📊 처리 상태\n준비 완료. 오디오 파일을 업로드하거나 텍스트를 입력하고 처리 버튼을 클릭하세요.",
+                    "### 📊 처리 상태\n준비 완료. 화자 이름을 설정하고 오디오 파일을 업로드하거나 텍스트를 입력한 후 처리 버튼을 클릭하세요.",
                     elem_classes=["status-box"]
                 )
+                
+                # 다운로드 섹션
+                gr.Markdown("### 📥 결과 다운로드")
+                download_file = gr.File(
+                    label="처리 결과 ZIP 파일",
+                    visible=False
+                )
             
             with gr.Column(scale=2):
                 # 결과 표시 섹션
@@ -325,22 +402,32 @@ def create_interface():
         ### 📖 사용법
         
         **🎤 오디오 파일 처리:**
-        1. **오디오 업로드**: WAV, MP3, MP4 등의 오디오 파일을 업로드하세요
-        2. **처리 시작**: '🚀 오디오 처리 시작' 버튼을 클릭하세요
-        3. **결과 확인**: 음성 인식 → 화자 분리 → 맞춤법 교정 순으로 처리됩니다
+        1. **화자 이름 설정**: 원하는 화자 이름을 입력하세요 (예: 김팀장, 이대리)
+        2. **오디오 업로드**: WAV, MP3, MP4 등의 오디오 파일을 업로드하세요
+        3. **처리 시작**: '🚀 오디오 처리 시작' 버튼을 클릭하세요
+        4. **결과 확인**: 음성 인식 → 화자 분리 → 맞춤법 교정 순으로 처리됩니다
+        5. **다운로드**: 처리 완료 후 ZIP 파일로 모든 결과를 다운로드할 수 있습니다
         
         **📝 텍스트 직접 입력:**
-        1. **텍스트 입력**: 2인 대화 텍스트를 입력란에 붙여넣기하세요
-        2. **처리 시작**: '🚀 텍스트 처리 시작' 버튼을 클릭하세요
-        3. **결과 확인**: 각 탭에서 화자 분리 결과를 확인하세요
+        1. **화자 이름 설정**: 원하는 화자 이름을 입력하세요
+        2. **텍스트 입력**: 2인 대화 텍스트를 입력란에 붙여넣기하세요
+        3. **처리 시작**: '🚀 텍스트 처리 시작' 버튼을 클릭하세요
+        4. **결과 확인**: 각 탭에서 화자 분리 결과를 확인하세요
         
         ### ⚙️ 기술 정보
         - **음성 인식**: OpenAI Whisper (다국어 지원)
-        - **화자 분리**: Google Gemini 2.0 Flash
+        - **화자 분리**: Google Gemini 2.0 Flash + AI 응답 검증
         - **맞춤법 교정**: 고급 AI 기반 한국어 교정
+        - **청킹 처리**: 대용량 텍스트 자동 분할 처리
         - **지원 형식**: WAV, MP3, MP4, M4A 등
         - **최적 환경**: 2인 대화, 명확한 음질
         
+        ### 🆕 새로운 기능
+        - **사용자 정의 화자 이름**: '화자1', '화자2' 대신 실제 이름 사용
+        - **다운로드 기능**: 전체 결과를 ZIP 파일로 다운로드
+        - **AI 응답 검증**: 화자 분리 실패 시 자동 감지 및 오류 처리
+        - **대용량 파일 지원**: 긴 오디오도 청킹으로 안정적 처리
+        
         ### ⚠️ 주의사항
         - 처리 시간은 오디오 길이에 따라 달라집니다 (보통 1-5분)
         - Google AI API 사용량 제한이 있을 수 있습니다
@@ -349,28 +436,44 @@ def create_interface():
         - 배경 소음이 적고 화자 구분이 명확한 오디오를 권장합니다
         """)
         
-        # 이벤트 연결
+        # 이벤트 연결 - 다운로드 파일 포함
+        def update_download_visibility(download_path):
+            """다운로드 파일이 생성되면 표시합니다."""
+            if download_path and os.path.exists(download_path):
+                return gr.File(value=download_path, visible=True)
+            else:
+                return gr.File(visible=False)
+        
         outputs = [
             status_output,
             original_output,
             separated_output,
             corrected_output,
             speaker1_output,
-            speaker2_output
+            speaker2_output,
+            download_file
         ]
         
         # 오디오 처리 이벤트
         audio_process_btn.click(
             fn=process_audio_file,
-            inputs=[audio_input],
+            inputs=[audio_input, speaker1_name, speaker2_name],
             outputs=outputs
+        ).then(
+            fn=update_download_visibility,
+            inputs=[download_file],
+            outputs=[download_file]
         )
         
         # 텍스트 처리 이벤트
         text_process_btn.click(
             fn=process_text_input,
-            inputs=[text_input],
+            inputs=[text_input, speaker1_name, speaker2_name],
             outputs=outputs
+        ).then(
+            fn=update_download_visibility,
+            inputs=[download_file],
+            outputs=[download_file]
         )
     
     return interface

audio_summarizer.py

@@ -2,15 +2,12 @@ import tkinter as tk
 from tkinter import scrolledtext, messagebox, ttk
 import threading
 import os
-import torch
 import whisper
-import google.generativeai as genai
 from dotenv import load_dotenv
 import logging
-import json
-from datetime import datetime
 import glob
-import re
+from datetime import datetime
+from stt_processor import TextProcessor
 
 # 환경 변수 로드
 load_dotenv()
@@ -18,17 +15,10 @@ load_dotenv()
 # --- 설정: .env 파일에서 API 키를 읽어옵니다 ---
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
 
-# logs 폴더 생성
-if not os.path.exists("logs"):
-    os.makedirs("logs")
-
-# output 폴더 생성
-if not os.path.exists("output"):
-    os.makedirs("output")
-
-# data 폴더 생성
-if not os.path.exists("data"):
-    os.makedirs("data")
+# 폴더 생성
+for folder in ["logs", "output", "data"]:
+    if not os.path.exists(folder):
+        os.makedirs(folder)
 
 # 로깅 설정
 logging.basicConfig(
@@ -41,451 +31,254 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# -----------------------------------------
-
 class STTProcessorApp:
     def __init__(self, root):
         self.root = root
         self.root.title("2인 대화 STT 처리기 (AI 화자 분리)")
         self.root.geometry("1000x750")
-
-        # 모델 로딩 상태 변수
-        self.models_loaded = False
+        
+        # 모델 초기화
         self.whisper_model = None
-        self.gemini_model = None
-
-        # UI 요소 생성
-        self.main_frame = tk.Frame(root, padx=10, pady=10)
-        self.main_frame.pack(fill=tk.BOTH, expand=True)
-
-        # 제목
-        title_label = tk.Label(self.main_frame, text="2인 대화 STT 처리기 (AI 화자 분리)", font=("Arial", 16, "bold"))
-        title_label.pack(pady=5)
-
-        # 설명
-        desc_label = tk.Label(self.main_frame, text="Whisper STT + Gemini AI 화자 분리로 2명의 대화를 자동으로 구분합니다", font=("Arial", 10))
-        desc_label.pack(pady=2)
-
-        # WAV 파일 목록 프레임
-        files_frame = tk.LabelFrame(self.main_frame, text="data 폴더의 WAV 파일 목록", padx=5, pady=5)
-        files_frame.pack(fill=tk.BOTH, expand=True, pady=5)
-
-        # 파일 목록과 스크롤바
-        list_frame = tk.Frame(files_frame)
-        list_frame.pack(fill=tk.BOTH, expand=True)
-
-        scrollbar = tk.Scrollbar(list_frame)
-        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
-
-        self.file_listbox = tk.Listbox(list_frame, yscrollcommand=scrollbar.set, selectmode=tk.SINGLE)
-        self.file_listbox.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
-        scrollbar.config(command=self.file_listbox.yview)
-
-        # 버튼 프레임
-        button_frame = tk.Frame(self.main_frame)
-        button_frame.pack(fill=tk.X, pady=5)
-
-        self.refresh_button = tk.Button(button_frame, text="파일 목록 새로고침", command=self.refresh_file_list)
-        self.refresh_button.pack(side=tk.LEFT, padx=5)
-
-        self.process_button = tk.Button(button_frame, text="선택된 파일 처리", command=self.start_processing,
-                                        state=tk.DISABLED)
-        self.process_button.pack(side=tk.LEFT, padx=5)
-
-        self.process_all_button = tk.Button(button_frame, text="모든 파일 처리", command=self.start_processing_all,
-                                           state=tk.DISABLED)
-        self.process_all_button.pack(side=tk.LEFT, padx=5)
-
-        # 진행률 표시
-        progress_frame = tk.Frame(self.main_frame)
-        progress_frame.pack(fill=tk.X, pady=5)
-
-        tk.Label(progress_frame, text="진행률:").pack(side=tk.LEFT)
-        self.progress_var = tk.StringVar(value="대기 중")
-        tk.Label(progress_frame, textvariable=self.progress_var).pack(side=tk.LEFT, padx=10)
-
-        self.progress_bar = ttk.Progressbar(progress_frame, mode='determinate')
-        self.progress_bar.pack(side=tk.RIGHT, fill=tk.X, expand=True, padx=10)
-
-        # 상태 표시줄
-        self.status_label = tk.Label(self.main_frame, text="준비 완료. Google API 키를 설정하고 '처리' 버튼을 누르세요.", bd=1,
-                                     relief=tk.SUNKEN, anchor=tk.W)
-        self.status_label.pack(side=tk.BOTTOM, fill=tk.X)
-
-        # 결과 출력 영역
-        result_frame = tk.LabelFrame(self.main_frame, text="처리 결과", padx=5, pady=5)
-        result_frame.pack(fill=tk.BOTH, expand=True, pady=5)
-
-        self.result_text = scrolledtext.ScrolledText(result_frame, wrap=tk.WORD, state=tk.DISABLED, height=15)
-        self.result_text.pack(fill=tk.BOTH, expand=True)
-
-        # 초기 파일 목록 로드
-        self.refresh_file_list()
-
-    def refresh_file_list(self):
-        """data 폴더의 WAV 파일 목록을 새로고침합니다."""
-        self.file_listbox.delete(0, tk.END)
+        self.text_processor = None
         
-        wav_files = glob.glob("data/*.wav")
-        if wav_files:
-            for file_path in wav_files:
-                filename = os.path.basename(file_path)
-                self.file_listbox.insert(tk.END, filename)
-            self.process_button.config(state=tk.NORMAL)
-            self.process_all_button.config(state=tk.NORMAL)
-            logger.info(f"{len(wav_files)}개의 WAV 파일을 발견했습니다.")
-        else:
-            self.file_listbox.insert(tk.END, "WAV 파일이 없습니다. data 폴더에 WAV 파일을 넣어주세요.")
-            self.process_button.config(state=tk.DISABLED)
-            self.process_all_button.config(state=tk.DISABLED)
-            logger.warning("data 폴더에 WAV 파일이 없습니다.")
+        # UI 구성 요소
+        self.setup_ui()
+        
+        # 상태 추적
+        self.is_processing = False
+        
+        logger.info("STT 처리기 앱이 시작되었습니다.")
 
-    def update_status(self, message):
-        """UI의 상태 메시지를 업데이트합니다."""
-        self.status_label.config(text=message)
-        self.root.update_idletasks()
+    def setup_ui(self):
+        """UI 컴포넌트를 설정합니다."""
+        # 상단 프레임 - 상태 정보
+        status_frame = ttk.Frame(self.root)
+        status_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        ttk.Label(status_frame, text="상태:").pack(side=tk.LEFT)
+        self.status_label = ttk.Label(status_frame, text="준비", foreground="green")
+        self.status_label.pack(side=tk.LEFT, padx=(5, 0))
+        
+        # 중앙 프레임 - 로그 출력
+        log_frame = ttk.LabelFrame(self.root, text="처리 로그")
+        log_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=5)
+        
+        self.log_text = scrolledtext.ScrolledText(log_frame, height=25, wrap=tk.WORD)
+        self.log_text.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)
+        
+        # 하단 프레임 - 컨트롤
+        control_frame = ttk.Frame(self.root)
+        control_frame.pack(fill=tk.X, padx=10, pady=5)
+        
+        # 왼쪽: 모델 로딩 버튼
+        self.load_models_btn = ttk.Button(
+            control_frame, 
+            text="모델 로딩", 
+            command=self.load_models_threaded
+        )
+        self.load_models_btn.pack(side=tk.LEFT, padx=(0, 10))
+        
+        # 중앙: 처리 버튼
+        self.process_btn = ttk.Button(
+            control_frame, 
+            text="오디오 파일 처리 시작", 
+            command=self.process_files_threaded,
+            state=tk.DISABLED
+        )
+        self.process_btn.pack(side=tk.LEFT, padx=(0, 10))
+        
+        # 오른쪽: 종료 버튼
+        ttk.Button(
+            control_frame, 
+            text="종료", 
+            command=self.root.quit
+        ).pack(side=tk.RIGHT)
+        
+        # 진행률 표시
+        self.progress = ttk.Progressbar(
+            control_frame, 
+            mode='indeterminate'
+        )
+        self.progress.pack(side=tk.LEFT, fill=tk.X, expand=True, padx=(0, 10))
+
+    def log(self, message):
+        """로그 메시지를 UI에 출력합니다."""
+        def append_log():
+            timestamp = datetime.now().strftime("%H:%M:%S")
+            self.log_text.insert(tk.END, f"[{timestamp}] {message}\n")
+            self.log_text.see(tk.END)
+            
+        self.root.after(0, append_log)
+        logger.info(message)
 
-    def update_progress(self, current, total, message=""):
-        """진행률을 업데이트합니다."""
-        if total > 0:
-            progress = (current / total) * 100
-            self.progress_bar.config(value=progress)
-            if message:
-                self.progress_var.set(f"{message} ({current}/{total})")
-            else:
-                self.progress_var.set(f"{current}/{total}")
-        self.root.update_idletasks()
+    def update_status(self, status, color="black"):
+        """상태 라벨을 업데이트합니다."""
+        def update():
+            self.status_label.config(text=status, foreground=color)
+        self.root.after(0, update)
 
-    def show_result(self, content):
-        """결과 텍스트 영역에 내용을 표시합니다."""
-        self.result_text.config(state=tk.NORMAL)
-        self.result_text.insert(tk.END, content + "\n\n")
-        self.result_text.see(tk.END)
-        self.result_text.config(state=tk.DISABLED)
+    def load_models_threaded(self):
+        """별도 스레드에서 모델을 로딩합니다."""
+        threading.Thread(target=self.load_models, daemon=True).start()
 
     def load_models(self):
-        """필요한 AI 모델들을 로드합니다."""
+        """AI 모델들을 로딩합니다."""
         try:
+            self.update_status("모델 로딩 중...", "orange")
+            self.log("AI 모델 로딩을 시작합니다...")
+            
+            # API 키 검증
             if not GOOGLE_API_KEY or GOOGLE_API_KEY == "your_google_api_key_here":
-                messagebox.showerror("API 키 오류", ".env 파일에 올바른 Google AI API 키를 입력해주세요.")
-                logger.error("Google API 키가 설���되지 않았습니다.")
-                return False
-
-            logger.info("모델 로딩을 시작합니다.")
-            self.update_status("모델 로딩 중... (최초 실행 시 시간이 걸릴 수 있습니다)")
-
+                raise ValueError("Google API 키가 설정되지 않았습니다. .env 파일을 확인하세요.")
+            
             # Whisper 모델 로딩
-            self.update_status("음성 인식 모델(Whisper) 로딩 중...")
-            logger.info("Whisper 모델 로딩을 시작합니다.")
-            self.whisper_model = whisper.load_model("base")  # "small", "medium", "large" 등으로 변경 가능
-            logger.info("Whisper 모델 로딩이 완료되었습니다.")
-
-            # Gemini 모델 설정
-            self.update_status("AI 화자 분리 모델(Gemini) 설정 중...")
-            logger.info("Gemini 모델 설정을 시작합니다.")
-            genai.configure(api_key=GOOGLE_API_KEY)
-            # gemini-2.0-flash: 최신 Gemini 2.0 모델, 빠르고 정확한 처리
-            self.gemini_model = genai.GenerativeModel('gemini-2.0-flash')
-            logger.info("Gemini 2.0 Flash 모델 설정이 완료되었습니다.")
-
-            self.models_loaded = True
-            self.update_status("모든 모델 로딩 완료. 처리 준비 완료.")
-            logger.info("모든 모델 로딩이 완료되었습니다.")
-            return True
-        except Exception as e:
-            error_msg = f"모델을 로딩하는 중 오류가 발생했습니다: {e}"
-            messagebox.showerror("모델 로딩 오류", error_msg)
-            logger.error(error_msg)
-            self.update_status("오류: 모델 로딩 실패")
-            return False
-
-    def start_processing(self):
-        """선택된 파일 처리 시작."""
-        selection = self.file_listbox.curselection()
-        if not selection:
-            messagebox.showwarning("파일 미선택", "처리할 파일을 선택해주세요.")
-            return
-        
-        filename = self.file_listbox.get(selection[0])
-        if filename == "WAV 파일이 없습니다. data 폴더에 WAV 파일을 넣어주세요.":
-            return
+            self.log("Whisper 모델을 로딩합니다...")
+            self.whisper_model = whisper.load_model("base")
+            self.log("Whisper 모델 로딩 완료!")
             
-        self.process_files([filename])
-
-    def start_processing_all(self):
-        """모든 파일 처리 시작."""
-        wav_files = glob.glob("data/*.wav")
-        if not wav_files:
-            messagebox.showwarning("파일 없음", "data 폴더에 처리할 WAV 파일이 없습니다.")
+            # TextProcessor 초기화
+            self.log("Gemini 텍스트 프로세서를 초기화합니다...")
+            self.text_processor = TextProcessor(GOOGLE_API_KEY)
+            self.text_processor.load_models()
+            self.log("모든 모델이 성공적으로 로딩되었습니다!")
+            
+            self.update_status("준비 완료", "green")
+            
+            # 처리 버튼 활성화
+            def enable_button():
+                self.process_btn.config(state=tk.NORMAL)
+            self.root.after(0, enable_button)
+            
+        except Exception as e:
+            error_msg = f"모델 로딩 실패: {str(e)}"
+            self.log(error_msg)
+            self.update_status("모델 로딩 실패", "red")
+            messagebox.showerror("오류", error_msg)
+
+    def process_files_threaded(self):
+        """별도 스레드에서 파일을 처리합니다."""
+        if self.is_processing:
+            messagebox.showwarning("경고", "이미 처리 중입니다.")
             return
             
-        filenames = [os.path.basename(f) for f in wav_files]
-        self.process_files(filenames)
-
-    def process_files(self, filenames):
-        """파일 처리 시작."""
-        # 모델이 로드되지 않았으면 먼저 로드
-        if not self.models_loaded:
-            if not self.load_models():
-                return  # 모델 로딩 실패 시 중단
-
-        # UI 비활성화 및 처리 스레드 시작
-        self.refresh_button.config(state=tk.DISABLED)
-        self.process_button.config(state=tk.DISABLED)
-        self.process_all_button.config(state=tk.DISABLED)
+        threading.Thread(target=self.process_files, daemon=True).start()
 
-        processing_thread = threading.Thread(target=self.process_audio_files, args=(filenames,))
-        processing_thread.start()
-
-    def process_audio_files(self, filenames):
-        """백그라운드에서 여러 오디오 파일을 처리하는 메인 로직."""
+    def process_files(self):
+        """data 폴더의 모든 WAV 파일을 처리합니다."""
         try:
-            total_files = len(filenames)
-            logger.info(f"{total_files}개의 파일 처리를 시작합니다.")
+            self.is_processing = True
+            self.update_status("처리 중...", "orange")
+            
+            # 진행률 표시 시작
+            def start_progress():
+                self.progress.start(10)
+            self.root.after(0, start_progress)
+            
+            # WAV 파일 찾기
+            wav_files = glob.glob("data/*.wav")
+            if not wav_files:
+                self.log("data 폴더에 WAV 파일이 없습니다.")
+                return
+            
+            self.log(f"{len(wav_files)}개의 WAV 파일을 발견했습니다.")
             
-            for idx, filename in enumerate(filenames):
-                file_path = os.path.join("data", filename)
-                self.update_progress(idx, total_files, f"처리 중: {filename}")
+            # 각 파일 처리
+            for i, wav_file in enumerate(wav_files):
+                self.log(f"\n=== 파일 처리 ({i+1}/{len(wav_files)}) ===")
+                success = self.process_single_audio_file(wav_file)
                 
-                result = self.process_single_audio_file(file_path, filename)
-                if result:
-                    self.show_result(f"✅ {filename} 처리 완료")
+                if success:
+                    self.log(f"✅ {os.path.basename(wav_file)} 처리 완료")
                 else:
-                    self.show_result(f"❌ {filename} 처리 실패")
+                    self.log(f"❌ {os.path.basename(wav_file)} 처리 실패")
+            
+            self.log(f"\n모든 파일 처리 완료! 총 {len(wav_files)}개 파일")
+            self.update_status("처리 완료", "green")
             
-            self.update_progress(total_files, total_files, "완료")
-            self.update_status("모든 파일 처리 완료!")
-            logger.info("모든 파일 처리가 완료되었습니다.")
-
         except Exception as e:
-            error_msg = f"파일 처리 중 오류가 발생했습니다: {e}"
-            logger.error(error_msg)
-            self.update_status(f"오류: {e}")
+            error_msg = f"파일 처리 중 오류: {str(e)}"
+            self.log(error_msg)
+            self.update_status("처리 실패", "red")
+            
         finally:
-            # UI 다시 활성화
-            self.refresh_button.config(state=tk.NORMAL)
-            self.process_button.config(state=tk.NORMAL)
-            self.process_all_button.config(state=tk.NORMAL)
+            self.is_processing = False
+            # 진행률 표시 중지
+            def stop_progress():
+                self.progress.stop()
+            self.root.after(0, stop_progress)
 
-    def process_single_audio_file(self, file_path, filename):
+    def process_single_audio_file(self, file_path):
         """단일 오디오 파일을 처리합니다."""
         try:
-            logger.info(f"파일 처리 시작: {file_path}")
+            filename = os.path.basename(file_path)
             base_name = os.path.splitext(filename)[0]
             
-            # 1단계: Whisper로 음성 인식
-            self.update_status(f"1/4: 음성 인식 진행 중: {filename}")
-            logger.info(f"음성 인식 시작: {filename}")
+            self.log(f"파일 처리 시작: {filename}")
             
+            # 1단계: Whisper로 음성 인식
+            self.log("1/3: 음성 인식 진행 중...")
             result = self.whisper_model.transcribe(file_path)
             full_text = result['text'].strip()
             
             if not full_text:
-                logger.warning(f"파일 {filename}에서 텍스트를 추출할 수 없습니다.")
+                self.log(f"❌ 파일 {filename}에서 텍스트를 추출할 수 없습니다.")
                 return False
             
-            # 2단계: Gemini로 화자 분리
-            self.update_status(f"2/4: AI 화자 분리 진행 중: {filename}")
-            logger.info(f"AI 화자 분리 시작: {filename}")
+            language = result.get('language', 'unknown')
+            self.log(f"음성 인식 완료 (언어: {language}, 길이: {len(full_text)}자)")
             
-            speaker_separated_text = self.separate_speakers_with_gemini(full_text)
+            # 2단계: TextProcessor로 화자 분리 및 맞춤법 교정
+            self.log("2/3: AI 화자 분리 및 맞춤법 교정 진행 중...")
             
-            # 3단계: 맞춤법 교정
-            self.update_status(f"3/4: 맞춤법 교정 진행 중: {filename}")
-            logger.info(f"맞춤법 교정 시작: {filename}")
+            def progress_callback(status, current, total):
+                self.log(f"  → {status} ({current}/{total})")
             
-            corrected_text = self.correct_spelling_with_gemini(speaker_separated_text)
+            text_result = self.text_processor.process_text(
+                full_text, 
+                text_name=base_name,
+                progress_callback=progress_callback
+            )
             
-            # 4단계: 결과 저장
-            self.update_status(f"4/4: 결과 저장 중: {filename}")
-            self.save_separated_conversations(base_name, full_text, speaker_separated_text, corrected_text, result)
+            if not text_result.get("success", False):
+                self.log(f"❌ 텍스트 처리 실패: {text_result.get('error', 'Unknown error')}")
+                return False
             
-            logger.info(f"파일 처리 완료: {filename}")
-            return True
-
-        except Exception as e:
-            logger.error(f"파일 {filename} 처리 중 오류: {e}")
-            return False
-
-    def separate_speakers_with_gemini(self, text):
-        """Gemini API를 사용하여 텍스트를 화자별로 분리합니다."""
-        try:
-            prompt = f"""
-당신은 2명의 화자가 나누는 대화를 분석하는 전문가입니다. 
-주어진 텍스트를 분석하여 각 발언을 화자별로 구분해주세요.
-
-분석 지침:
-1. 대화의 맥락과 내용을 기반으로 화자를 구분하세요
-2. 말투, 주제 전환, 질문과 답변의 패턴을 활용하세요
-3. 화자1과 화자2로 구분하여 표시하세요
-4. 각 발언 앞에 [화자1] 또는 [화자2]를 붙여주세요
-5. 발언이 너무 길 경우 자연스러운 지점에서 나누어주세요
-
-출력 형식:
-[화자1] 첫 번째 발언 내용
-[화자2] 두 번째 발언 내용
-[화자1] 세 번째 발언 내용
-...
-
-분석할 텍스트:
-{text}
-"""
-
-            response = self.gemini_model.generate_content(prompt)
-            separated_text = response.text.strip()
+            # 3단계: 결과 저장
+            self.log("3/3: 결과 저장 중...")
             
-            logger.info("Gemini를 통한 화자 분리가 완료되었습니다.")
-            return separated_text
+            # 기존 결과에 Whisper 정보 추가
+            enhanced_result = text_result.copy()
+            enhanced_result.update({
+                "base_name": base_name,
+                "language": language,
+                "whisper_segments": result.get("segments", [])
+            })
             
-        except Exception as e:
-            logger.error(f"Gemini 화자 분리 중 오류: {e}")
-            return f"[오류] 화자 분리 실패: {str(e)}"
-
-    def correct_spelling_with_gemini(self, separated_text):
-        """Gemini API를 사용하여 화자별 분리된 텍스트의 맞춤법을 교정합니다."""
-        try:
-            prompt = f"""
-당신은 한국어 맞춤법 교정 전문가입니다. 
-주어진 텍스트에서 맞춤법 오류, 띄어쓰기 오류, 오타를 수정해주세요.
-
-교정 지침:
-1. 자연스러운 한국어 표현으로 수정하되, 원본의 의미와 말투는 유지하세요
-2. [화자1], [화자2] 태그는 그대로 유지하세요
-3. 전문 용어나 고유명사는 가능한 정확하게 수정하세요
-4. 구어체 특성은 유지하되, 명백한 오타만 수정하세요
-5. 문맥에 맞는 올바른 단어로 교체하세요
-
-수정이 필요한 예시:
-- "치특기" → "치트키"
-- "실점픽" → "실전 픽"  
-- "복사부천억" → "복사 붙여넣기"
-- "핵심같이가" → "핵심 가치가"
-- "재활" → "재활용"
-- "저정할" → "저장할"
-- "플레일" → "플레어"
-- "서벌 수" → "서버리스"
-- "커리" → "쿼리"
-- "전력" → "전략"
-- "클라클라" → "클라크"
-- "가인만" → "가입만"
-- "M5U" → "MAU"
-- "나온 로도" → "다운로드"
-- "무시무치" → "무시무시"
-- "송신유금" → "송신 요금"
-- "10지가" → "10GB"
-- "유금" → "요금"
-- "전 색을" → "전 세계"
-- "도무원은" → "도구들은"
-- "골차품데" → "골치 아픈데"
-- "변원해" → "변환해"
-- "f 운영" → "서비스 운영"
-- "오류추저개" → "오류 추적기"
-- "f 늘려질" → "서비스가 늘어날"
-- "캐시칭" → "캐싱"
-- "플레이어" → "플레어"
-- "업스테시" → "업스태시"
-- "원시근을" → "웬지슨"
-- "부각이릉도" → "부각들도"
-- "컴포넌트" → "컴포넌트"
-- "본이터링" → "모니터링"
-- "번뜨기는" → "번뜩이는"
-- "사용적 경험" → "사용자 경험"
-
-교정할 텍스트:
-{separated_text}
-"""
-
-            response = self.gemini_model.generate_content(prompt)
-            corrected_text = response.text.strip()
+            # 파일 저장
+            saved = self.text_processor.save_results_to_files(enhanced_result)
+            if saved:
+                self.log("결과 파일 저장 완료!")
+            else:
+                self.log("⚠️ 결과 파일 저장 중 일부 오류 발생")
             
-            logger.info("Gemini를 통한 맞춤법 교정이 완료되었습니다.")
-            return corrected_text
+            return True
             
         except Exception as e:
-            logger.error(f"Gemini 맞춤법 교정 중 오류: {e}")
-            return separated_text  # 오류 발생 시 원본 반환
-
-    def parse_separated_text(self, separated_text):
-        """화자별로 분리된 텍스트를 파싱하여 구조화합니다."""
-        conversations = {
-            "화자1": [],
-            "화자2": []
-        }
-        
-        # 정규표현식으로 화자별 발언 추출
-        pattern = r'\[화자([12])\]\s*(.+?)(?=\[화자[12]\]|$)'
-        matches = re.findall(pattern, separated_text, re.DOTALL)
-        
-        for speaker_num, content in matches:
-            speaker = f"화자{speaker_num}"
-            content = content.strip()
-            if content:
-                conversations[speaker].append(content)
-        
-        return conversations
-
-    def save_separated_conversations(self, base_name, original_text, separated_text, corrected_text, whisper_result):
-        """화자별로 분리되고 맞춤법이 교정된 대화 내용을 파일로 저장합니다."""
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        
-        # 교정된 텍스트에서 화자별 대화 파싱
-        corrected_conversations = self.parse_separated_text(corrected_text)
-        
-        # 원본 화자별 대화 파싱 (비교용)
-        original_conversations = self.parse_separated_text(separated_text)
-        
-        # 1. 전체 대화 저장 (원본, 화자 분리, 맞춤법 교정 포함)
-        all_txt_path = f"output/{base_name}_전체대화_{timestamp}.txt"
-        with open(all_txt_path, 'w', encoding='utf-8') as f:
-            f.write(f"파일명: {base_name}\n")
-            f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-            f.write(f"언어: {whisper_result.get('language', 'unknown')}\n")
-            f.write("="*50 + "\n\n")
-            f.write("원본 텍스트:\n")
-            f.write(original_text + "\n\n")
-            f.write("="*50 + "\n\n")
-            f.write("화자별 분리 결과 (원본):\n")
-            f.write(separated_text + "\n\n")
-            f.write("="*50 + "\n\n")
-            f.write("화자별 분리 결과 (맞춤법 교정):\n")
-            f.write(corrected_text + "\n")
-        
-        # 2. 교정된 화자별 개별 파일 저장
-        for speaker, utterances in corrected_conversations.items():
-            if utterances:
-                speaker_txt_path = f"output/{base_name}_{speaker}_교정본_{timestamp}.txt"
-                with open(speaker_txt_path, 'w', encoding='utf-8') as f:
-                    f.write(f"파일명: {base_name}\n")
-                    f.write(f"화자: {speaker}\n")
-                    f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-                    f.write(f"발언 수: {len(utterances)}\n")
-                    f.write("="*50 + "\n\n")
-                    
-                    for idx, utterance in enumerate(utterances, 1):
-                        f.write(f"{idx}. {utterance}\n\n")
-        
-        # 3. JSON 형태로도 저장 (분석용)
-        json_path = f"output/{base_name}_data_{timestamp}.json"
-        json_data = {
-            "filename": base_name,
-            "processed_time": datetime.now().isoformat(),
-            "language": whisper_result.get("language", "unknown"),
-            "original_text": original_text,
-            "separated_text": separated_text,
-            "corrected_text": corrected_text,
-            "conversations_by_speaker_original": original_conversations,
-            "conversations_by_speaker_corrected": corrected_conversations,
-            "segments": whisper_result.get("segments", [])
-        }
-        
-        with open(json_path, 'w', encoding='utf-8') as f:
-            json.dump(json_data, f, ensure_ascii=False, indent=2)
-        
-        logger.info(f"결과 저장 완료: {all_txt_path}, {json_path}")
-        logger.info(f"교정된 화자별 파일도 저장되었습니다.")
-
+            self.log(f"❌ 파일 {filename} 처리 중 오류: {str(e)}")
+            return False
 
-if __name__ == "__main__":
+def main():
+    """메인 함수"""
     root = tk.Tk()
     app = STTProcessorApp(root)
-    root.mainloop()
+    
+    try:
+        root.mainloop()
+    except KeyboardInterrupt:
+        logger.info("사용자에 의해 프로그램이 종료되었습니다.")
+    except Exception as e:
+        logger.error(f"예상치 못한 오류: {e}")
+        messagebox.showerror("오류", f"예상치 못한 오류가 발생했습니다: {str(e)}")
+
+if __name__ == "__main__":
+    main()

config.json

@@ -0,0 +1,35 @@
+{
+  "models": {
+    "whisper": {
+      "name": "base",
+      "options": {
+        "language": null,
+        "task": "transcribe"
+      }
+    },
+    "gemini": {
+      "name": "gemini-2.0-flash",
+      "temperature": 0.3,
+      "max_tokens": null
+    }
+  },
+  "prompts": {
+    "speaker_separation": "당신은 2명의 화자가 나누는 대화를 분석하는 전문가입니다. \n주어진 텍스트를 분석하여 각 발언을 화자별로 구분해주세요.\n\n분석 지침:\n1. 대화의 맥락과 내용을 기반으로 화자를 구분하세요\n2. 말투, 주제 전환, 질문과 답변의 패턴을 활용하세요\n3. 화자1과 화자2로 구분하여 표시하세요\n4. 각 발언 앞에 [화자1] 또는 [화자2]를 붙여주세요\n5. 발언이 너무 길 경우 자연스러운 지점에서 나누어주세요\n\n출력 형식:\n[화자1] 첫 번째 발언 내용\n[화자2] 두 번째 발언 내용\n[화자1] 세 번째 발언 내용\n...\n\n분석할 텍스트:\n{text}",
+    
+    "spell_correction": "당신은 한국어 맞춤법 교정 전문가입니다. \n주어진 텍스트에서 맞춤법 오류, 띄어쓰기 오류, 오타를 수정해주세요.\n\n교정 지침:\n1. 자연스러운 한국어 표현으로 수정하되, 원본의 의미와 말투는 유지하세요\n2. [화자1], [화자2] 태그는 그대로 유지하세요\n3. 전문 용어나 고유명사는 가능한 정확하게 수정하세요\n4. 구어체 특성은 유지하되, 명백한 오타만 수정하세요\n5. 문맥에 맞는 올바른 단어로 교체하세요\n\n수정이 필요한 예시:\n- \"치특기\" → \"치트키\"\n- \"실점픽\" → \"실전 픽\"\n- \"복사부천억\" → \"복사 붙여넣기\"\n- \"핵심같이가\" → \"핵심 가치가\"\n- \"재활\" → \"재활용\"\n- \"저정할\" → \"저장할\"\n- \"플레일\" → \"플레어\"\n- \"서벌 수\" → \"서버리스\"\n- \"커리\" → \"쿼리\"\n- \"전력\" → \"전략\"\n- \"클라클라\" → \"클라크\"\n- \"가인만\" → \"가입만\"\n- \"M5U\" → \"MAU\"\n- \"나온 로도\" → \"다운로드\"\n- \"무시무치\" → \"무시무시\"\n- \"송신유금\" → \"송신 요금\"\n- \"10지가\" → \"10GB\"\n- \"유금\" → \"요금\"\n- \"전 색을\" → \"전 세계\"\n- \"도무원은\" → \"도구들은\"\n- \"골차품데\" → \"골치 아픈데\"\n- \"변원해\" → \"변환해\"\n- \"f 운영\" → \"서비스 운영\"\n- \"오류추저개\" → \"오류 추적기\"\n- \"f 늘려질\" → \"서비스가 늘어날\"\n- \"캐시칭\" → \"캐싱\"\n- \"플레이어\" → \"플레어\"\n- \"업스테시\" → \"업스태시\"\n- \"원시근을\" → \"웬지슨\"\n- \"부각이릉도\" → \"부각들도\"\n- \"컴포넌트\" → \"컴포넌트\"\n- \"본이터링\" → \"모니터링\"\n- \"번뜨기는\" → \"번뜩이는\"\n- \"사용적 경험\" → \"사용자 경험\"\n\n교정할 텍스트:\n{text}"
+  },
+  "processing": {
+    "chunk_size": 20000,
+    "enable_chunking": true,
+    "validate_ai_response": true,
+    "required_speaker_tags": ["[화자1]", "[화자2]"]
+  },
+  "output": {
+    "save_original": true,
+    "save_separated": true,
+    "save_corrected": true,
+    "save_individual_speakers": true,
+    "save_json": true,
+    "create_download_zip": true
+  }
+}

stt_processor.py

@@ -5,6 +5,8 @@ import logging
 import json
 from datetime import datetime
 import re
+import tempfile
+import zipfile
 
 # 환경 변수 로드
 load_dotenv()
@@ -17,12 +19,13 @@ class TextProcessor:
     텍스트를 AI를 통한 화자 분리 및 맞춤법 교정을 수행하는 클래스
     """
     
-    def __init__(self, google_api_key=None):
+    def __init__(self, google_api_key=None, config_path="config.json"):
         """
         TextProcessor 초기화
         
         Args:
             google_api_key (str): Google AI API 키. None인 경우 환경 변수에서 읽음
+            config_path (str): 설정 파일 경로
         """
         # API 키 안전하게 가져오기
         if google_api_key:
@@ -33,6 +36,9 @@ class TextProcessor:
         self.gemini_model = None
         self.models_loaded = False
         
+        # 설정 파일 로드
+        self.config = self.load_config(config_path)
+        
         # API 키 검증 - 더 안전한 체크
         if (self.google_api_key is None or 
             not isinstance(self.google_api_key, str) or 
@@ -40,15 +46,55 @@ class TextProcessor:
             self.google_api_key.strip() == "your_google_api_key_here"):
             raise ValueError("Google AI API 키가 설정되지 않았습니다. 환경 변수 GOOGLE_API_KEY를 설정하거나 매개변수로 전달하세요.")
     
+    def load_config(self, config_path):
+        """설정 파일을 로드합니다."""
+        try:
+            if os.path.exists(config_path):
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                logger.info(f"설정 파일 로드 완료: {config_path}")
+                return config
+            else:
+                logger.warning(f"설정 파일을 찾을 수 없습니다: {config_path}. 기본 설정을 사용합니다.")
+                return self.get_default_config()
+        except Exception as e:
+            logger.error(f"설정 파일 로드 실패: {e}. 기본 설정을 사용합니다.")
+            return self.get_default_config()
+    
+    def get_default_config(self):
+        """기본 설정을 반환합니다."""
+        return {
+            "models": {
+                "gemini": {"name": "gemini-2.0-flash", "temperature": 0.3}
+            },
+            "processing": {
+                "chunk_size": 20000,
+                "enable_chunking": True,
+                "validate_ai_response": True,
+                "required_speaker_tags": ["[화자1]", "[화자2]"]
+            },
+            "output": {
+                "save_original": True,
+                "save_separated": True,
+                "save_corrected": True,
+                "save_individual_speakers": True,
+                "save_json": True,
+                "create_download_zip": True
+            }
+        }
+    
     def load_models(self):
         """Gemini AI 모델을 로드합니다."""
         try:
             logger.info("Gemini 모델 로딩을 시작합니다.")
             
+            # 설정에서 모델 이름 가져오기
+            model_name = self.config.get("models", {}).get("gemini", {}).get("name", "gemini-2.0-flash")
+            
             # Gemini 모델 설정
             genai.configure(api_key=self.google_api_key)
-            self.gemini_model = genai.GenerativeModel('gemini-2.0-flash')
-            logger.info("Gemini 2.0 Flash 모델 설정이 완료되었습니다.")
+            self.gemini_model = genai.GenerativeModel(model_name)
+            logger.info(f"{model_name} 모델 설정이 완료되었습니다.")
             
             self.models_loaded = True
             logger.info("Gemini 모델 로딩이 완료되었습니다.")
@@ -59,7 +105,74 @@ class TextProcessor:
             logger.error(error_msg)
             raise Exception(error_msg)
     
-    def process_text(self, input_text, text_name=None, progress_callback=None):
+    def split_text_into_chunks(self, text, chunk_size=None):
+        """텍스트를 청크로 분할합니다."""
+        if chunk_size is None:
+            chunk_size = self.config.get("processing", {}).get("chunk_size", 20000)
+        
+        if len(text) <= chunk_size:
+            return [text]
+        
+        chunks = []
+        sentences = re.split(r'[.!?。！？]\s+', text)
+        current_chunk = ""
+        
+        for sentence in sentences:
+            if len(current_chunk) + len(sentence) <= chunk_size:
+                current_chunk += sentence + ". "
+            else:
+                if current_chunk:
+                    chunks.append(current_chunk.strip())
+                current_chunk = sentence + ". "
+        
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+        
+        logger.info(f"텍스트를 {len(chunks)}개 청크로 분할했습니다.")
+        return chunks
+    
+    def validate_ai_response(self, response_text, expected_tags=None):
+        """AI 응답의 유효성을 검증합니다."""
+        if not self.config.get("processing", {}).get("validate_ai_response", True):
+            return True, "검증 비활성화됨"
+        
+        if expected_tags is None:
+            expected_tags = self.config.get("processing", {}).get("required_speaker_tags", ["[화자1]", "[화자2]"])
+        
+        # 응답이 비어있는지 확인
+        if not response_text or not response_text.strip():
+            return False, "AI 응답이 비어 있습니다."
+        
+        # 필요한 태그가 포함되어 있는지 확인
+        found_tags = []
+        for tag in expected_tags:
+            if tag in response_text:
+                found_tags.append(tag)
+        
+        if not found_tags:
+            return False, f"화자 태그({', '.join(expected_tags)})가 응답에 포함되지 않았습니다."
+        
+        if len(found_tags) < 2:
+            return False, f"최소 2개의 화자 태그가 필요하지만 {len(found_tags)}개만 발견되었습니다."
+        
+        return True, f"검증 성공: {', '.join(found_tags)} 태그 발견"
+    
+    def get_prompt(self, prompt_type, **kwargs):
+        """설정에서 프롬프트를 가져와 포맷팅합니다."""
+        prompts = self.config.get("prompts", {})
+        
+        if prompt_type == "speaker_separation":
+            template = prompts.get("speaker_separation", 
+                "당신은 2명의 화자가 나누는 대화를 분석하는 전문가입니다. 주어진 텍스트를 화자별로 분리해주세요.\n\n분석할 텍스트:\n{text}")
+        elif prompt_type == "spell_correction":
+            template = prompts.get("spell_correction",
+                "한국어 맞춤법을 교정해주세요. [화자1], [화자2] 태그는 유지하세요.\n\n교정할 텍스트:\n{text}")
+        else:
+            raise ValueError(f"알 수 없는 프롬프트 타입: {prompt_type}")
+        
+        return template.format(**kwargs)
+    
+    def process_text(self, input_text, text_name=None, progress_callback=None, speaker1_name=None, speaker2_name=None):
         """
         텍스트를 처리하여 화자 분리 및 맞춤법 교정을 수행합니다.
         
@@ -67,6 +180,8 @@ class TextProcessor:
             input_text (str): 처리할 텍스트
             text_name (str): 텍스트 이름 (선택사항)
             progress_callback (function): 진행 상황을 알려주는 콜백 함수
+            speaker1_name (str): 화자1의 사용자 정의 이름
+            speaker2_name (str): 화자2의 사용자 정의 이름
             
         Returns:
             dict: 처리 결과 딕셔너리
@@ -84,42 +199,14 @@ class TextProcessor:
             
             full_text = input_text.strip()
             
-            # 1단계: Gemini로 화자 분리
-            if progress_callback:
-                progress_callback("AI 화자 분리 중...", 1, 3)
-            logger.info(f"AI 화자 분리 시작: {text_name}")
-            
-            speaker_separated_text = self.separate_speakers_with_gemini(full_text)
-            
-            # 2단계: 맞춤법 교정
-            if progress_callback:
-                progress_callback("맞춤법 교정 중...", 2, 3)
-            logger.info(f"맞춤법 교정 시작: {text_name}")
-            
-            corrected_text = self.correct_spelling_with_gemini(speaker_separated_text)
-            
-            # 3단계: 결과 파싱
-            if progress_callback:
-                progress_callback("결과 정리 중...", 3, 3)
-            
-            # 교정된 텍스트에서 화자별 대화 파싱
-            corrected_conversations = self.parse_separated_text(corrected_text)
-            original_conversations = self.parse_separated_text(speaker_separated_text)
-            
-            # 결과 딕셔너리 생성
-            processing_result = {
-                "text_name": text_name,
-                "processed_time": datetime.now().isoformat(),
-                "original_text": full_text,
-                "separated_text": speaker_separated_text,
-                "corrected_text": corrected_text,
-                "conversations_by_speaker_original": original_conversations,
-                "conversations_by_speaker_corrected": corrected_conversations,
-                "success": True
-            }
+            # 청킹 여부 결정
+            enable_chunking = self.config.get("processing", {}).get("enable_chunking", True)
+            chunk_size = self.config.get("processing", {}).get("chunk_size", 20000)
             
-            logger.info(f"텍스트 처리 완료: {text_name}")
-            return processing_result
+            if enable_chunking and len(full_text) > chunk_size:
+                return self.process_text_with_chunking(full_text, text_name, progress_callback, speaker1_name, speaker2_name)
+            else:
+                return self.process_text_single(full_text, text_name, progress_callback, speaker1_name, speaker2_name)
             
         except Exception as e:
             logger.error(f"텍스트 {text_name} 처리 중 ��류: {e}")
@@ -129,30 +216,154 @@ class TextProcessor:
                 "error": str(e)
             }
     
+    def process_text_single(self, full_text, text_name, progress_callback, speaker1_name, speaker2_name):
+        """단일 텍스트를 처리합니다."""
+        # 1단계: Gemini로 화자 분리
+        if progress_callback:
+            progress_callback("AI 화자 분리 중...", 1, 3)
+        logger.info(f"AI 화자 분리 시작: {text_name}")
+        
+        speaker_separated_text = self.separate_speakers_with_gemini(full_text)
+        
+        # AI 응답 검증
+        is_valid, validation_msg = self.validate_ai_response(speaker_separated_text)
+        if not is_valid:
+            raise ValueError(f"화자 분리 실패: {validation_msg}")
+        
+        logger.info(f"화자 분리 검증 완료: {validation_msg}")
+        
+        # 2단계: 맞춤법 교정
+        if progress_callback:
+            progress_callback("맞춤법 교정 중...", 2, 3)
+        logger.info(f"맞춤법 교정 시작: {text_name}")
+        
+        corrected_text = self.correct_spelling_with_gemini(speaker_separated_text)
+        
+        # 3단계: 결과 파싱 및 사용자 정의 이름 적용
+        if progress_callback:
+            progress_callback("결과 정리 중...", 3, 3)
+        
+        # 교정된 텍스트에서 화자별 대화 파싱
+        corrected_conversations = self.parse_separated_text(corrected_text)
+        original_conversations = self.parse_separated_text(speaker_separated_text)
+        
+        # 사용자 정의 화자 이름 적용
+        if speaker1_name or speaker2_name:
+            corrected_conversations, corrected_text = self.apply_custom_speaker_names(
+                corrected_conversations, corrected_text, speaker1_name, speaker2_name)
+            original_conversations, speaker_separated_text = self.apply_custom_speaker_names(
+                original_conversations, speaker_separated_text, speaker1_name, speaker2_name)
+        
+        # 결과 딕셔너리 생성
+        processing_result = {
+            "text_name": text_name,
+            "processed_time": datetime.now().isoformat(),
+            "original_text": full_text,
+            "separated_text": speaker_separated_text,
+            "corrected_text": corrected_text,
+            "conversations_by_speaker_original": original_conversations,
+            "conversations_by_speaker_corrected": corrected_conversations,
+            "speaker1_name": speaker1_name or "화자1",
+            "speaker2_name": speaker2_name or "화자2",
+            "success": True
+        }
+        
+        logger.info(f"텍스트 처리 완료: {text_name}")
+        return processing_result
+    
+    def process_text_with_chunking(self, full_text, text_name, progress_callback, speaker1_name, speaker2_name):
+        """청킹을 사용하여 대용량 텍스트를 처리합니다."""
+        logger.info(f"대용량 텍스트 청킹 처리 시작: {text_name}")
+        
+        chunks = self.split_text_into_chunks(full_text)
+        total_steps = len(chunks) * 2  # 화자 분리 + 맞춤법 교정
+        current_step = 0
+        
+        separated_chunks = []
+        corrected_chunks = []
+        
+        # 각 청크 처리
+        for i, chunk in enumerate(chunks):
+            # 화자 분리
+            current_step += 1
+            if progress_callback:
+                progress_callback(f"청크 {i+1}/{len(chunks)} 화자 분리 중...", current_step, total_steps)
+            
+            separated_chunk = self.separate_speakers_with_gemini(chunk)
+            
+            # AI 응답 검증
+            is_valid, validation_msg = self.validate_ai_response(separated_chunk)
+            if not is_valid:
+                logger.warning(f"청크 {i+1} 화자 분리 검증 실패: {validation_msg}")
+                # 검증 실패한 청크는 원본을 사용하되 기본 태그 추가
+                separated_chunk = f"[화자1] {chunk}"
+            
+            separated_chunks.append(separated_chunk)
+            
+            # 맞춤법 교정
+            current_step += 1
+            if progress_callback:
+                progress_callback(f"청크 {i+1}/{len(chunks)} 맞춤법 교정 중...", current_step, total_steps)
+            
+            corrected_chunk = self.correct_spelling_with_gemini(separated_chunk)
+            corrected_chunks.append(corrected_chunk)
+        
+        # 청크들을 다시 합치기
+        speaker_separated_text = "\n\n".join(separated_chunks)
+        corrected_text = "\n\n".join(corrected_chunks)
+        
+        # 결과 파싱 및 사용자 정의 이름 적용
+        corrected_conversations = self.parse_separated_text(corrected_text)
+        original_conversations = self.parse_separated_text(speaker_separated_text)
+        
+        if speaker1_name or speaker2_name:
+            corrected_conversations, corrected_text = self.apply_custom_speaker_names(
+                corrected_conversations, corrected_text, speaker1_name, speaker2_name)
+            original_conversations, speaker_separated_text = self.apply_custom_speaker_names(
+                original_conversations, speaker_separated_text, speaker1_name, speaker2_name)
+        
+        processing_result = {
+            "text_name": text_name,
+            "processed_time": datetime.now().isoformat(),
+            "original_text": full_text,
+            "separated_text": speaker_separated_text,
+            "corrected_text": corrected_text,
+            "conversations_by_speaker_original": original_conversations,
+            "conversations_by_speaker_corrected": corrected_conversations,
+            "speaker1_name": speaker1_name or "화자1",
+            "speaker2_name": speaker2_name or "화자2",
+            "chunks_processed": len(chunks),
+            "success": True
+        }
+        
+        logger.info(f"청킹 처리 완료: {text_name} ({len(chunks)}개 청크)")
+        return processing_result
+    
+    def apply_custom_speaker_names(self, conversations, text, speaker1_name, speaker2_name):
+        """사용자 정의 화자 이름을 적용합니다."""
+        updated_conversations = {}
+        updated_text = text
+        
+        # 대화 딕셔너리 업데이트
+        if speaker1_name:
+            updated_conversations[speaker1_name] = conversations.get("화자1", [])
+            updated_text = updated_text.replace("[화자1]", f"[{speaker1_name}]")
+        else:
+            updated_conversations["화자1"] = conversations.get("화자1", [])
+        
+        if speaker2_name:
+            updated_conversations[speaker2_name] = conversations.get("화자2", [])
+            updated_text = updated_text.replace("[화자2]", f"[{speaker2_name}]")
+        else:
+            updated_conversations["화자2"] = conversations.get("화자2", [])
+        
+        return updated_conversations, updated_text
+    
     def separate_speakers_with_gemini(self, text):
         """Gemini API를 사용하여 텍스트를 화자별로 분리합니다."""
         try:
-            prompt = f"""
-당신은 2명의 화자가 나누는 대화를 분석하는 전문가입니다. 
-주어진 텍스트를 분석하여 각 발언을 화자별로 구분해주세요.
-
-분석 지침:
-1. 대화의 맥락과 내용을 기반으로 화자를 구분하세요
-2. 말투, 주제 전환, 질문과 답변의 패턴을 활용하세요
-3. 화자1과 화자2로 구분하여 표시하세요
-4. 각 발언 앞에 [화자1] 또는 [화자2]를 붙여주세요
-5. 발언이 너무 길 경우 자연스러운 지점에서 나누어주세요
-
-출력 형식:
-[화자1] 첫 번째 발언 내용
-[화자2] 두 번째 발언 내용
-[화자1] 세 번째 발언 내용
-...
-
-분석할 텍스트:
-{text}
-"""
-
+            prompt = self.get_prompt("speaker_separation", text=text)
+            
             response = self.gemini_model.generate_content(prompt)
             separated_text = response.text.strip()
             
@@ -166,57 +377,8 @@ class TextProcessor:
     def correct_spelling_with_gemini(self, separated_text):
         """Gemini API를 사용하여 화자별 분리된 텍스트의 맞춤법을 교정합니다."""
         try:
-            prompt = f"""
-당신은 한국어 맞춤법 교정 전문가입니다. 
-주어진 텍스트에서 맞춤법 오류, 띄어쓰기 오류, 오타를 수정해주세요.
-
-교정 지침:
-1. 자연스러운 한국어 표현으로 수정하되, 원본의 의미와 말투는 유지하세요
-2. [화자1], [화자2] 태그는 그대로 유지하세요
-3. 전문 용어나 고유명사는 가능한 정확하게 수정하세요
-4. 구어체 특성은 유지하되, 명백한 오타만 수정하세요
-5. 문맥에 맞는 올바른 단어로 교체하세요
-
-수정이 필요한 예시:
-- "치특기" → "치트키"
-- "실점픽" → "실전 픽"  
-- "복사부천억" → "복사 붙여넣기"
-- "핵심같이가" → "핵심 가치가"
-- "재활" → "재활용"
-- "저정할" → "저장할"
-- "플레일" → "플레어"
-- "서벌 수" → "서버리스"
-- "커리" → "쿼리"
-- "전력" → "전략"
-- "클라클라" → "클라크"
-- "가인만" → "가입만"
-- "M5U" → "MAU"
-- "나온 로도" → "다운로드"
-- "무시무치" → "무시무시"
-- "송신유금" → "송신 요금"
-- "10지가" → "10GB"
-- "유금" → "요금"
-- "전 색을" → "전 세계"
-- "도무원은" → "도구들은"
-- "골차품데" → "골치 아픈데"
-- "변원해" → "변환해"
-- "f 운영" → "서비스 운영"
-- "오류추저개" → "오류 추적기"
-- "f 늘려질" → "서비스가 늘어날"
-- "캐시칭" → "캐싱"
-- "플레이어" → "플레어"
-- "업스테시" → "업스태시"
-- "원시근을" → "웬지슨"
-- "부각이릉도" → "부각들도"
-- "컴포넌트" → "컴포넌트"
-- "본이터링" → "모니터링"
-- "번뜨기는" → "번뜩이는"
-- "사용적 경험" → "사용자 경험"
-
-교정할 텍스트:
-{separated_text}
-"""
-
+            prompt = self.get_prompt("spell_correction", text=separated_text)
+            
             response = self.gemini_model.generate_content(prompt)
             corrected_text = response.text.strip()
             
@@ -246,6 +408,72 @@ class TextProcessor:
         
         return conversations
     
+    def create_download_zip(self, result, output_dir="output"):
+        """처리 결과를 ZIP 파일로 생성합니다."""
+        try:
+            if not self.config.get("output", {}).get("create_download_zip", True):
+                return None
+            
+            base_name = result["text_name"]
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            zip_path = os.path.join(output_dir, f"{base_name}_complete_{timestamp}.zip")
+            
+            with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                # 전체 대화 저장
+                all_content = self._generate_complete_text_content(result)
+                zipf.writestr(f"{base_name}_전체대화_{timestamp}.txt", all_content)
+                
+                # 화자별 개별 파일
+                for speaker, utterances in result['conversations_by_speaker_corrected'].items():
+                    if utterances:
+                        speaker_content = self._generate_speaker_content(result, speaker, utterances)
+                        zipf.writestr(f"{base_name}_{speaker}_교정본_{timestamp}.txt", speaker_content)
+                
+                # JSON 데이터
+                json_content = json.dumps(result, ensure_ascii=False, indent=2)
+                zipf.writestr(f"{base_name}_data_{timestamp}.json", json_content)
+            
+            logger.info(f"ZIP 파일 생성 완료: {zip_path}")
+            return zip_path
+            
+        except Exception as e:
+            logger.error(f"ZIP 파일 생성 중 오류: {e}")
+            return None
+    
+    def _generate_complete_text_content(self, result):
+        """전체 대화 텍스트 내용을 생성합니다."""
+        content = []
+        content.append(f"파일명: {result['text_name']}")
+        content.append(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        content.append(f"화자1: {result.get('speaker1_name', '화자1')}")
+        content.append(f"화자2: {result.get('speaker2_name', '화자2')}")
+        content.append("="*50)
+        content.append("원본 텍스트:")
+        content.append(result['original_text'])
+        content.append("="*50)
+        content.append("화자별 분리 결과 (원본):")
+        content.append(result['separated_text'])
+        content.append("="*50)
+        content.append("화자별 분리 결과 (맞춤법 교정):")
+        content.append(result['corrected_text'])
+        
+        return "\n".join(content)
+    
+    def _generate_speaker_content(self, result, speaker, utterances):
+        """화자별 개별 파일 내용을 생성합니다."""
+        content = []
+        content.append(f"파일명: {result['text_name']}")
+        content.append(f"화자: {speaker}")
+        content.append(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        content.append(f"발언 수: {len(utterances)}")
+        content.append("="*50)
+        
+        for idx, utterance in enumerate(utterances, 1):
+            content.append(f"{idx}. {utterance}")
+            content.append("")
+        
+        return "\n".join(content)
+    
     def save_results_to_files(self, result, output_dir="output"):
         """처리 결과를 파일로 저장합니다."""
         if not result.get("success", False):
@@ -257,47 +485,44 @@ class TextProcessor:
             if not os.path.exists(output_dir):
                 os.makedirs(output_dir)
             
-            base_name = result["base_name"]
+            base_name = result["text_name"]
             timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            saved_files = []
             
-            # 1. 전체 대화 저장 (원본, 화자 분리, 맞춤법 교정 포함)
-            all_txt_path = f"{output_dir}/{base_name}_전체대화_{timestamp}.txt"
-            with open(all_txt_path, 'w', encoding='utf-8') as f:
-                f.write(f"파일명: {base_name}\n")
-                f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-                f.write(f"언어: {result['language']}\n")
-                f.write("="*50 + "\n\n")
-                f.write("원본 텍스트:\n")
-                f.write(result['original_text'] + "\n\n")
-                f.write("="*50 + "\n\n")
-                f.write("화자별 분리 결과 (원본):\n")
-                f.write(result['separated_text'] + "\n\n")
-                f.write("="*50 + "\n\n")
-                f.write("화자별 분리 결과 (맞춤법 교정):\n")
-                f.write(result['corrected_text'] + "\n")
-            
-            # 2. 교정된 화자별 개별 파일 저장
-            for speaker, utterances in result['conversations_by_speaker_corrected'].items():
-                if utterances:
-                    speaker_txt_path = f"{output_dir}/{base_name}_{speaker}_교정본_{timestamp}.txt"
-                    with open(speaker_txt_path, 'w', encoding='utf-8') as f:
-                        f.write(f"파일명: {base_name}\n")
-                        f.write(f"화자: {speaker}\n")
-                        f.write(f"처리 시간: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
-                        f.write(f"발언 수: {len(utterances)}\n")
-                        f.write("="*50 + "\n\n")
-                        
-                        for idx, utterance in enumerate(utterances, 1):
-                            f.write(f"{idx}. {utterance}\n\n")
-            
-            # 3. JSON 형태로도 저장 (분석용)
-            json_path = f"{output_dir}/{base_name}_data_{timestamp}.json"
-            with open(json_path, 'w', encoding='utf-8') as f:
-                json.dump(result, f, ensure_ascii=False, indent=2)
-            
-            logger.info(f"결과 파일 저장 완료: {output_dir}")
+            output_config = self.config.get("output", {})
+            
+            # 1. 전체 대화 저장
+            if output_config.get("save_original", True) or output_config.get("save_separated", True) or output_config.get("save_corrected", True):
+                all_txt_path = f"{output_dir}/{base_name}_전체대화_{timestamp}.txt"
+                with open(all_txt_path, 'w', encoding='utf-8') as f:
+                    f.write(self._generate_complete_text_content(result))
+                saved_files.append(all_txt_path)
+            
+            # 2. 화자별 개별 파일 저장
+            if output_config.get("save_individual_speakers", True):
+                for speaker, utterances in result['conversations_by_speaker_corrected'].items():
+                    if utterances:
+                        speaker_txt_path = f"{output_dir}/{base_name}_{speaker}_교정본_{timestamp}.txt"
+                        with open(speaker_txt_path, 'w', encoding='utf-8') as f:
+                            f.write(self._generate_speaker_content(result, speaker, utterances))
+                        saved_files.append(speaker_txt_path)
+            
+            # 3. JSON 형태로도 저장
+            if output_config.get("save_json", True):
+                json_path = f"{output_dir}/{base_name}_data_{timestamp}.json"
+                with open(json_path, 'w', encoding='utf-8') as f:
+                    json.dump(result, f, ensure_ascii=False, indent=2)
+                saved_files.append(json_path)
+            
+            # 4. ZIP 파일 생성
+            zip_path = self.create_download_zip(result, output_dir)
+            if zip_path:
+                saved_files.append(zip_path)
+            
+            logger.info(f"결과 파일 저장 완료: {len(saved_files)}개 파일")
+            result["saved_files"] = saved_files
             return True
             
         except Exception as e:
             logger.error(f"결과 파일 저장 중 오류: {e}")
-            return False 
+            return False