Update app.py

app.py

@@ -1,352 +1,187 @@
-# File: app.py
+# File: selfapi_writer.py
 
+import anthropic
 import streamlit as st
 import json
 import os
-from selfapi_writer import SelfApiWriter
-from data_manager import DataManager
+from typing import Dict, Any
 
-class SelfApiApp:
+class SelfApiWriter:
     def __init__(self):
-        """Initialize the Streamlit application"""
-        st.set_page_config(
-            page_title="Self.api Book Generator",
-            page_icon="📚",
-            layout="wide"
-        )
-        
-        # Initialize data manager
-        self.data_manager = DataManager()
+        """Initialize the Self.api writer"""
+        # Try to get API key from environment variables first, then from secrets
+        api_key = os.environ.get('ANTHROPIC_API_KEY')
         
-        # Initialize session state
-        self._initialize_session_state()
-
-    def _initialize_session_state(self):
-        """Initialize session state variables"""
-        if 'current_tab' not in st.session_state:
-            st.session_state.current_tab = 'Blueprint'
+        if not api_key and hasattr(st, 'secrets'):
+            api_key = st.secrets.get('ANTHROPIC_API_KEY')
             
-        if 'blueprint' not in st.session_state:
-            st.session_state.blueprint = self.default_blueprint
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY not found in environment variables or Streamlit secrets.")
             
-        if 'book_content' not in st.session_state:
-            st.session_state.book_content = {
-                "introduction": "",
-                "parts": []
+        # Print debug info (remove in production)
+        print("Environment variables available:", [k for k in os.environ.keys()])
+        print("API key found:", bool(api_key))
+        
+        self.client = anthropic.Anthropic(
+            api_key=api_key
+        )
+        self.context = {}
+        self.book_structure = {
+            "introduction": "System Requirements: A Human's Guide to Being Human",
+            "parts": [
+                {
+                    "title": "The Human Input/Output System",
+                    "chapters": [
+                        "Rate Limiting Your Reality",
+                        "Debugging Your Attention Span",
+                        "The Mindfulness Microservice"
+                    ]
+                },
+                {
+                    "title": "Your Internal Neural Network",
+                    "chapters": [
+                        "Training Your Gut Algorithm",
+                        "The Wisdom Cache",
+                        "Pattern Recognition Beyond Logic"
+                    ]
+                },
+                {
+                    "title": "The Source Code of Being",
+                    "chapters": [
+                        "Quantum Mechanics of Consciousness",
+                        "The Purpose Protocol",
+                        "Refactoring Your Reality"
+                    ]
+                },
+                {
+                    "title": "The Universal Runtime Environment",
+                    "chapters": [
+                        "Distributed Consciousness Systems",
+                        "The Empathy Protocol",
+                        "Scaling Your Impact"
+                    ]
+                }
+            ]
+        }
+
+    def process_blueprint(self, blueprint: str) -> Dict[str, Any]:
+        """Process updated blueprint to generate new book structure"""
+        try:
+            system_prompt = """You are an expert book planner analyzing a blueprint for 'Self.api: A Modern Spiritual Operating System'.
+            Extract and organize the book structure from the provided blueprint.
+            Return a JSON structure with the following format:
+            {
+                "introduction": "Introduction title",
+                "parts": [
+                    {
+                        "title": "Part title",
+                        "chapters": ["Chapter 1 title", "Chapter 2 title", ...]
+                    }
+                ]
             }
+            Ensure all sections from the blueprint are included and properly organized."""
 
-    @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
+            prompt = f"""Analyze this book blueprint and extract the structure:
 
-### Part 4: The Universal Runtime Environment
-- Distributed Consciousness Systems
-- The Empathy Protocol
-- Scaling Your Impact
+            {blueprint}
 
-## Style Guidelines
-1. Technical Authenticity
-   - Use API and tech metaphors naturally
-   - Example: "Think of meditation as a daily health check for your consciousness microservices"
+            Return only the JSON structure with no additional text."""
 
-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:
-            # 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}")
-            
-            # 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}")
+            response = self.client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=2000,
+                temperature=0,
+                system=system_prompt,
+                messages=[{"role": "user", "content": prompt}]
+            )
             
-            # 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)
+            new_structure = json.loads(response.content[0].text)
+            self.book_structure = new_structure
+            return new_structure
             
         except Exception as e:
-            st.error(f"Error saving state: {e}")
+            st.error(f"Error processing blueprint: {str(e)}")
+            return self.book_structure  # Return existing structure on error
 
-    def load_latest_state(self):
-        """Load latest state from data directory"""
+    def write_introduction(self) -> str:
+        """Generate the book's introduction"""
         try:
-            # Load latest blueprint
-            blueprint = self.data_manager.load_latest_blueprint()
-            if blueprint:
-                st.session_state.blueprint = blueprint
+            system_prompt = """You are writing the introduction to 'Self.api: A Modern Spiritual Operating System'.
+            The introduction should hook tech professionals by speaking their language while introducing the book's core premise.
+            Include the author's journey from debugging code to debugging consciousness."""
+
+            intro_prompt = """Write the introduction "System Requirements: A Human's Guide to Being Human"
+            
+            Key elements to include:
+            1. Opening hook: "In a world where we can Google anything except our own purpose..."
+            2. Author's personal journey
+            3. The core premise of viewing spirituality through an API/systems lens
+            4. Overview of the book's structure and approach
+            5. What readers will gain from this "operating manual for the human spirit"
+            
+            Make it compelling, technical yet accessible, and set the tone for the entire book."""
+
+            response = self.client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=4000,
+                temperature=0.7,
+                system=system_prompt,
+                messages=[{"role": "user", "content": intro_prompt}]
+            )
             
-            # Load latest book content
-            content = self.data_manager.load_latest_book_content()
-            if content:
-                st.session_state.book_content = content
-                
-            st.success("Latest state loaded successfully!")
+            intro_content = response.content[0].text
+            self.context['introduction'] = intro_content
+            return intro_content
             
         except Exception as e:
-            st.error(f"Error loading state: {e}")
+            st.error(f"Error generating introduction: {str(e)}")
+            return f"Error generating introduction: {str(e)}"
 
-    def export_book(self):
-        """Export book in markdown format"""
+    def write_chapter(self, part_idx: int, chapter_idx: int) -> str:
+        """Generate a specific chapter"""
         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}")
-                
-                # Create download link
-                with open(filepath, 'r') as f:
-                    markdown_content = f.read()
-                
-                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")
-        
-        col1, col2 = st.columns([7, 3])
-        
-        with col1:
-            # Blueprint Editor
-            edited_blueprint = st.text_area(
-                "Edit Blueprint",
-                value=st.session_state.blueprint,
-                height=600
+            part = self.book_structure["parts"][part_idx]
+            chapter_title = part["chapters"][chapter_idx]
+            part_title = part["title"]
+            previous_chapter = self.context.get(f'part_{part_idx}_chapter_{chapter_idx-1}', '')
+
+            system_prompt = """You are writing 'Self.api: A Modern Spiritual Operating System', a book that bridges technology and spirituality for tech professionals.
+            Follow these guidelines:
+            - Use API and technical metaphors naturally and accurately
+            - Maintain a voice that's witty but wise (Douglas Adams meets Deepak Chopra)
+            - Structure each chapter with: System Log (personal story), Documentation (teaching), Implementation Guide (practical steps)
+            - Balance is 60% practical, 40% philosophical
+            - Include 3 "aha" moments and 2-3 quotable passages
+            - Ensure every concept links to both ancient wisdom and modern science
+            - Write for analytical minds seeking spiritual depth without woo-woo
+            - Include practical exercises every few pages"""
+
+            chapter_prompt = f"""
+            Write Chapter: "{chapter_title}" in Part {part_idx + 1}: "{part_title}"
+            
+            Previous Chapter Context: {previous_chapter[:1000] if previous_chapter else 'Starting new part'}
+
+            Requirements:
+            1. Open with a compelling "System Log" that relates to {chapter_title}
+            2. Use technically accurate API/programming metaphors
+            3. Include at least two practical exercises
+            4. End with clear implementation steps
+            5. Maintain the tech-spiritual bridge throughout
+            
+            Begin writing the complete chapter now."""
+
+            response = self.client.messages.create(
+                model="claude-3-sonnet-20240229",
+                max_tokens=4000,
+                temperature=0.7,
+                system=system_prompt,
+                messages=[{"role": "user", "content": chapter_prompt}]
             )
             
-            if edited_blueprint != st.session_state.blueprint:
-                st.session_state.blueprint = edited_blueprint
-        
-        with col2:
-            st.subheader("Blueprint Controls")
-            
-            # 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:
-                    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 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")
-        
-        # Initialize writer if needed
-        if 'writer' not in st.session_state:
-            st.session_state.writer = SelfApiWriter()
-        
-        # Generation controls
-        col1, col2 = st.columns([2, 1])
-        
-        with col1:
-            st.subheader("Generation Controls")
-            
-            # 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!")
-            
-            # 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!")
-        
-        with col2:
-            st.subheader("Quick Actions")
+            chapter_content = response.content[0].text
+            self.context[f'part_{part_idx}_chapter_{chapter_idx}'] = chapter_content
+            return chapter_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
-                    
-                    # 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
-                            }
-                    
-                    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:
-            # 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 Streamlit application"""
-        st.title("🚀 Self.api Book Generator")
-        
-        # Main navigation
-        tabs = ["Blueprint", "Generator", "Preview"]
-        selected_tab = st.radio("Navigation", tabs, horizontal=True)
-        st.session_state.current_tab = selected_tab
-        
-        st.divider()
-        
-        # 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():
-    app = SelfApiApp()
-    app.run()
-
-if __name__ == "__main__":
-    main()
+        except Exception as e:
+            st.error(f"Error generating chapter: {str(e)}")
+            return f"Error generating chapter {chapter_title}: {str(e)}"