Update app.py

app.py

@@ -4,15 +4,20 @@ import json
 import requests
 from datetime import datetime
 import time
-from typing import List, Dict, Any, Generator, Optional
+from typing import List, Dict, Any, Generator, Tuple, Optional, Set
 import logging
 import re
+import tempfile
+from pathlib import Path
 import sqlite3
+import hashlib
 import threading
 from contextlib import contextmanager
 from dataclasses import dataclass, field, asdict
 from collections import defaultdict
-import secrets
+import json
+from pathlib import Path
+import random
 
 # --- Logging setup ---
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -93,6 +98,7 @@ class StoryBible:
     plot_points: List[Dict[str, Any]] = field(default_factory=list)
     themes: List[str] = field(default_factory=list)
     symbols: Dict[str, List[str]] = field(default_factory=dict)
+    style_guide: Dict[str, str] = field(default_factory=dict)
     opening_sentence: str = ""
 
 @dataclass
@@ -249,18 +255,6 @@ class NovelDatabase:
                 )
             ''')
             
-            # Random themes table
-            cursor.execute('''
-                CREATE TABLE IF NOT EXISTS random_themes (
-                    id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    theme_text TEXT NOT NULL,
-                    language TEXT NOT NULL,
-                    created_at TEXT DEFAULT (datetime('now')),
-                    used_count INTEGER DEFAULT 0,
-                    last_used TEXT
-                )
-            ''')
-            
             conn.commit()
 
     @staticmethod
@@ -276,7 +270,6 @@ class NovelDatabase:
 
     @staticmethod
     def create_session(user_query: str, language: str) -> str:
-        import hashlib
         session_id = hashlib.md5(f"{user_query}{datetime.now()}".encode()).hexdigest()
         with NovelDatabase.get_db() as conn:
             conn.cursor().execute(
@@ -454,48 +447,6 @@ class NovelDatabase:
             ).fetchone()
             return row['total_words'] if row and row['total_words'] else 0
 
-    @staticmethod
-    def save_random_theme(theme_text: str, language: str) -> int:
-        """Save random theme to database"""
-        with NovelDatabase.get_db() as conn:
-            cursor = conn.cursor()
-            cursor.execute(
-                'INSERT INTO random_themes (theme_text, language) VALUES (?, ?)',
-                (theme_text, language)
-            )
-            conn.commit()
-            return cursor.lastrowid
-
-    @staticmethod
-    def get_random_themes(language: str = None, limit: int = 50) -> List[Dict]:
-        """Get random themes from database"""
-        with NovelDatabase.get_db() as conn:
-            if language:
-                query = '''SELECT * FROM random_themes 
-                          WHERE language = ? 
-                          ORDER BY created_at DESC 
-                          LIMIT ?'''
-                rows = conn.cursor().execute(query, (language, limit)).fetchall()
-            else:
-                query = '''SELECT * FROM random_themes 
-                          ORDER BY created_at DESC 
-                          LIMIT ?'''
-                rows = conn.cursor().execute(query, (limit,)).fetchall()
-            return [dict(row) for row in rows]
-
-    @staticmethod
-    def update_theme_usage(theme_id: int):
-        """Update theme usage count and last used time"""
-        with NovelDatabase.get_db() as conn:
-            conn.cursor().execute(
-                '''UPDATE random_themes 
-                   SET used_count = used_count + 1, 
-                       last_used = datetime('now') 
-                   WHERE id = ?''',
-                (theme_id,)
-            )
-            conn.commit()
-
 class WebSearchIntegration:
     """Web search functionality"""
     def __init__(self):
@@ -872,6 +823,7 @@ Provide concrete, innovative plan."""
 **Characters:** {', '.join(story_bible.characters.keys()) if story_bible.characters else 'TBD'}
 **Key Symbols:** {', '.join(story_bible.symbols.keys()) if story_bible.symbols else 'TBD'}
 **Themes:** {', '.join(story_bible.themes[:3]) if story_bible.themes else 'TBD'}
+**Style:** {story_bible.style_guide.get('voice', 'N/A')}
 """
         
         # Previous content summary
@@ -1365,8 +1317,8 @@ Provide specific and actionable revision instructions."""
 
     # --- Main process ---
     def process_novel_stream(self, query: str, language: str, 
-                           session_id: Optional[str] = None) -> Generator[List[Dict[str, Any]], None, None]:
-        """Single writer novel generation process with enhanced progress tracking"""
+                           session_id: Optional[str] = None) -> Generator[Tuple[str, List[Dict[str, Any]], str], None, None]:
+        """Single writer novel generation process"""
         try:
             resume_from_stage = 0
             if session_id:
@@ -1390,10 +1342,8 @@ Provide specific and actionable revision instructions."""
                     "status": s['status'], 
                     "content": s.get('content', ''),
                     "word_count": s.get('word_count', 0),
-                    "momentum": s.get('narrative_momentum', 0.0),
-                    "role": s.get('role', ''),
-                    "stage_number": i
-                } for i, s in enumerate(NovelDatabase.get_stages(self.current_session_id))]
+                    "momentum": s.get('narrative_momentum', 0.0)
+                } for s in NovelDatabase.get_stages(self.current_session_id)]
 
             total_words = NovelDatabase.get_total_words(self.current_session_id)
 
@@ -1405,39 +1355,12 @@ Provide specific and actionable revision instructions."""
                         "status": "active", 
                         "content": "", 
                         "word_count": 0,
-                        "momentum": 0.0,
-                        "role": role,
-                        "stage_number": stage_idx,
-                        "progress_detail": {
-                            "current_role": role,
-                            "phase": self._get_stage_phase(stage_idx),
-                            "part_number": self._get_part_number(stage_idx),
-                            "action": self._get_stage_action(role, stage_idx)
-                        }
+                        "momentum": 0.0
                     })
                 else:
                     stages[stage_idx]["status"] = "active"
-                    stages[stage_idx]["progress_detail"] = {
-                        "current_role": role,
-                        "phase": self._get_stage_phase(stage_idx),
-                        "part_number": self._get_part_number(stage_idx),
-                        "action": self._get_stage_action(role, stage_idx)
-                    }
 
-                # Enhanced progress info
-                progress_info = {
-                    "session_id": self.current_session_id,
-                    "current_stage": stage_idx,
-                    "total_stages": len(UNIFIED_STAGES),
-                    "current_role": role,
-                    "stage_name": stage_name,
-                    "total_words": total_words,
-                    "target_words": TARGET_WORDS,
-                    "percentage": (stage_idx / len(UNIFIED_STAGES)) * 100,
-                    "status": f"🔄 {self._get_role_emoji(role)} {self._get_role_name(role)} is {self._get_stage_action(role, stage_idx)}..."
-                }
-                
-                yield stages, progress_info
+                yield f"🔄 Processing... (Current {total_words:,} words)", stages, self.current_session_id
                 
                 prompt = self.get_stage_prompt(stage_idx, role, query, language, stages)
                 stage_content = ""
@@ -1446,10 +1369,7 @@ Provide specific and actionable revision instructions."""
                     stage_content += chunk
                     stages[stage_idx]["content"] = stage_content
                     stages[stage_idx]["word_count"] = len(stage_content.split())
-                    
-                    # Update progress during streaming
-                    progress_info["status"] = f"🔄 {self._get_role_emoji(role)} {self._get_role_name(role)} is {self._get_stage_action(role, stage_idx)}... ({stages[stage_idx]['word_count']} words)"
-                    yield stages, progress_info
+                    yield f"🔄 {stage_name} writing... ({total_words + stages[stage_idx]['word_count']:,} words)", stages, self.current_session_id
 
                 # Content processing and tracking
                 if role == "writer":
@@ -1474,11 +1394,7 @@ Provide specific and actionable revision instructions."""
                 
                 NovelDatabase.save_narrative_tracker(self.current_session_id, self.narrative_tracker)
                 total_words = NovelDatabase.get_total_words(self.current_session_id)
-                
-                # Update progress after completion
-                progress_info["total_words"] = total_words
-                progress_info["status"] = f"✅ {self._get_role_emoji(role)} {self._get_role_name(role)} completed {self._get_stage_action(role, stage_idx, completed=True)}"
-                yield stages, progress_info
+                yield f"✅ {stage_name} completed (Total {total_words:,} words)", stages, self.current_session_id
 
             # Final processing
             final_novel = NovelDatabase.get_writer_content(self.current_session_id)
@@ -1486,91 +1402,11 @@ Provide specific and actionable revision instructions."""
             final_report = self.generate_literary_report(final_novel, final_word_count, language)
             
             NovelDatabase.update_final_novel(self.current_session_id, final_novel, final_report)
-            
-            # Final progress info
-            final_progress = {
-                "session_id": self.current_session_id,
-                "current_stage": len(UNIFIED_STAGES),
-                "total_stages": len(UNIFIED_STAGES),
-                "current_role": "complete",
-                "stage_name": "Novel Completed",
-                "total_words": final_word_count,
-                "target_words": TARGET_WORDS,
-                "percentage": 100,
-                "status": f"✅ Novel completed! Total {final_word_count:,} words"
-            }
-            yield stages, final_progress
+            yield f"✅ Novel completed! Total {final_word_count:,} words", stages, self.current_session_id
 
         except Exception as e:
             logger.error(f"Novel generation process error: {e}", exc_info=True)
-            error_progress = {
-                "session_id": self.current_session_id,
-                "status": f"❌ Error occurred: {e}",
-                "error": True
-            }
-            yield stages if 'stages' in locals() else [], error_progress
-
-    def _get_role_emoji(self, role: str) -> str:
-        """Get emoji for role"""
-        emoji_map = {
-            "director": "🎬",
-            "writer": "✍️",
-            "critic_director": "🔍",
-            "critic_final": "📊"
-        }
-        if role.startswith("critic_part"):
-            return "📝"
-        return emoji_map.get(role, "🔄")
-
-    def _get_role_name(self, role: str) -> str:
-        """Get display name for role"""
-        role_names = {
-            "director": "Director",
-            "writer": "Writer",
-            "critic_director": "Structure Critic",
-            "critic_final": "Final Critic"
-        }
-        if role.startswith("critic_part"):
-            part_num = role.replace("critic_part", "")
-            return f"Part {part_num} Critic"
-        return role_names.get(role, role.title())
-
-    def _get_stage_action(self, role: str, stage_idx: int, completed: bool = False) -> str:
-        """Get action description for stage"""
-        if completed:
-            action_map = {
-                "director": "narrative planning" if stage_idx < 3 else "final master plan",
-                "writer": "writing" if "Revision" not in UNIFIED_STAGES[stage_idx][1] else "revision",
-                "critic_director": "structure review",
-                "critic_final": "comprehensive evaluation"
-            }
-        else:
-            action_map = {
-                "director": "planning narrative structure" if stage_idx < 3 else "finalizing master plan",
-                "writer": "writing" if "Revision" not in UNIFIED_STAGES[stage_idx][1] else "revising based on critique",
-                "critic_director": "reviewing narrative structure",
-                "critic_final": "evaluating complete novel"
-            }
-        
-        if role.startswith("critic_part"):
-            if completed:
-                return "part review"
-            else:
-                return "reviewing part for improvements"
-        
-        return action_map.get(role, "processing")
-
-    def _get_stage_phase(self, stage_idx: int) -> str:
-        """Get phase description for stage"""
-        if stage_idx < 3:
-            return "Planning Phase"
-        elif stage_idx < len(UNIFIED_STAGES) - 1:
-            part_num = self._get_part_number(stage_idx)
-            if part_num:
-                return f"Part {part_num} Phase"
-            return "Writing Phase"
-        else:
-            return "Final Evaluation Phase"
+            yield f"❌ Error occurred: {e}", stages if 'stages' in locals() else [], self.current_session_id
 
     def get_stage_prompt(self, stage_idx: int, role: str, query: str, 
                         language: str, stages: List[Dict]) -> str:
@@ -1681,36 +1517,25 @@ Present concrete and executable final plan."""
 
 
 # --- Utility functions ---
-def process_query(query: str, language: str, session_id: Optional[str] = None) -> Generator[Dict[str, Any], None, None]:
-    """Main query processing function with enhanced progress tracking"""
+def process_query(query: str, language: str, session_id: Optional[str] = None) -> Generator[Tuple[str, str, str, str], None, None]:
+    """Main query processing function"""
     if not query.strip():
-        yield {
-            "stages_markdown": "",
-            "novel_content": "",
-            "status": "❌ Please enter a theme.",
-            "session_id": session_id,
-            "progress_info": {"error": True, "status": "❌ Please enter a theme."}
-        }
+        yield "", "", "❌ Please enter a theme.", session_id
         return
     
     system = UnifiedLiterarySystem()
+    stages_markdown = ""
+    novel_content = ""
     
-    for stages, progress_info in system.process_novel_stream(query, language, session_id):
-        stages_markdown = format_stages_display(stages, progress_info)
+    for status, stages, current_session_id in system.process_novel_stream(query, language, session_id):
+        stages_markdown = format_stages_display(stages)
         
         # Get final novel content
-        novel_content = ""
-        if progress_info.get("percentage", 0) == 100:
-            novel_content = NovelDatabase.get_writer_content(progress_info["session_id"])
+        if stages and all(s.get("status") == "complete" for s in stages[-10:]):
+            novel_content = NovelDatabase.get_writer_content(current_session_id)
             novel_content = format_novel_display(novel_content)
         
-        yield {
-            "stages_markdown": stages_markdown,
-            "novel_content": novel_content,
-            "status": progress_info.get("status", "🔄 Processing..."),
-            "session_id": progress_info.get("session_id", session_id),
-            "progress_info": progress_info
-        }
+        yield stages_markdown, novel_content, status or "🔄 Processing...", current_session_id
 
 def get_active_sessions(language: str) -> List[str]:
     """Get active session list"""
@@ -1718,24 +1543,18 @@ def get_active_sessions(language: str) -> List[str]:
     return [f"{s['session_id'][:8]}... - {s['user_query'][:50]}... ({s['created_at']}) [{s['total_words']:,} words]" 
             for s in sessions]
 
-def auto_recover_session(language: str) -> Dict[str, Any]:
+def auto_recover_session(language: str) -> Tuple[Optional[str], str]:
     """Auto-recover recent session"""
     sessions = NovelDatabase.get_active_sessions()
     if sessions:
         latest_session = sessions[0]
-        return {"session_id": latest_session['session_id'], "message": f"Session {latest_session['session_id'][:8]}... recovered"}
-    return {"session_id": None, "message": "No session to recover."}
+        return latest_session['session_id'], f"Session {latest_session['session_id'][:8]}... recovered"
+    return None, "No session to recover."
 
-def resume_session(session_id: str, language: str) -> Generator[Dict[str, Any], None, None]:
+def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str, str], None, None]:
     """Resume session"""
     if not session_id:
-        yield {
-            "stages_markdown": "",
-            "novel_content": "",
-            "status": "❌ No session ID.",
-            "session_id": None,
-            "progress_info": {"error": True, "status": "❌ No session ID."}
-        }
+        yield "", "", "❌ No session ID.", session_id
         return
     
     if "..." in session_id:
@@ -1743,13 +1562,7 @@ def resume_session(session_id: str, language: str) -> Generator[Dict[str, Any],
     
     session = NovelDatabase.get_session(session_id)
     if not session:
-        yield {
-            "stages_markdown": "",
-            "novel_content": "",
-            "status": "❌ Session not found.",
-            "session_id": None,
-            "progress_info": {"error": True, "status": "❌ Session not found."}
-        }
+        yield "", "", "❌ Session not found.", None
         return
     
     yield from process_query(session['user_query'], session['language'], session_id)
@@ -1771,144 +1584,61 @@ def download_novel(novel_text: str, format_type: str, language: str, session_id:
        logger.error(f"File generation failed: {e}")
        return None
 
-def format_stages_display(stages: List[Dict], progress_info: Dict) -> str:
-    """Stage progress display with enhanced role identification"""
-    markdown = "## 🎬 Progress Status\n\n"
-    
-    # Overall progress bar
-    percentage = progress_info.get("percentage", 0)
-    progress_bar = create_progress_bar(percentage)
-    markdown += f"{progress_bar}\n\n"
-    
-    # Current status with role identification
-    current_role = progress_info.get("current_role", "")
-    current_action = progress_info.get("status", "")
-    markdown += f"### 🎯 Current Status\n"
-    markdown += f"**{current_action}**\n\n"
-    
-    # Statistics
-    total_words = progress_info.get("total_words", 0)
-    target_words = progress_info.get("target_words", TARGET_WORDS)
-    markdown += f"**Total Word Count: {total_words:,} / {target_words:,}** ({(total_words/target_words*100):.1f}%)\n"
-    
-    # Calculate completed parts
-    completed_parts = sum(1 for s in stages 
+def format_stages_display(stages: List[Dict]) -> str:
+   """Stage progress display - For single writer system"""
+   markdown = "## 🎬 Progress Status\n\n"
+   
+   # Calculate total word count (writer stages only)
+   total_words = sum(s.get('word_count', 0) for s in stages 
+                    if s.get('name', '').startswith('✍️ Writer:') and 'Revision' in s.get('name', ''))
+   markdown += f"**Total Word Count: {total_words:,} / {TARGET_WORDS:,}**\n\n"
+   
+   # Progress summary
+   completed_parts = sum(1 for s in stages 
                         if 'Revision' in s.get('name', '') and s.get('status') == 'complete')
-    markdown += f"**Completed Parts: {completed_parts} / 10**\n"
-    
-    # Average narrative momentum
-    momentum_scores = [s.get('momentum', 0) for s in stages if s.get('momentum', 0) > 0]
-    if momentum_scores:
-        avg_momentum = sum(momentum_scores) / len(momentum_scores)
-        markdown += f"**Average Narrative Momentum: {avg_momentum:.1f} / 10**\n"
-    
-    markdown += "\n---\n\n"
-    
-    # Stage details with role identification
-    current_phase = ""
-    for stage in stages:
-        # Phase headers
-        stage_phase = get_stage_phase_from_name(stage.get('name', ''))
-        if stage_phase != current_phase:
-            current_phase = stage_phase
-            markdown += f"\n### 📚 {current_phase}\n\n"
-        
-        # Stage status
-        status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
-        role_emoji = get_role_emoji_from_name(stage.get('name', ''))
-        
-        # Stage line with role identification
-        markdown += f"{status_icon} {role_emoji} **{stage['name']}**"
-        
-        # Add role tag
-        role = stage.get('role', '')
-        if role:
-            role_display = get_role_display_name(role)
-            markdown += f" `[{role_display}]`"
-        
-        # Word count and momentum
-        if stage.get('word_count', 0) > 0:
-            markdown += f" ({stage['word_count']:,} words)"
-        
-        if stage.get('momentum', 0) > 0:
-            markdown += f" [Momentum: {stage['momentum']:.1f}/10]"
-        
-        markdown += "\n"
-        
-        # Content preview
-        if stage['content'] and stage['status'] == 'complete':
-            # Adjust preview length by role
-            preview_length = 300 if 'writer' in stage.get('role', '') else 200
-            preview = stage['content'][:preview_length] + "..." if len(stage['content']) > preview_length else stage['content']
-            markdown += f"> {preview}\n\n"
-        elif stage['status'] == 'active':
-            # Show what the current role is doing
-            role_action = get_role_action_description(stage.get('role', ''), stage.get('name', ''))
-            markdown += f"> *{role_action}...*\n\n"
-    
-    return markdown
-
-def create_progress_bar(percentage: float) -> str:
-    """Create visual progress bar"""
-    filled = int(percentage / 5)  # 20 blocks total
-    empty = 20 - filled
-    bar = "█" * filled + "░" * empty
-    return f"Progress: [{bar}] {percentage:.1f}%"
-
-def get_stage_phase_from_name(stage_name: str) -> str:
-    """Determine phase from stage name"""
-    if "Director" in stage_name and "Final Master Plan" not in stage_name:
-        return "Planning Phase"
-    elif "Final Master Plan" in stage_name:
-        return "Master Plan Finalization"
-    elif "Final Critic" in stage_name:
-        return "Final Evaluation Phase"
-    elif match := re.search(r'Part (\d+)', stage_name):
-        part_num = int(match.group(1))
-        return f"Part {part_num}: {NARRATIVE_PHASES[part_num-1]}"
-    return "Processing Phase"
-
-def get_role_emoji_from_name(stage_name: str) -> str:
-    """Get emoji based on stage name"""
-    if "Director" in stage_name:
-        return "🎬"
-    elif "Writer" in stage_name:
-        return "✍️"
-    elif "Final Critic" in stage_name:
-        return "📊"
-    elif "Critic" in stage_name:
-        return "📝"
-    return "🔄"
-
-def get_role_display_name(role: str) -> str:
-    """Get user-friendly role name"""
-    role_map = {
-        "director": "Director",
-        "writer": "Writer",
-        "critic_director": "Structure Critic",
-        "critic_final": "Final Evaluator"
-    }
-    if role.startswith("critic_part"):
-        part_num = role.replace("critic_part", "")
-        return f"Part {part_num} Critic"
-    return role_map.get(role, role.title())
-
-def get_role_action_description(role: str, stage_name: str) -> str:
-    """Get detailed action description for active role"""
-    actions = {
-        "director": "Planning narrative structure and character arcs",
-        "writer": "Crafting literary prose with philosophical depth",
-        "critic_director": "Analyzing structural coherence and feasibility",
-        "critic_final": "Evaluating literary achievement and impact"
-    }
-    
-    if role.startswith("critic_part"):
-        return "Reviewing for continuity, depth, and literary quality"
-    
-    if "Revision" in stage_name:
-        return "Incorporating critique to enhance literary quality"
-    
-    return actions.get(role, "Processing content")
+   markdown += f"**Completed Parts: {completed_parts} / 10**\n\n"
+   
+   # Average narrative momentum
+   momentum_scores = [s.get('momentum', 0) for s in stages if s.get('momentum', 0) > 0]
+   if momentum_scores:
+       avg_momentum = sum(momentum_scores) / len(momentum_scores)
+       markdown += f"**Average Narrative Momentum: {avg_momentum:.1f} / 10**\n\n"
+   
+   markdown += "---\n\n"
+   
+   # Display each stage
+   current_part = 0
+   for i, stage in enumerate(stages):
+       status_icon = "✅" if stage['status'] == 'complete' else "🔄" if stage['status'] == 'active' else "⏳"
+       
+       # Add part divider
+       if 'Part' in stage.get('name', '') and 'Critic' not in stage.get('name', ''):
+           part_match = re.search(r'Part (\d+)', stage['name'])
+           if part_match:
+               new_part = int(part_match.group(1))
+               if new_part != current_part:
+                   current_part = new_part
+                   markdown += f"\n### 📚 Part {current_part}\n\n"
+       
+       markdown += f"{status_icon} **{stage['name']}**"
+       
+       if stage.get('word_count', 0) > 0:
+           markdown += f" ({stage['word_count']:,} words)"
+       
+       if stage.get('momentum', 0) > 0:
+           markdown += f" [Momentum: {stage['momentum']:.1f}/10]"
+       
+       markdown += "\n"
+       
+       if stage['content'] and stage['status'] == 'complete':
+           # Adjust preview length by role
+           preview_length = 300 if 'writer' in stage.get('name', '').lower() else 200
+           preview = stage['content'][:preview_length] + "..." if len(stage['content']) > preview_length else stage['content']
+           markdown += f"> {preview}\n\n"
+       elif stage['status'] == 'active':
+           markdown += "> *Writing...*\n\n"
+   
+   return markdown
 
 def format_novel_display(novel_text: str) -> str:
    """Display novel content - Enhanced part separation"""
@@ -1959,9 +1689,10 @@ def export_to_docx(content: str, filename: str, language: str, session_id: str)
     # Generate title from session info
     session = NovelDatabase.get_session(session_id)
     
-    # Generate title based on theme and content
+    # Title generation function
     def generate_title(user_query: str, content_preview: str) -> str:
         """Generate title based on theme and content"""
+        # Simple rule-based title generation (could use LLM)
         if len(user_query) < 20:
             return user_query
         else:
@@ -2007,12 +1738,14 @@ def export_to_docx(content: str, filename: str, language: str, session_id: str)
         # Remove part titles/numbers patterns
         patterns_to_remove = [
             r'^#{1,6}\s+.*',          # Markdown headers
-            r'^\*\*.*\*\*',           # Bold text **text**
-            r'^Part\s*\d+.*',         # "Part 1 …" format
-            r'^\d+\.\s+.*:.*',        # "1. Title: …" format
-            r'^---+',                 # Dividers
-            r'^\s*\[.*\]\s*',         # Bracket labels
+            r'^\*\*.*\*\*',           # 굵은 글씨 **text**
+            r'^Part\s*\d+.*',         # “Part 1 …” 형식
+            r'^\d+\.\s+.*:.*',        # “1. 제목: …” 형식
+            r'^---+',                 # 구분선
+            r'^\s*\[.*\]\s*',         # 대괄호 라벨
         ]
+
+
         
         lines = text.split('\n')
         cleaned_lines = []
@@ -2096,120 +1829,7 @@ def export_to_txt(content: str, filename: str) -> str:
    
    return filepath
 
-def generate_random_theme(language="English", save_to_db=True):
-    """Generate a realistic and relatable novel theme"""
-    try:
-        # Realistic theme components
-        themes = {
-            "Korean": {
-                "situations": [
-                    "아버지의 장례식에서 만난 낯선 사람들",
-                    "30년 만에 돌아온 고향의 변화",
-                    "은퇴 후 시작된 예상치 못한 일상",
-                    "딸이 남긴 일기장을 읽는 어머니",
-                    "폐업을 앞둔 오래된 책방의 마지막 날들",
-                    "치매가 시작된 남편을 돌보는 아내",
-                    "이혼 후 혼자 키우는 아이와의 관계",
-                    "형제간의 유산 분쟁과 가족의 의미"
-                ],
-                "conflicts": [
-                    "평생 숨겨온 비밀의 무게",
-                    "변화를 받아들이는 것의 어려움",
-                    "과거와 화해하려는 시도",
-                    "사랑과 의무 사이의 갈등",
-                    "세대 간 가치관의 충돌",
-                    "정체성에 대한 혼란과 탐색",
-                    "용서와 화해의 가능성",
-                    "삶의 의미를 재정의하는 과정"
-                ],
-                "questions": [
-                    "진정한 가족의 의미는 무엇인가?",
-                    "우리는 과거로부터 자유로울 수 있는가?",
-                    "변화 속에서 변하지 않는 것은 무엇인가?",
-                    "사랑은 모든 것을 극복할 수 있는가?",
-                    "우리가 남기고 가는 것은 무엇인가?",
-                    "용서란 무엇이며 어떻게 가능한가?",
-                    "나이가 든다는 것의 진정한 의미는?",
-                    "행복의 조건은 무엇인가?"
-                ]
-            },
-            "English": {
-                "situations": [
-                    "strangers met at father's funeral",
-                    "returning home after thirty years away",
-                    "unexpected daily life after retirement",
-                    "mother reading daughter's left diary",
-                    "last days of an old bookstore closing",
-                    "wife caring for husband with early dementia",
-                    "single parent after difficult divorce",
-                    "inheritance dispute between siblings"
-                ],
-                "conflicts": [
-                    "weight of lifelong hidden secrets",
-                    "difficulty of accepting change",
-                    "attempting reconciliation with past",
-                    "conflict between love and duty",
-                    "generational clash of values",
-                    "confusion and search for identity",
-                    "possibility of forgiveness and healing",
-                    "process of redefining life's meaning"
-                ],
-                "questions": [
-                    "What truly makes a family?",
-                    "Can we ever be free from our past?",
-                    "What remains unchanged amid change?",
-                    "Can love overcome everything?",
-                    "What legacy do we leave behind?",
-                    "What is forgiveness and how is it possible?",
-                    "What does it truly mean to grow old?",
-                    "What are the conditions for happiness?"
-                ]
-            }
-        }
-        
-        # Select language-appropriate components
-        lang_themes = themes.get(language, themes["English"])
-        
-        situation = secrets.choice(lang_themes["situations"])
-        conflict = secrets.choice(lang_themes["conflicts"])
-        question = secrets.choice(lang_themes["questions"])
-        
-        # Create natural theme description
-        if language == "Korean":
-            theme = f"""{situation}
-
-이 상황에서 주인공은 {conflict}에 직면하게 됩니다.
-결국 이 이야기는 "{question}"라는 질문에 대한 하나의 대답을 찾아가는 여정이 될 것입니다.
-
-인간의 보편적인 감정과 현대 사회의 구체적인 현실이 교차하는 지점에서,
-우리 모두가 한 번쯤 마주하게 되는 삶의 본질적인 문제들을 탐구합니다."""
-        else:
-            theme = f"""{situation}
-
-In this situation, the protagonist faces {conflict}.
-Ultimately, this story becomes a journey to find one answer to the question: "{question}"
-
-At the intersection of universal human emotions and concrete modern realities,
-it explores the essential life questions we all face at some point."""
-        
-        # Save to database if requested
-        if save_to_db:
-            NovelDatabase.save_random_theme(theme, language)
-        
-        return theme
-        
-    except Exception as e:
-        logger.error(f"Theme generation error: {str(e)}")
-        # Fallback themes
-        fallback = {
-            "Korean": "은퇴한 교사가 옛 제자의 편지를 받고 시작되는 과거와의 화해",
-            "English": "A retired teacher's reconciliation with the past after receiving a letter from a former student"
-        }
-        theme = fallback.get(language, fallback["English"])
-        if save_to_db:
-            NovelDatabase.save_random_theme(theme, language)
-        return theme
-
+# CSS styles
 # CSS styles - Writer's Study Theme (Light & Warm)
 custom_css = """
 /* Global container - Light paper background */
@@ -2384,112 +2004,6 @@ custom_css = """
     color: #5a453a;
 }
 
-/* Progress display enhancements */
-#stages-display code {
-    background: #f5f0e6;
-    padding: 2px 6px;
-    border-radius: 4px;
-    font-family: 'Courier New', monospace;
-    color: #5a453a;
-    font-size: 0.9em;
-}
-
-/* Random theme library styles */
-#theme-library {
-    background: linear-gradient(to bottom, #ffffff 0%, #fdfcfa 100%);
-    padding: 25px;
-    border-radius: 16px;
-    box-shadow: 0 8px 25px rgba(139, 69, 19, 0.08),
-                inset 0 1px 3px rgba(255, 255, 255, 0.9);
-    color: #3d2914;
-    border: 1px solid #e8dcc6;
-}
-
-.theme-card {
-    background: linear-gradient(145deg, #faf8f5 0%, #f5f0e8 100%);
-    border: 1px solid #e0d0b8;
-    border-radius: 12px;
-    padding: 18px;
-    margin: 10px;
-    box-shadow: 0 3px 10px rgba(139, 69, 19, 0.08);
-    transition: all 0.3s ease;
-    cursor: pointer;
-    min-height: 150px;
-    display: flex;
-    flex-direction: column;
-    gap: 10px;
-}
-
-.theme-card:hover {
-    transform: translateY(-3px);
-    box-shadow: 0 5px 15px rgba(139, 69, 19, 0.15);
-    background: linear-gradient(145deg, #fcfaf8 0%, #f7f2ea 100%);
-}
-
-.theme-card-header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 8px;
-    padding-bottom: 8px;
-    border-bottom: 1px solid #e0d0b8;
-}
-
-.theme-card-date {
-    font-size: 0.75em;
-    color: #8b6239;
-    font-style: italic;
-}
-
-.theme-card-lang {
-    font-size: 0.75em;
-    background: #d4a574;
-    color: white;
-    padding: 2px 8px;
-    border-radius: 4px;
-    font-weight: 600;
-}
-
-.theme-card-content {
-    font-size: 0.85em;
-    line-height: 1.5;
-    color: #5a453a;
-    overflow: hidden;
-    text-overflow: ellipsis;
-    display: -webkit-box;
-    -webkit-line-clamp: 6;
-    -webkit-box-orient: vertical;
-}
-
-.theme-card-footer {
-    margin-top: auto;
-    padding-top: 8px;
-    border-top: 1px solid #f0e6d6;
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-}
-
-.theme-card-usage {
-    font-size: 0.7em;
-    color: #8b6239;
-}
-
-.theme-card-copy {
-    font-size: 0.75em;
-    background: #f5f0e6;
-    border: 1px solid #d4c4b0;
-    padding: 2px 8px;
-    border-radius: 4px;
-    cursor: pointer;
-    transition: all 0.2s ease;
-}
-
-.theme-card-copy:hover {
-    background: #d4a574;
-    color: white;
-}
-
 /* Download section - Book binding style */
 .download-section {
     background: linear-gradient(145deg, #faf6f0 0%, #f5efe6 100%);
@@ -3084,99 +2598,8 @@ def process_generated_theme(self, theme_text: str, language: str) -> str:
         summary += f"{theme_elements.get('exploration', '')}"
     
     return summary.strip()
-
-
-def format_theme_card(theme_data: Dict) -> str:
-    """Format theme data as HTML card"""
-    from html import escape
-    
-    theme_id = theme_data.get('id', 0)
-    theme_text = escape(theme_data.get('theme_text', ''))
-    language = theme_data.get('language', 'English')
-    created_at = theme_data.get('created_at', '')
-    used_count = theme_data.get('used_count', 0)
-    
-    # Format date
-    try:
-        date_obj = datetime.strptime(created_at, '%Y-%m-%d %H:%M:%S')
-        formatted_date = date_obj.strftime('%Y.%m.%d')
-    except:
-        formatted_date = created_at[:10] if created_at else 'Unknown'
-    
-    # Truncate text for card display
-    lines = theme_text.split('\n')
-    truncated_text = '\n'.join(lines[:6]) if len(lines) > 6 else theme_text
-    if len(truncated_text) > 300:
-        truncated_text = truncated_text[:297] + '...'
-    
-    return f"""
-    <div class="theme-card" data-theme-id="{theme_id}" data-theme-text="{theme_text}">
-        <div class="theme-card-header">
-            <span class="theme-card-date">{formatted_date}</span>
-            <span class="theme-card-lang">{language[:2].upper()}</span>
-        </div>
-        <div class="theme-card-content">
-            {escape(truncated_text).replace('\n', '<br>')}
-        </div>
-        <div class="theme-card-footer">
-            <span class="theme-card-usage">Used {used_count} times</span>
-            <button class="theme-card-copy" onclick="copyTheme({theme_id})">Copy</button>
-        </div>
-    </div>
-    """
-
-def format_theme_library(themes: List[Dict]) -> str:
-    """Format theme library as grid"""
-    if not themes:
-        return """
-        <div style="text-align: center; padding: 40px; color: #8b6239;">
-            <p style="font-size: 1.2em; margin-bottom: 20px;">📚 No themes in the library yet</p>
-            <p>Click the "Random Theme" button to generate and save themes!</p>
-        </div>
-        """
-    
-    # Create grid HTML
-    cards_html = ''.join([format_theme_card(theme) for theme in themes])
-    
-    return f"""
-    <div style="padding: 20px;">
-        <h3 style="color: #2c1810; font-family: 'Playfair Display', serif; margin-bottom: 20px;">
-            📚 Random Theme Library ({len(themes)} themes)
-        </h3>
-        <div style="display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 15px;">
-            {cards_html}
-        </div>
-    </div>
-    
-    <script>
-        function copyTheme(themeId) {{
-            const card = document.querySelector(`[data-theme-id="${{themeId}}"]`);
-            if (card) {{
-                const themeText = card.getAttribute('data-theme-text');
-                const textArea = document.getElementById('theme_input').querySelector('textarea');
-                if (textArea) {{
-                    textArea.value = themeText;
-                    textArea.dispatchEvent(new Event('input', {{ bubbles: true }}));
-                    
-                    // Visual feedback
-                    const copyBtn = card.querySelector('.theme-card-copy');
-                    const originalText = copyBtn.textContent;
-                    copyBtn.textContent = '✓ Copied';
-                    copyBtn.style.background = '#d4a574';
-                    copyBtn.style.color = 'white';
-                    
-                    setTimeout(() => {{
-                        copyBtn.textContent = originalText;
-                        copyBtn.style.background = '';
-                        copyBtn.style.color = '';
-                    }}, 2000);
-                }}
-            }}
-        }}
-    </script>
-    """
-
-    
+            
+# Create Gradio interface
 # Create Gradio interface - Writer's Study Theme
 def create_interface():
     # Using Soft theme with safe color options
@@ -3202,9 +2625,9 @@ def create_interface():
             </p>
             
             <div class="progress-note">
-                🎲 <strong>Novel Theme Random Generator:</strong> This system can generate unique, realistic novel themes based on universal human experiences. 
-                Each generated theme explores profound questions about family, identity, aging, and the human condition.
-                Click the "Random" button to discover meaningful story possibilities!
+                🎲 <strong>Novel Theme Random Generator:</strong> This system can generate up to approximately 170 quadrillion (1.7 × 10¹⁷) unique novel themes. 
+                Even writing 100 novels per day, it would take 4.6 million years to exhaust all combinations. 
+                Click the "Random" button to explore infinite creative possibilities!
             </div>
             
             <div class="warning-note">
@@ -3294,20 +2717,6 @@ def create_interface():
                         visible=False,
                         elem_id="download_file"
                     )
-            
-            with gr.Tab("🎲 Random Theme Library", elem_id="theme_library_tab"):
-                theme_library_display = gr.HTML(
-                    value=format_theme_library([]),
-                    elem_id="theme-library"
-                )
-                with gr.Row():
-                    theme_filter = gr.Radio(
-                        choices=["All", "English", "Korean"],
-                        value="All",
-                        label="Filter by Language",
-                        elem_id="theme_filter"
-                    )
-                    refresh_library_btn = gr.Button("🔄 Refresh Library", variant="secondary")
         
         # Hidden state
         novel_text_state = gr.State("")
@@ -3340,56 +2749,22 @@ def create_interface():
                 return gr.update(choices=[])
         
         def handle_auto_recover(language):
-            result = auto_recover_session(language)
-            return result["session_id"], result["message"]
-        
-        def handle_submit(query, language, session_id):
-            """Handle submit with proper return values"""
-            for result in process_query(query, language, session_id):
-                yield (
-                    result["stages_markdown"],
-                    result["novel_content"],
-                    result["status"],
-                    result["session_id"]
-                )
-        
-        def handle_resume(dropdown_value, language):
-            """Handle resume with proper return values"""
-            if not dropdown_value:
-                yield "", "", "❌ No session selected.", None
-                return
-                
-            session_id = dropdown_value.split("...")[0] if "..." in dropdown_value else dropdown_value
-            
-            for result in resume_session(session_id, language):
-                yield (
-                    result["stages_markdown"],
-                    result["novel_content"],
-                    result["status"],
-                    result["session_id"]
-                )
-        
-        def refresh_theme_library(filter_lang):
-            """Refresh theme library display"""
-            try:
-                if filter_lang == "All":
-                    themes = NovelDatabase.get_random_themes(limit=50)
-                else:
-                    themes = NovelDatabase.get_random_themes(language=filter_lang, limit=50)
-                return format_theme_library(themes)
-            except Exception as e:
-                logger.error(f"Theme library refresh error: {str(e)}")
-                return "<p>Error loading theme library</p>"
-        
-        def handle_random_theme_with_save(language):
-            """Generate random theme and save to database"""
-            theme = generate_random_theme(language, save_to_db=True)
-            logger.info(f"Generated and saved theme: {theme[:100]}...")
+            session_id, message = auto_recover_session(language)
+            return session_id, message
+
+        def handle_random_theme(language):
+            """Handle random theme generation with language support"""
+            import time
+            import datetime
+            time.sleep(0.05)
+            logger.info(f"Random theme requested at {datetime.datetime.now()}")
+            theme = generate_random_theme(language)
+            logger.info(f"Generated theme: {theme[:100]}...")
             return theme
         
         # Event connections
         submit_btn.click(
-            fn=handle_submit,
+            fn=process_query,
             inputs=[query_input, language_select, current_session_id],
             outputs=[stages_display, novel_output, status_text, current_session_id]
         )
@@ -3401,8 +2776,12 @@ def create_interface():
         )
         
         resume_btn.click(
-            fn=handle_resume,
-            inputs=[session_dropdown, language_select],
+            fn=lambda x: x.split("...")[0] if x and "..." in x else x,
+            inputs=[session_dropdown],
+            outputs=[current_session_id]
+        ).then(
+            fn=resume_session,
+            inputs=[current_session_id, language_select],
             outputs=[stages_display, novel_output, status_text, current_session_id]
         )
         
@@ -3411,7 +2790,7 @@ def create_interface():
             inputs=[language_select],
             outputs=[current_session_id, status_text]
         ).then(
-            fn=handle_resume,
+            fn=resume_session,
             inputs=[current_session_id, language_select],
             outputs=[stages_display, novel_output, status_text, current_session_id]
         )
@@ -3427,26 +2806,10 @@ def create_interface():
         )
 
         random_btn.click(
-            fn=handle_random_theme_with_save,
+            fn=lambda lang: generate_random_theme(lang),
             inputs=[language_select],
             outputs=[query_input],
             queue=False
-        ).then(
-            fn=lambda filter_lang: refresh_theme_library(filter_lang),
-            inputs=[theme_filter],
-            outputs=[theme_library_display]
-        )
-        
-        refresh_library_btn.click(
-            fn=refresh_theme_library,
-            inputs=[theme_filter],
-            outputs=[theme_library_display]
-        )
-        
-        theme_filter.change(
-            fn=refresh_theme_library,
-            inputs=[theme_filter],
-            outputs=[theme_library_display]
         )
         
         def handle_download(format_type, language, session_id, novel_text):
@@ -3465,13 +2828,10 @@ def create_interface():
             outputs=[download_file]
         )
         
-        # Load sessions and theme library on start
+        # Load sessions on start
         interface.load(
             fn=refresh_sessions,
             outputs=[session_dropdown]
-        ).then(
-            fn=lambda: refresh_theme_library("All"),
-            outputs=[theme_library_display]
         )
     
     return interface
@@ -3512,4 +2872,4 @@ if __name__ == "__main__":
       server_port=7860,
       share=False,
       debug=True
-  )    
+  )