Update app.py

app.py

@@ -1116,94 +1116,56 @@ Provide comprehensive evaluation and final improvement suggestions:
 Provide specific and actionable feedback for the director's final revision."""
     
     def create_director_final_prompt(self, all_content: str, critic_final_feedback: str, language: str = "English") -> str:
-        """Director's final compilation and polish - 모든 작가 내용 포함"""
+        """Director's final compilation - 메타데이터만 생성"""
         word_count = len(all_content.split())
-        expected_words = 14500  # 30페이지 * 500단어
         
+        # 전체 내용은 포함하지 않고 메타데이터만 요청
         if language == "Korean":
-            return f"""감독자로서 비평가의 최종 평가를 반영하여 완성본을 제작합니다.
+            return f"""감독자로서 비평가의 최종 평가를 반영하여 소설의 메타데이터를 작성합니다.
 
-전체 작가들의 작품 (30페이지 전체, {word_count}단어):
-{all_content}
+총 단어 수: {word_count}단어
 
 비평가 최종 평가:
-{critic_final_feedback}
+{critic_final_feedback[:1000]}
 
-다음을 포함한 최종 완성본을 제시하세요:
+다음 정보만 간단히 제공하세요:
 
-# [소설 제목]
-
-## 작품 정보
-- 장르: 
-- 분량: 30페이지 ({word_count}단어)
-- 주제: 
-- 한 줄 요약: 
+# 소설 정보
+- 제목: [소설 제목]
+- 장르: [장르]
+- 주제: [핵심 주제]
+- 한 줄 요약: [간단한 요약]
 
 ## 등장인물 소개
-[주요 인물들의 간단한 소개]
-
----
-
-## 본문
-
-[10명의 작가가 작성한 전체 30페이지 내용을 다음 기준으로 통합]
-1. 중대 오류 수정 완료
-2. 파트 간 연결 매끄럽게 조정
-3. 문체와 톤 통일
-4. 최종 퇴고 및 윤문
-5. 페이지 구분 표시 완전 제거
-6. 자연스러운 흐름으로 재구성
-
-[전체 30페이지 분량의 완성된 소설 본문]
-
----
+[주요 인물 3-4명의 간단한 소개 - 각 2-3줄]
 
 ## 작가의 말
-[작품에 대한 간단한 해설이나 의도]
+[작품에 대한 간단한 해설 - 5줄 이내]
 
-모든 작가의 기여를 통합한 완전한 30페이지 소설을 제시하세요."""
+주의: 본문은 작성하지 마세요. 메타데이터만 제공하세요."""
         else:
-            return f"""As director, create the final version reflecting the critic's final evaluation.
+            return f"""As director, create metadata for the final novel reflecting the critic's evaluation.
 
-Complete Writers' Work (Full 30 pages, {word_count} words):
-{all_content}
+Total word count: {word_count} words
 
 Critic's Final Evaluation:
-{critic_final_feedback}
+{critic_final_feedback[:1000]}
 
-Present the final version including:
+Provide only the following information briefly:
 
-# [Novel Title]
-
-## Work Information
-- Genre: 
-- Length: 30 pages ({word_count} words)
-- Theme: 
-- One-line summary: 
+# Novel Information
+- Title: [Novel Title]
+- Genre: [Genre]
+- Theme: [Core Theme]
+- One-line summary: [Brief summary]
 
 ## Character Introduction
-[Brief introduction of main characters]
-
----
-
-## Main Text
-
-[Integrate all 30 pages written by 10 writers with these criteria]
-1. Critical errors corrected
-2. Smooth transitions between parts
-3. Unified style and tone
-4. Final editing and polishing
-5. Complete removal of page markers
-6. Reorganized for natural flow
-
-[Complete 30-page novel text]
-
----
+[Brief introduction of 3-4 main characters - 2-3 lines each]
 
 ## Author's Note
-[Brief commentary or intention about the work]
+[Brief commentary about the work - within 5 lines]
 
-Present a complete 30-page novel integrating all writers' contributions."""
+Note: Do not write the main text. Provide metadata only."""
     
     def simulate_streaming(self, text: str, role: str) -> Generator[str, None, None]:
         """Simulate streaming in test mode"""
@@ -1725,10 +1687,19 @@ Seoyeon leaned back in her chair and closed her eyes for a moment. Fatigue penet
                     logger.error(f"Final novel too short! Only {verification['total_words']} words")
             
             # Get final novel from last stage
-            final_novel = stages[-1]["content"] if stages else ""
+            final_novel_metadata = stages[-1]["content"] if stages else ""
+            
+            # Get complete novel from DB
+            complete_novel = NovelDatabase.get_all_writer_content(self.current_session_id)
+            
+            # Combine metadata and complete content for display
+            if final_novel_metadata and complete_novel:
+                final_novel = f"{final_novel_metadata}\n\n---\n\n## Complete Novel\n\n{complete_novel}"
+            else:
+                final_novel = complete_novel or final_novel_metadata
             
             # Save final novel to DB
-            NovelDatabase.update_final_novel(self.current_session_id, final_novel)
+            NovelDatabase.update_final_novel(self.current_session_id, complete_novel)
             
             # Final yield
             yield final_novel, stages
@@ -1918,6 +1889,165 @@ def get_active_sessions(language: str) -> List[Tuple[str, str]]:
         logger.error(f"Error getting active sessions: {str(e)}", exc_info=True)
         return []
 
+def get_chapter_content(session_id: str, chapter: str) -> str:
+    """Get content of a specific chapter"""
+    if not session_id or not chapter:
+        return "No session or chapter selected"
+    
+    try:
+        chapter_num = int(chapter.split()[-1])
+        
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            # Get the writer's revision (final version)
+            cursor.execute('''
+                SELECT content, word_count, updated_at 
+                FROM stages 
+                WHERE session_id = ? 
+                AND role = ? 
+                AND stage_name LIKE '%Revision%'
+                ORDER BY stage_number DESC 
+                LIMIT 1
+            ''', (session_id, f'writer{chapter_num}'))
+            
+            row = cursor.fetchone()
+            if row and row['content']:
+                content = row['content']
+                word_count = row['word_count'] or len(content.split())
+                updated = row['updated_at']
+                
+                # 페이지 마크 제거
+                content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                
+                return f"""## Chapter {chapter_num} (Pages {(chapter_num-1)*3+1}-{chapter_num*3})
+                
+**Word Count:** {word_count:,} words  
+**Last Updated:** {updated}
+
+---
+
+{content}"""
+            else:
+                return f"Chapter {chapter_num} not found or not yet written"
+    except Exception as e:
+        logger.error(f"Error getting chapter content: {str(e)}")
+        return f"Error: {str(e)}"
+
+def get_db_sessions_detailed() -> List[Tuple[str, str]]:
+    """Get detailed list of all sessions for DB explorer"""
+    try:
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT 
+                    s.session_id, 
+                    s.user_query, 
+                    s.language, 
+                    s.created_at, 
+                    s.updated_at,
+                    s.status,
+                    s.current_stage,
+                    COUNT(st.id) as total_stages,
+                    SUM(CASE WHEN st.status = 'complete' THEN 1 ELSE 0 END) as completed_stages
+                FROM sessions s
+                LEFT JOIN stages st ON s.session_id = st.session_id
+                GROUP BY s.session_id
+                ORDER BY s.updated_at DESC
+            ''')
+            
+            sessions = cursor.fetchall()
+            
+            choices = []
+            for session in sessions:
+                created = NovelDatabase.parse_datetime(session['created_at'])
+                updated = NovelDatabase.parse_datetime(session['updated_at'])
+                query_preview = session['user_query'][:40] + "..." if len(session['user_query']) > 40 else session['user_query']
+                
+                label = (f"[{session['status'].upper()}] {query_preview} | "
+                        f"Created: {created.strftime('%Y-%m-%d %H:%M')} | "
+                        f"Progress: {session['completed_stages']}/{session['total_stages']}")
+                
+                choices.append((label, session['session_id']))
+            
+            return choices
+    except Exception as e:
+        logger.error(f"Error getting detailed sessions: {str(e)}")
+        return []
+
+def get_session_details(session_id: str) -> str:
+    """Get detailed information about a session"""
+    if not session_id:
+        return "No session selected"
+    
+    try:
+        session = NovelDatabase.get_session(session_id)
+        if not session:
+            return "Session not found"
+        
+        # Get stages information
+        stages = NovelDatabase.get_stages(session_id)
+        
+        # Calculate statistics
+        total_words = 0
+        completed_writers = 0
+        writer_stats = []
+        
+        for stage in stages:
+            if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
+                completed_writers += 1
+                word_count = stage['word_count'] or 0
+                total_words += word_count
+                writer_num = int(stage['role'].replace('writer', ''))
+                writer_stats.append(f"- Writer {writer_num}: {word_count:,} words")
+        
+        # Build detailed info
+        info = f"""# Session Details
+
+**Session ID:** `{session_id}`  
+**Theme:** {session['user_query']}  
+**Language:** {session['language']}  
+**Status:** {session['status']}  
+**Created:** {session['created_at']}  
+**Last Updated:** {session['updated_at']}  
+
+## Progress
+- **Current Stage:** {session['current_stage']}
+- **Completed Writers:** {completed_writers}/10
+- **Total Words:** {total_words:,}
+- **Estimated Pages:** ~{total_words/500:.0f}
+
+## Writer Statistics
+{"".join(writer_stats) if writer_stats else "No writers completed yet"}
+
+## Search History
+"""
+        
+        # Add search history
+        with NovelDatabase.get_db() as conn:
+            cursor = conn.cursor()
+            cursor.execute('''
+                SELECT role, query, created_at
+                FROM search_history
+                WHERE session_id = ?
+                ORDER BY created_at DESC
+                LIMIT 10
+            ''', (session_id,))
+            
+            searches = cursor.fetchall()
+            if searches:
+                info += "\nRecent searches:\n"
+                for search in searches:
+                    info += f"- [{search['role']}] {search['query']} ({search['created_at']})\n"
+            else:
+                info += "\nNo search history available."
+        
+        return info
+        
+    except Exception as e:
+        logger.error(f"Error getting session details: {str(e)}")
+        return f"Error: {str(e)}"
+
 def resume_session(session_id: str, language: str) -> Generator[Tuple[str, str, str], None, None]:
     """Resume an existing session"""
     if not session_id:
@@ -1947,155 +2077,174 @@ def auto_recover_session(language: str) -> Tuple[str, str]:
         return None, ""
 
 def download_novel(novel_text: str, format: str, language: str, session_id: str = None) -> str:
-    """Download novel in specified format - enhanced for 10 writers"""
-    if not novel_text and not session_id:
+    """Download novel - DB에서 직접 작가 내용을 가져와서 통합"""
+    if not session_id:
+        logger.error("No session_id provided for download")
         return None
     
-    # If session_id provided, get all writer content
-    if session_id:
-        all_writer_content = NovelDatabase.get_all_writer_content(session_id)
-        if all_writer_content:
-            novel_text = all_writer_content
-    
-    if not novel_text:
+    # DB에서 세션 정보 가져오기
+    session = NovelDatabase.get_session(session_id)
+    if not session:
+        logger.error(f"Session not found: {session_id}")
         return None
     
-    # 페이지 마크 제거
-    novel_text = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', novel_text)
-    novel_text = re.sub(r'(?:페이지|Page)\s*\d+:', '', novel_text)
+    # 모든 작가의 최종본 가져오기
+    all_writer_content = NovelDatabase.get_all_writer_content(session_id)
+    
+    # 최종 감독자의 메타데이터 가져오기
+    metadata = ""
+    with NovelDatabase.get_db() as conn:
+        cursor = conn.cursor()
+        cursor.execute('''
+            SELECT content FROM stages 
+            WHERE session_id = ? AND role = 'director' AND stage_name LIKE '%Final%'
+            ORDER BY stage_number DESC LIMIT 1
+        ''', (session_id,))
+        row = cursor.fetchone()
+        if row and row['content']:
+            metadata = row['content']
     
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    word_count = len(novel_text.split())
-    char_count = len(novel_text)
     
-    logger.info(f"Exporting novel: {word_count} words, {char_count} characters")
+    # 통계 정보
+    word_count = len(all_writer_content.split())
+    char_count = len(all_writer_content)
+    
+    logger.info(f"Exporting novel: {word_count} words, {char_count} characters from DB")
     
     if format == "DOCX" and DOCX_AVAILABLE:
         # Create DOCX
         doc = Document()
         
-        # Title page
-        title_para = doc.add_paragraph()
-        title_run = title_para.add_run('AI Collaborative Novel')
-        title_run.font.size = Pt(24)
-        title_run.font.bold = True
-        title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        
-        doc.add_paragraph()
-        
-        # 문서 정보 추가
-        info_para = doc.add_paragraph()
-        info_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        info_run = info_para.add_run(f'10 Writers Collaboration\n')
-        info_run.font.size = Pt(14)
-        
-        stats_para = doc.add_paragraph()
-        stats_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
-        stats_run = stats_para.add_run(
-            f'Total words: {word_count:,}\n'
-            f'Total pages: ~{word_count/500:.0f}\n'
-            f'Export date: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}'
-        )
-        stats_run.font.size = Pt(12)
-        
+        # 메타데이터 추가 (있는 경우)
+        if metadata:
+            # 메타데이터 파싱 및 추가
+            lines = metadata.split('\n')
+            for line in lines:
+                if line.startswith('#'):
+                    level = len(line.split()[0].strip('#'))
+                    text = line.lstrip('#').strip()
+                    if text and level <= 2:  # 제목과 주요 섹션만
+                        doc.add_heading(text, level)
+                elif line.strip() and not line.startswith('['):
+                    doc.add_paragraph(line)
+            
+            doc.add_page_break()
+        else:
+            # 기본 제목
+            title_para = doc.add_paragraph()
+            title_run = title_para.add_run('AI Collaborative Novel')
+            title_run.font.size = Pt(24)
+            title_run.font.bold = True
+            title_para.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            doc.add_page_break()
+        
+        # 통계 페이지
+        doc.add_heading('Novel Statistics', 1)
+        doc.add_paragraph(f'Total Writers: 10')
+        doc.add_paragraph(f'Total Words: {word_count:,}')
+        doc.add_paragraph(f'Total Pages: ~{word_count/500:.0f}')
+        doc.add_paragraph(f'Export Date: {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}')
+        doc.add_paragraph(f'Session ID: {session_id[:8]}...')
         doc.add_page_break()
         
-        # Table of Contents
+        # 목차
         doc.add_heading('Table of Contents', 1)
         for i in range(1, 11):
-            doc.add_paragraph(f'Writer {i}: Pages {(i-1)*3+1}-{i*3}')
-        
+            doc.add_paragraph(f'Chapter {i}: Pages {(i-1)*3+1}-{i*3}')
         doc.add_page_break()
         
-        # Parse and add content with writer sections
-        if session_id:
-            # Get individual writer contents from DB
-            stages = NovelDatabase.get_stages(session_id)
-            writer_num = 0
-            
-            for stage in stages:
-                if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
-                    writer_num += 1
-                    # Add writer header
-                    doc.add_heading(f'Writer {writer_num}', 1)
-                    doc.add_paragraph(f'Pages {(writer_num-1)*3+1}-{writer_num*3}')
-                    doc.add_paragraph()
-                    
-                    # Add writer content
-                    content = stage['content'] or ""
-                    paragraphs = content.split('\n\n')
-                    for para_text in paragraphs:
-                        if para_text.strip():
-                            para = doc.add_paragraph(para_text)
-                            para.style.font.size = Pt(11)
-                    
-                    if writer_num < 10:  # Don't add page break after last writer
-                        doc.add_page_break()
-        else:
-            # If no session_id, add content as is
-            lines = novel_text.split('\n')
-            for line in lines:
-                if line.startswith('#'):
-                    level = min(len(line.split()[0].strip('#')), 9)
-                    text = line.lstrip('#').strip()
-                    if text:
-                        doc.add_heading(text, level)
-                elif line.strip():
-                    para = doc.add_paragraph(line)
-                    if hasattr(para.style, 'font'):
+        # 각 작가의 최종본 추가
+        stages = NovelDatabase.get_stages(session_id)
+        writer_num = 0
+        
+        for stage in stages:
+            if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
+                writer_num += 1
+                
+                # 챕터 헤더
+                doc.add_heading(f'Chapter {writer_num}', 1)
+                doc.add_paragraph(f'Pages {(writer_num-1)*3+1}-{writer_num*3}')
+                doc.add_paragraph(f'Word Count: {stage["word_count"] or "N/A"}')
+                doc.add_paragraph()
+                
+                # 작가 내용
+                content = stage['content'] or ""
+                # 페이지 마크 제거
+                content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                
+                paragraphs = content.split('\n\n')
+                for para_text in paragraphs:
+                    if para_text.strip():
+                        para = doc.add_paragraph(para_text)
                         para.style.font.size = Pt(11)
+                
+                if writer_num < 10:  # 마지막 작가 후에는 페이지 구분 없음
+                    doc.add_page_break()
         
         # 페이지 설정
-        section = doc.sections[0]
-        section.page_height = Inches(11)
-        section.page_width = Inches(8.5)
-        section.left_margin = Inches(1)
-        section.right_margin = Inches(1)
-        section.top_margin = Inches(1)
-        section.bottom_margin = Inches(1)
+        for section in doc.sections:
+            section.page_height = Inches(11)
+            section.page_width = Inches(8.5)
+            section.left_margin = Inches(1)
+            section.right_margin = Inches(1)
+            section.top_margin = Inches(1)
+            section.bottom_margin = Inches(1)
         
         # Save
         temp_dir = tempfile.gettempdir()
-        filename = f"Novel_10Writers_{timestamp}_{word_count}words.docx"
+        filename = f"Novel_Complete_{session['user_query'][:20].replace(' ', '_')}_{timestamp}.docx"
         filepath = os.path.join(temp_dir, filename)
         doc.save(filepath)
         
-        logger.info(f"DOCX saved: {filepath}")
+        logger.info(f"DOCX saved successfully: {filepath}")
         return filepath
     else:
         # TXT format
         temp_dir = tempfile.gettempdir()
-        filename = f"Novel_10Writers_{timestamp}_{word_count}words.txt"
+        filename = f"Novel_Complete_{session['user_query'][:20].replace(' ', '_')}_{timestamp}.txt"
         filepath = os.path.join(temp_dir, filename)
         
-        # 파일 시작 부분에 정보 추가
         with open(filepath, 'w', encoding='utf-8') as f:
             f.write("="*60 + "\n")
-            f.write("AI COLLABORATIVE NOVEL - 10 WRITERS\n")
+            f.write("AI COLLABORATIVE NOVEL - COMPLETE VERSION\n")
             f.write("="*60 + "\n")
-            f.write(f"Total words: {word_count:,}\n")
-            f.write(f"Total characters: {char_count:,}\n")
-            f.write(f"Estimated pages: {word_count/500:.1f}\n")
-            f.write(f"Export date: {datetime.now()}\n")
+            f.write(f"Theme: {session['user_query']}\n")
+            f.write(f"Total Writers: 10\n")
+            f.write(f"Total Words: {word_count:,}\n")
+            f.write(f"Total Pages: ~{word_count/500:.0f}\n")
+            f.write(f"Export Date: {datetime.now()}\n")
+            f.write(f"Session ID: {session_id}\n")
             f.write("="*60 + "\n\n")
             
-            if session_id:
-                # Get individual writer contents
-                stages = NovelDatabase.get_stages(session_id)
-                writer_num = 0
-                
-                for stage in stages:
-                    if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
-                        writer_num += 1
-                        f.write(f"\n{'='*40}\n")
-                        f.write(f"WRITER {writer_num} (Pages {(writer_num-1)*3+1}-{writer_num*3})\n")
-                        f.write(f"{'='*40}\n\n")
-                        f.write(stage['content'] or "")
-                        f.write("\n\n")
-            else:
-                f.write(novel_text)
+            # 메타데이터 추가
+            if metadata:
+                f.write("=== METADATA ===\n")
+                f.write(metadata)
+                f.write("\n\n" + "="*60 + "\n\n")
+            
+            # 각 작가의 최종본
+            stages = NovelDatabase.get_stages(session_id)
+            writer_num = 0
+            
+            for stage in stages:
+                if stage['role'].startswith('writer') and 'Revision' in stage['stage_name']:
+                    writer_num += 1
+                    f.write(f"\n{'='*40}\n")
+                    f.write(f"CHAPTER {writer_num} (Pages {(writer_num-1)*3+1}-{writer_num*3})\n")
+                    f.write(f"Word Count: {stage['word_count'] or 'N/A'}\n")
+                    f.write(f"{'='*40}\n\n")
+                    
+                    content = stage['content'] or ""
+                    # 페이지 마크 제거
+                    content = re.sub(r'\[(?:페이지|Page|page)\s*\d+\]', '', content)
+                    content = re.sub(r'(?:페이지|Page)\s*\d+:', '', content)
+                    
+                    f.write(content)
+                    f.write("\n\n")
         
-        logger.info(f"TXT saved: {filepath}")
+        logger.info(f"TXT saved successfully: {filepath}")
         return filepath
 
 # Custom CSS
@@ -2149,6 +2298,17 @@ custom_css = """
     overflow-y: auto;
 }
 
+#chapter-content {
+    background-color: rgba(255, 255, 255, 0.95);
+    padding: 30px;
+    border-radius: 12px;
+    box-shadow: 0 8px 32px rgba(0, 0, 0, 0.1);
+    max-height: 800px;
+    overflow-y: auto;
+    font-family: Georgia, serif;
+    line-height: 1.8;
+}
+
 .download-section {
     background-color: rgba(255, 255, 255, 0.9);
     padding: 15px;
@@ -2262,6 +2422,36 @@ def create_interface():
                         label="Downloaded File / 다운로드된 파일",
                         visible=False
                     )
+            
+            with gr.Tab("📑 Chapter View / 챕터별 보기"):
+                chapter_select = gr.Dropdown(
+                    label="Select Chapter / 챕터 선택",
+                    choices=[f"Chapter {i}" for i in range(1, 11)],
+                    value="Chapter 1"
+                )
+                chapter_content = gr.Markdown(
+                    value="Select a chapter to view its content / 챕터를 선택하여 내용을 확인하세요",
+                    elem_id="chapter-content"
+                )
+                
+            with gr.Tab("🔍 Database Explorer / DB 탐색"):
+                with gr.Row():
+                    db_session_select = gr.Dropdown(
+                        label="Select Session / 세션 선택",
+                        choices=[],
+                        interactive=True
+                    )
+                    db_refresh_btn = gr.Button("🔄 Refresh / 새로고침")
+                
+                db_info = gr.Markdown(
+                    value="Select a session to view details / 세���을 선택하여 상세 정보를 확인하세요"
+                )
+                
+                db_export_btn = gr.Button("📤 Export Selected Session / 선택된 세션 내보내기", visible=False)
+                db_export_file = gr.File(
+                    label="Exported File / 내보낸 파일",
+                    visible=False
+                )
         
         # Hidden state for novel text
         novel_text_state = gr.State("")
@@ -2294,13 +2484,37 @@ def create_interface():
             session_id, message = auto_recover_session(language)
             return session_id
         
+        def update_chapter_content(chapter, session_id):
+            if session_id:
+                return get_chapter_content(session_id, chapter)
+            else:
+                return "Please complete or select a session first / 먼저 세션을 완료하거나 선택하세요"
+        
+        def refresh_db_sessions():
+            sessions = get_db_sessions_detailed()
+            return gr.update(choices=sessions)
+        
+        def show_session_details(session_id):
+            if session_id:
+                return get_session_details(session_id), gr.update(visible=True)
+            else:
+                return "Select a session to view details", gr.update(visible=False)
+        
+        def export_db_session(session_id, format_type):
+            if session_id:
+                file_path = download_novel("", format_type, "English", session_id)
+                if file_path:
+                    return gr.update(value=file_path, visible=True)
+            return gr.update(visible=False)
+        
+        # Connect event handlers
         submit_btn.click(
             fn=process_query,
             inputs=[query_input, language_select, current_session_id],
             outputs=[stages_display, novel_output, status_text]
         )
         
-        # Update novel text state when novel output changes
+        # Update novel text state and chapter dropdown when novel output changes
         novel_output.change(
             fn=lambda x: x,
             inputs=[novel_output],
@@ -2338,7 +2552,7 @@ def create_interface():
         )
         
         def handle_download(format_type, language, session_id, novel_text):
-            if not novel_text and not session_id:
+            if not session_id:
                 return gr.update(visible=False)
             
             file_path = download_novel(novel_text, format_type, language, session_id)
@@ -2353,10 +2567,47 @@ def create_interface():
             outputs=[download_file]
         )
         
+        # Chapter view handlers
+        chapter_select.change(
+            fn=update_chapter_content,
+            inputs=[chapter_select, current_session_id],
+            outputs=[chapter_content]
+        )
+        
+        # Update chapter content when session changes
+        current_session_id.change(
+            fn=update_chapter_content,
+            inputs=[chapter_select, current_session_id],
+            outputs=[chapter_content]
+        )
+        
+        # DB Explorer handlers
+        db_refresh_btn.click(
+            fn=refresh_db_sessions,
+            outputs=[db_session_select]
+        )
+        
+        db_session_select.change(
+            fn=show_session_details,
+            inputs=[db_session_select],
+            outputs=[db_info, db_export_btn]
+        )
+        
+        db_export_btn.click(
+            fn=lambda session_id: export_db_session(session_id, "DOCX"),
+            inputs=[db_session_select],
+            outputs=[db_export_file]
+        )
+        
         # Load sessions on startup
+        def on_load():
+            sessions = refresh_sessions()
+            db_sessions = refresh_db_sessions()
+            return sessions, db_sessions
+        
         interface.load(
-            fn=refresh_sessions,
-            outputs=[session_dropdown]
+            fn=on_load,
+            outputs=[session_dropdown, db_session_select]
         )
     
     return interface