Update app.py

app.py

@@ -1,414 +1,351 @@
 # File: app.py
-# Location: /app.py (root directory for Hugging Face Spaces)
-# Description: Main Streamlit application for AI Book Writing Assistant
 
 import streamlit as st
-import os
 import json
-import uuid
-
-from multi_agent_book_workflow import BookWritingOrchestrator
-from persistence_manager import ProjectPersistenceManager
+import os
+from selfapi_writer import SelfApiWriter
+from data_manager import DataManager
 
-class BookWritingApp:
+class SelfApiApp:
     def __init__(self):
-        """
-        Initialize the Streamlit application for book writing
-        
-        Manages session state and persistence
-        """
-        # Set page configuration
+        """Initialize the Streamlit application"""
         st.set_page_config(
-            page_title="AI Book Writing Assistant",
-            page_icon="📖",
+            page_title="Self.api Book Generator",
+            page_icon="📚",
             layout="wide"
         )
         
-        # Initialize persistence manager
-        self.persistence_manager = ProjectPersistenceManager()
+        # Initialize data manager
+        self.data_manager = DataManager()
         
         # Initialize session state
         self._initialize_session_state()
-        
-        # Set up project orchestrator 
-        self._setup_project_orchestrator()
-    
-    def _setup_project_orchestrator(self):
-        """
-        Initialize project orchestrator with proper error handling
-        """
-        try:
-            if 'project_orchestrator' not in st.session_state or st.session_state.project_orchestrator is None:
-                st.session_state.project_orchestrator = BookWritingOrchestrator()
-        except ValueError as ve:
-            st.error(f"API Key Error: {str(ve)}")
-            st.info("Please ensure your API keys are properly set in the environment variables.")
-            st.session_state.project_orchestrator = None
-        except Exception as e:
-            st.error(f"Error setting up project orchestrator: {e}")
-            st.session_state.project_orchestrator = None
-    
+
     def _initialize_session_state(self):
-        """
-        Initialize and manage Streamlit session state
-        """
-        # Project tracking
-        if 'active_project_id' not in st.session_state:
-            st.session_state.active_project_id = None
-        
-        # Restore last active project if exists
-        if st.session_state.active_project_id:
-            self._load_project(st.session_state.active_project_id)
-        
-        # Ensure core session state variables exist
-        session_defaults = {
-            'project_orchestrator': None,
-            'book_concept': None,
-            'generated_chapters': {},
-            'total_chapters': 10,  # Default value
-            'project_metadata': {
-                'title': 'Untitled Project',
-                'genre': 'Unspecified',
-                'total_chapters': 10
+        """Initialize session state variables"""
+        if 'current_tab' not in st.session_state:
+            st.session_state.current_tab = 'Blueprint'
+            
+        if 'blueprint' not in st.session_state:
+            st.session_state.blueprint = self.default_blueprint
+            
+        if 'book_content' not in st.session_state:
+            st.session_state.book_content = {
+                "introduction": "",
+                "parts": []
             }
-        }
-        
-        for key, default in session_defaults.items():
-            if key not in st.session_state:
-                st.session_state[key] = default
-    
-    def _load_project(self, project_id):
-        """
-        Load a project from persistent storage
-        """
+
+    @property
+    def default_blueprint(self):
+        """Get default blueprint content"""
+        return """# Editorial Blueprint: Self.api - A Modern Spiritual Operating System
+
+## Core Editorial Vision
+Transform "Self.api" from a conceptual framework into a revolutionary guide that speaks to the modern seeker - the stressed executive who downloads meditation apps but can't stick to them, the engineering lead who understands distributed systems better than their own emotions, and the consultant who can optimize anything except their own life satisfaction.
+
+### Target Reader Profile
+- Primary: Tech professionals, entrepreneurs, and knowledge workers (25-45)
+- Secondary: Anyone feeling disconnected in our hyper-connected world
+- Psychographic: Analytical minds seeking spiritual depth without the woo-woo
+
+## Book Structure
+### Introduction: "System Requirements: A Human's Guide to Being Human"
+- Opening hook: "In a world where we can Google anything except our own purpose..."
+- Key narrative: Author's journey from debugging code to debugging consciousness
+
+### Part 1: The Human Input/Output System
+- Rate Limiting Your Reality
+- Debugging Your Attention Span
+- The Mindfulness Microservice
+
+### Part 2: Your Internal Neural Network
+- Training Your Gut Algorithm
+- The Wisdom Cache
+- Pattern Recognition Beyond Logic
+
+### Part 3: The Source Code of Being
+- Quantum Mechanics of Consciousness
+- The Purpose Protocol
+- Refactoring Your Reality
+
+### Part 4: The Universal Runtime Environment
+- Distributed Consciousness Systems
+- The Empathy Protocol
+- Scaling Your Impact
+
+## Style Guidelines
+1. Technical Authenticity
+   - Use API and tech metaphors naturally
+   - Example: "Think of meditation as a daily health check for your consciousness microservices"
+
+2. Voice & Tone
+   - Witty But Wise
+   - Blend humor with depth
+   - Style: Think Douglas Adams meets Deepak Chopra
+
+3. Chapter Structure
+   - System Log (personal story)
+   - Documentation (teaching)
+   - Implementation Guide (practical steps)
+
+## Content Requirements
+1. Each chapter should have:
+   - 3 "aha" moments
+   - 2-3 quotable passages
+   - Practical exercises every 5 pages
+   - Balance: 60% practical, 40% philosophical
+   - Links to both ancient wisdom and modern science"""
+
+    def save_current_state(self):
+        """Save current state to data directory"""
         try:
-            loaded_project = self.persistence_manager.load_project(project_id)
+            # Save blueprint if it exists
+            if st.session_state.blueprint:
+                blueprint_file = self.data_manager.save_blueprint(st.session_state.blueprint)
+                st.success(f"Blueprint saved: {blueprint_file}")
             
-            if loaded_project:
-                # Update session state with loaded project
-                st.session_state.active_project_id = project_id
-                st.session_state.book_concept = loaded_project.get('book_concept')
-                st.session_state.generated_chapters = loaded_project.get('chapters', {})
-                st.session_state.total_chapters = loaded_project.get('total_chapters', 10)
-                st.session_state.project_metadata = {
-                    'title': loaded_project.get('title', 'Untitled Project'),
-                    'genre': loaded_project.get('genre', 'Unspecified'),
-                    'total_chapters': loaded_project.get('total_chapters', 10)
-                }
-                
-                st.success(f"Loaded project: {loaded_project.get('title', 'Untitled')}")
-            else:
-                st.warning("Could not load project.")
-        
-        except Exception as e:
-            st.error(f"Error loading project: {e}")
-    
-    def _save_current_project(self):
-        """
-        Save the current project to persistent storage
-        """
-        try:
-            # Prepare project data for saving
-            project_data = {
-                'project_id': st.session_state.active_project_id or str(uuid.uuid4()),
-                'title': st.session_state.project_metadata.get('title', 'Untitled Project'),
-                'genre': st.session_state.project_metadata.get('genre', 'Unspecified'),
-                'book_concept': st.session_state.book_concept,
-                'chapters': st.session_state.generated_chapters,
-                'total_chapters': st.session_state.total_chapters
-            }
+            # Save book content if it exists
+            if st.session_state.book_content:
+                content_file = self.data_manager.save_book_content(st.session_state.book_content)
+                st.success(f"Book content saved: {content_file}")
             
-            # Save project
-            project_id = self.persistence_manager.save_project(project_data)
+            # Save individual chapters
+            for part_idx, part in enumerate(st.session_state.book_content.get('parts', [])):
+                for ch_idx, chapter in enumerate(part.get('chapters', [])):
+                    if chapter.get('content'):
+                        self.data_manager.save_chapter(part_idx, ch_idx, chapter)
             
-            if project_id:
-                # Update active project ID
-                st.session_state.active_project_id = project_id
-                st.success(f"Project saved successfully!")
-            else:
-                st.error("Failed to save project.")
-        
         except Exception as e:
-            st.error(f"Error saving project: {e}")
-    
-    def render_project_management(self):
-        """
-        Render project management interface
-        """
-        st.sidebar.header("Project Management")
-        
-        # New Project Button
-        if st.sidebar.button("Start New Project"):
-            # Reset session state
-            st.session_state.active_project_id = None
-            st.session_state.book_concept = None
-            st.session_state.generated_chapters = {}
-            st.session_state.total_chapters = 10
-            st.session_state.project_metadata = {
-                'title': 'Untitled Project',
-                'genre': 'Unspecified',
-                'total_chapters': 10
-            }
-            st.experimental_rerun()
-        
-        # Load Project
-        project_list = self.persistence_manager.list_projects()
-        if project_list:
-            selected_project = st.sidebar.selectbox(
-                "Load Existing Project",
-                options=[p['title'] for p in project_list],
-                index=None,
-                placeholder="Select a project..."
-            )
+            st.error(f"Error saving state: {e}")
+
+    def load_latest_state(self):
+        """Load latest state from data directory"""
+        try:
+            # Load latest blueprint
+            blueprint = self.data_manager.load_latest_blueprint()
+            if blueprint:
+                st.session_state.blueprint = blueprint
             
-            if selected_project:
-                # Find project ID
-                project_id = next(
-                    (p['project_id'] for p in project_list if p['title'] == selected_project),
-                    None
-                )
+            # Load latest book content
+            content = self.data_manager.load_latest_book_content()
+            if content:
+                st.session_state.book_content = content
                 
-                if project_id and st.sidebar.button("Load Selected Project"):
-                    self._load_project(project_id)
-        
-        # Save Current Project
-        if st.sidebar.button("Save Current Project"):
-            self._save_current_project()
-    
-    def render_book_generation_interface(self):
-        """
-        Render the main book generation interface
-        """
-        # Tabs for different stages of book writing
-        tab1, tab2, tab3 = st.tabs([
-            "Book Concept", 
-            "Chapter Generation", 
-            "Project Progress"
-        ])
-        
-        with tab1:
-            self._render_concept_development()
-        
-        with tab2:
-            self._render_chapter_generation()
-        
-        with tab3:
-            self._render_project_progress()
-    
-    def _render_concept_development(self):
-        """
-        Render the book concept development interface
-        """
-        st.header("📘 Book Concept Development")
-        
-        # Initial concept input
-        initial_concept = st.text_area(
-            "Describe Your Book Idea", 
-            height=200, 
-            placeholder="Enter a comprehensive description of your book concept..."
-        )
-        
-        if st.button("Generate Book Concept"):
-            if st.session_state.project_orchestrator is None:
-                st.error("Project orchestrator is not properly initialized. Please check your API keys.")
-                return
+            st.success("Latest state loaded successfully!")
+            
+        except Exception as e:
+            st.error(f"Error loading state: {e}")
+
+    def export_book(self):
+        """Export book in markdown format"""
+        try:
+            # Export as markdown
+            if st.session_state.book_content:
+                filepath = self.data_manager.export_markdown(st.session_state.book_content)
+                st.success(f"Book exported to: {filepath}")
                 
-            with st.spinner("Developing Book Concept..."):
-                try:
-                    # Generate book concept using multi-agent approach
-                    book_concept = st.session_state.project_orchestrator.generate_book_concept(
-                        initial_concept
-                    )
-                    
-                    if book_concept:
-                        # Update session state
-                        st.session_state.book_concept = book_concept
-                        st.session_state.project_metadata.update({
-                            'title': book_concept.get('title', 'Untitled Project'),
-                            'genre': book_concept.get('genre', 'Unspecified')
-                        })
-                        
-                        # Display generated concept
-                        st.subheader("Generated Book Concept")
-                        st.json(book_concept)
-                    else:
-                        st.error("Failed to generate book concept.")
+                # Create download link
+                with open(filepath, 'r') as f:
+                    markdown_content = f.read()
                 
-                except Exception as e:
-                    st.error(f"Error generating book concept: {e}")
-    
-    def _render_chapter_generation(self):
-        """
-        Render the chapter generation interface
-        """
-        st.header("✍️ Chapter Generation")
-        
-        # Check if book concept exists
-        if not st.session_state.book_concept:
-            st.warning("Please generate a book concept first.")
-            return
+                st.download_button(
+                    label="Download Markdown",
+                    data=markdown_content,
+                    file_name="self_api_book.md",
+                    mime="text/markdown"
+                )
+        except Exception as e:
+            st.error(f"Error exporting book: {e}")
+
+    def render_blueprint_editor(self):
+        """Render the blueprint editor interface"""
+        st.header("�� Editorial Blueprint Editor")
         
-        # Chapter generation controls
-        col1, col2 = st.columns(2)
+        col1, col2 = st.columns([7, 3])
         
         with col1:
-            # Chapter number selection
-            max_chapters = 20  # Can be adjusted
-            current_chapter = len(st.session_state.generated_chapters) + 1
-            chapter_number = st.number_input(
-                "Select Chapter to Generate", 
-                min_value=1, 
-                max_value=max_chapters, 
-                value=min(current_chapter, max_chapters)
+            # Blueprint Editor
+            edited_blueprint = st.text_area(
+                "Edit Blueprint",
+                value=st.session_state.blueprint,
+                height=600
             )
+            
+            if edited_blueprint != st.session_state.blueprint:
+                st.session_state.blueprint = edited_blueprint
         
         with col2:
-            # Total chapters planning
-            total_chapters = st.number_input(
-                "Total Planned Chapters", 
-                min_value=1, 
-                max_value=max_chapters, 
-                value=st.session_state.total_chapters
-            )
+            st.subheader("Blueprint Controls")
             
-            # Update session state
-            if total_chapters != st.session_state.total_chapters:
-                st.session_state.total_chapters = total_chapters
-                st.session_state.project_metadata['total_chapters'] = total_chapters
-        
-        # Generate Chapter Button
-        if st.button("Generate Chapter"):
-            if st.session_state.project_orchestrator is None:
-                st.error("Project orchestrator is not properly initialized. Please check your API keys.")
-                return
-                
-            with st.spinner(f"Generating Chapter {chapter_number}..."):
+            # Reset Blueprint
+            if st.button("Reset to Default"):
+                st.session_state.blueprint = self.default_blueprint
+                st.experimental_rerun()
+            
+            # Save Blueprint
+            if st.button("Save Blueprint"):
                 try:
-                    # Generate chapter content
-                    chapter_content = st.session_state.project_orchestrator.generate_chapter_content(
-                        st.session_state.book_concept, 
-                        chapter_number
-                    )
-                    
-                    if chapter_content:
-                        # Store generated chapter
-                        st.session_state.generated_chapters[chapter_number] = {
-                            'content': chapter_content,
-                            'status': 'Generated'
-                        }
-                        
-                        # Display Chapter Content
-                        st.subheader(f"Chapter {chapter_number}")
-                        st.write(chapter_content)
-                        
-                        # Create a unique key for the text area
-                        edit_key = f"edit_chapter_{chapter_number}"
-                        
-                        # Optional: Edit Chapter
-                        edited_content = st.text_area(
-                            "Edit Chapter Content", 
-                            value=chapter_content, 
-                            height=400,
-                            key=edit_key
-                        )
-                        
-                        # Save button with unique key
-                        save_key = f"save_chapter_{chapter_number}"
-                        if st.button(f"Save Chapter {chapter_number}", key=save_key):
-                            st.session_state.generated_chapters[chapter_number]['content'] = edited_content
-                            st.success(f"Chapter {chapter_number} saved!")
-                    else:
-                        st.error("Failed to generate chapter content.")
-                
+                    filename = self.data_manager.save_blueprint(st.session_state.blueprint)
+                    st.success(f"Blueprint saved as: {filename}")
                 except Exception as e:
-                    st.error(f"Error generating chapter: {e}")
-    
-    def _render_project_progress(self):
-        """
-        Render project progress and tracking interface
-        """
-        st.header("📊 Project Progress")
+                    st.error(f"Error saving blueprint: {e}")
+            
+            # Load Blueprint
+            if st.button("Load Latest"):
+                try:
+                    blueprint = self.data_manager.load_latest_blueprint()
+                    if blueprint:
+                        st.session_state.blueprint = blueprint
+                        st.success("Latest blueprint loaded!")
+                        st.experimental_rerun()
+                except Exception as e:
+                    st.error(f"Error loading blueprint: {e}")
+
+    def render_generator_interface(self):
+        """Render the book generation interface"""
+        st.header("⚙️ Content Generator")
         
-        # Project Metadata Overview
-        st.subheader("Project Overview")
-        col1, col2 = st.columns(2)
+        # Initialize writer if needed
+        if 'writer' not in st.session_state:
+            st.session_state.writer = SelfApiWriter()
         
-        with col1:
-            st.metric("Book Title", st.session_state.project_metadata.get('title', 'Untitled'))
-            st.metric("Genre", st.session_state.project_metadata.get('genre', 'Unspecified'))
+        # Generation controls
+        col1, col2 = st.columns([2, 1])
         
-        with col2:
-            total_chapters = st.session_state.total_chapters
-            generated_chapters = len(st.session_state.generated_chapters)
+        with col1:
+            st.subheader("Generation Controls")
             
-            st.metric("Total Planned Chapters", total_chapters)
-            st.metric("Chapters Generated", generated_chapters)
+            # Introduction Generation
+            intro_col1, intro_col2 = st.columns([3, 1])
+            with intro_col1:
+                st.markdown("### Introduction")
+            with intro_col2:
+                if st.button("Generate Introduction"):
+                    with st.spinner("Generating introduction..."):
+                        intro_content = st.session_state.writer.write_introduction()
+                        st.session_state.book_content["introduction"] = intro_content
+                        self.save_current_state()
+                        st.success("Introduction generated!")
             
-            # Progress Bar
-            progress = generated_chapters / total_chapters if total_chapters > 0 else 0
-            st.progress(progress)
-        
-        # Chapter Navigation and Details
-        st.subheader("Generated Chapters")
+            # Parts and Chapters Generation
+            for part_idx, part in enumerate(st.session_state.writer.book_structure["parts"]):
+                st.markdown(f"### Part {part_idx + 1}: {part['title']}")
+                
+                for ch_idx, ch_title in enumerate(part["chapters"]):
+                    ch_col1, ch_col2 = st.columns([3, 1])
+                    with ch_col1:
+                        st.markdown(f"- {ch_title}")
+                    with ch_col2:
+                        if st.button(f"Generate", key=f"gen_{part_idx}_{ch_idx}"):
+                            with st.spinner(f"Generating {ch_title}..."):
+                                chapter_content = st.session_state.writer.write_chapter(part_idx, ch_idx)
+                                
+                                # Ensure part exists
+                                while len(st.session_state.book_content["parts"]) <= part_idx:
+                                    st.session_state.book_content["parts"].append({
+                                        "title": part["title"],
+                                        "chapters": []
+                                    })
+                                
+                                # Ensure chapter exists
+                                while len(st.session_state.book_content["parts"][part_idx]["chapters"]) <= ch_idx:
+                                    st.session_state.book_content["parts"][part_idx]["chapters"].append({
+                                        "title": "",
+                                        "content": ""
+                                    })
+                                
+                                # Update chapter
+                                st.session_state.book_content["parts"][part_idx]["chapters"][ch_idx] = {
+                                    "title": ch_title,
+                                    "content": chapter_content
+                                }
+                                self.save_current_state()
+                                st.success(f"{ch_title} generated!")
         
-        # Create tabs for each generated chapter
-        if st.session_state.generated_chapters:
-            chapter_tabs = st.tabs([
-                f"Chapter {ch_num}" for ch_num in sorted(st.session_state.generated_chapters.keys())
-            ])
+        with col2:
+            st.subheader("Quick Actions")
             
-            for i, ch_num in enumerate(sorted(st.session_state.generated_chapters.keys())):
-                with chapter_tabs[i]:
-                    chapter_data = st.session_state.generated_chapters[ch_num]
-                    st.write(chapter_data['content'])
+            if st.button("Generate All"):
+                with st.spinner("Generating entire book..."):
+                    # Generate introduction
+                    intro_content = st.session_state.writer.write_introduction()
+                    st.session_state.book_content["introduction"] = intro_content
                     
-                    # Chapter status and actions
-                    col1, col2 = st.columns(2)
-                    with col1:
-                        status = st.selectbox(
-                            "Chapter Status", 
-                            ["Generated", "In Review", "Completed"],
-                            key=f"status_{ch_num}"
-                        )
-                        if status != chapter_data['status']:
-                            chapter_data['status'] = status
+                    # Generate all chapters
+                    for part_idx, part in enumerate(st.session_state.writer.book_structure["parts"]):
+                        # Initialize part
+                        if len(st.session_state.book_content["parts"]) <= part_idx:
+                            st.session_state.book_content["parts"].append({
+                                "title": part["title"],
+                                "chapters": []
+                            })
+                        
+                        for ch_idx, ch_title in enumerate(part["chapters"]):
+                            chapter_content = st.session_state.writer.write_chapter(part_idx, ch_idx)
+                            
+                            # Ensure chapter exists
+                            while len(st.session_state.book_content["parts"][part_idx]["chapters"]) <= ch_idx:
+                                st.session_state.book_content["parts"][part_idx]["chapters"].append({
+                                    "title": "",
+                                    "content": ""
+                                })
+                            
+                            # Update chapter
+                            st.session_state.book_content["parts"][part_idx]["chapters"][ch_idx] = {
+                                "title": ch_title,
+                                "content": chapter_content
+                            }
                     
-                    with col2:
-                        if st.button(f"Export Chapter {ch_num}", key=f"export_{ch_num}"):
-                            try:
-                                # Export chapter functionality
-                                export_path = os.path.join('data', f"chapter_{ch_num}.txt")
-                                os.makedirs('data', exist_ok=True)
-                                with open(export_path, "w") as f:
-                                    f.write(chapter_data['content'])
-                                st.success(f"Chapter {ch_num} exported to {export_path}")
-                            except Exception as e:
-                                st.error(f"Error exporting chapter: {e}")
+                    self.save_current_state()
+                    st.success("Full book generated!")
+
+    def render_content_preview(self):
+        """Render the book content preview"""
+        st.header("📚 Generated Content Preview")
+        
+        # Display any generated content here
+        if not st.session_state.book_content["introduction"] and not st.session_state.book_content["parts"]:
+            st.info("No content generated yet. Use the Generator tab to create content.")
         else:
-            st.info("No chapters generated yet. Start writing your book!")
-    
+            # Add export button
+            if st.button("Export Current Content"):
+                self.export_book()
+            
+            # Show introduction if it exists
+            if st.session_state.book_content["introduction"]:
+                st.subheader("Introduction")
+                with st.expander("View Introduction", expanded=True):
+                    st.markdown(st.session_state.book_content["introduction"])
+            
+            # Show generated parts and chapters
+            for part_idx, part in enumerate(st.session_state.book_content["parts"]):
+                st.subheader(f"Part {part_idx + 1}: {part['title']}")
+                for chapter in part["chapters"]:
+                    if chapter["content"]:
+                        with st.expander(f"Chapter: {chapter['title']}", expanded=False):
+                            st.markdown(chapter["content"])
+
     def run(self):
-        """
-        Run the main Streamlit application
-        """
-        # Render project management sidebar
-        self.render_project_management()
+        """Run the Streamlit application"""
+        st.title("🚀 Self.api Book Generator")
         
-        # Main title
-        st.title("🚀 AI-Powered Book Writing Assistant")
+        # Main navigation
+        tabs = ["Blueprint", "Generator", "Preview"]
+        selected_tab = st.radio("Navigation", tabs, horizontal=True)
+        st.session_state.current_tab = selected_tab
         
-        # Check if project orchestrator is initialized
-        if st.session_state.project_orchestrator is None:
-            st.warning("Please ensure your API keys are properly set in the environment variables.")
+        st.divider()
         
-        # Render the main interface
-        self.render_book_generation_interface()
+        # Render appropriate content based on selected tab
+        if selected_tab == "Blueprint":
+            self.render_blueprint_editor()
+        elif selected_tab == "Generator":
+            self.render_generator_interface()
+        else:
+            self.render_content_preview()
 
 def main():
-    """
-    Initialize and run the application
-    """
-    app = BookWritingApp()
+    app = SelfApiApp()
     app.run()
 
 if __name__ == "__main__":