Update selfapi_writer.py

selfapi_writer.py

@@ -1,3 +1,5 @@
+# selfapi_writer.py
+
 from anthropic import Anthropic
 import streamlit as st
 import json
@@ -10,7 +12,7 @@ class SelfApiWriter:
     def __init__(self):
         """Initialize the Self.api writer with enhanced content tracking"""
         ANTHROPIC_API_KEY = os.getenv('api_key')
-            
+                    
         if not ANTHROPIC_API_KEY:
             raise ValueError("Anthropic API key not found. Please ensure ANTHROPIC_API_KEY is set.")
         
@@ -151,7 +153,7 @@ class SelfApiWriter:
                     temperature=0,
                     system=system_prompt,
                     messages=[{
-                        "role": "user", 
+                        "role": "user",
                         "content": f"""Analyze this book blueprint and extract ALL information:
 
                         {truncated_blueprint}
@@ -177,138 +179,7 @@ class SelfApiWriter:
             st.error(f"Error processing blueprint: {str(e)}")
             return None
 
-    def set_manual_content(self, content_id: str, content: str) -> None:
-        """Set pre-written content for a section"""
-        if content_id not in self.content_states:
-            self._initialize_content_state(content_id)
-        self.content_states[content_id].set_manual_content(content)
-
-    def _generate_transition(self, content_id: str, prev_content: str, next_content: str) -> str:
-        """Generate smooth transition between content sections"""
-        state = self.content_states[content_id]
-        
-        transition_prompt = f"""Create a smooth transition between these sections:
-        
-        Previous Section Summary: {self._summarize_text(prev_content)}
-        Next Section Key Points: {self._summarize_text(next_content)}
-        
-        Create a natural bridge that:
-        1. References relevant previous points
-        2. Introduces upcoming concepts
-        3. Maintains narrative flow
-        4. Feels organic and not forced"""
-
-        response = self.client.messages.create(
-            model=self.model,
-            max_tokens=300,
-            temperature=0.7,
-            messages=[{"role": "user", "content": transition_prompt}]
-        )
-        
-        transition = response.content[0].text
-        state.transition_points.append(transition)
-        return transition
-
-    def _generate_progressive_summary(self, content_id: str, content: str) -> str:
-        """Generate a running summary of content progress"""
-        summary_prompt = f"""Summarize the key points and narrative progression of:
-
-        {content}
-
-        Focus on:
-        1. Main concepts introduced
-        2. Key arguments developed
-        3. Narrative threads established
-        4. Important conclusions reached
-        
-        Keep the summary concise but comprehensive."""
-
-        response = self.client.messages.create(
-            model=self.model,
-            max_tokens=500,
-            temperature=0.3,
-            messages=[{"role": "user", "content": summary_prompt}]
-        )
-        
-        return response.content[0].text
-
-    def _generate_with_continuity(self, 
-                                    generate_func: callable,
-                                    content_id: str,
-                                    title: str,
-                                    total_steps: int = 10) -> str:
-        """Enhanced generation with content continuity tracking"""
-        progress_bar = st.progress(0, text=f"Generating {title}...")
-        full_content = ""
-        state = self.content_states[content_id]
-        
-        try:
-            # If manual content exists, use it as a starting point
-            if state.manual_content:
-                full_content = state.manual_content + "\n\n"
-                # Generate initial summary from manual content
-                state.current_summary = self._generate_progressive_summary(
-                    content_id,
-                    full_content
-                )
-            
-            # Generate initial outline
-            outline = self._generate_section_outline(content_id, "section", title)
-            points_per_iteration = max(1, len(outline) // total_steps)
-            
-            for iteration in range(1, total_steps + 1):
-                progress = iteration / total_steps
-                progress_bar.progress(
-                    min(int(progress * 100), 100),
-                    text=f"Generating {title}... (Iteration {iteration}/{total_steps})"
-                )
-                
-                start_idx = (iteration - 1) * points_per_iteration
-                end_idx = min(start_idx + points_per_iteration, len(outline))
-                current_points = outline[start_idx:end_idx]
-                
-                new_content = generate_func(
-                    iteration=iteration,
-                    previous_summary=state.current_summary,
-                    points_to_cover=current_points,
-                    narrative_threads=state.narrative_threads
-                )
-                
-                state.generated_sections.append(new_content)
-                
-                if iteration > 1:
-                    transition = self._generate_transition(
-                        content_id,
-                        state.generated_sections[-2],
-                        new_content
-                    )
-                    full_content += transition
-                
-                full_content += new_content
-                
-                state.current_summary = self._generate_progressive_summary(
-                    content_id,
-                    full_content
-                )
-                state.key_points_covered.update(current_points)
-                
-                if len(full_content.split()) > self.pages_per_chapter * self.words_per_page:
-                    break
-            
-            conclusion = self._generate_conclusion(content_id, full_content)
-            full_content += conclusion
-            
-            progress_bar.progress(100, text=f"Finished generating {title}")
-            return full_content
-            
-        except Exception as e:
-            st.error(f"Error generating {title}: {e}")
-            progress_bar.empty()
-            return f"Error generating {title}: {e}"
-        finally:
-            progress_bar.empty()
-
-    def write_introduction(self) -> str:
+    def write_introduction(self, additional_prompt: str = "") -> str:
         """Generate the book's introduction with enhanced continuity"""
         if not self.initialized:
             raise ValueError("Writer not initialized. Process blueprint first.")
@@ -317,9 +188,9 @@ class SelfApiWriter:
         self._initialize_content_state(content_id)
             
         def generate_intro_iteration(iteration: int,
-                                        previous_summary: str,
-                                        points_to_cover: List[str],
-                                        narrative_threads: List[str]) -> str:
+                                   previous_summary: str,
+                                   points_to_cover: List[str],
+                                   narrative_threads: List[str]) -> str:
             """Generate a single iteration of the introduction"""
             full_blueprint = self.context.get('full_original_blueprint', '')
 
@@ -332,7 +203,11 @@ class SelfApiWriter:
             Core Vision: {self.book_info.get('vision', '')}
             Target Audience: {self.book_info.get('target_audience', '')}
             Writing Style: {self.writing_guidelines.get('style', 'Academic and clear')}
-            Tone: {self.writing_guidelines.get('tone', 'Professional')}"""
+            Tone: {self.writing_guidelines.get('tone', 'Professional')}
+            
+            Additional Instructions: {additional_prompt}
+            
+            Write the introduction following these guidelines."""
 
             response = self.client.messages.create(
                 model=self.model,
@@ -365,15 +240,15 @@ class SelfApiWriter:
             
         content_id = f"part_{part_idx}_chapter_{chapter_idx}"
         self._initialize_content_state(content_id)
-       
+        
         # Add any additional prompts to the content state
         if additional_prompt:
             self.content_states[content_id].add_custom_prompt(content_id, additional_prompt)
-       
+        
         def generate_chapter_iteration(iteration: int,
-                                        previous_summary: str,
-                                        points_to_cover: List[str],
-                                        narrative_threads: List[str]) -> str:
+                                    previous_summary: str,
+                                    points_to_cover: List[str],
+                                    narrative_threads: List[str]) -> str:
             """Generate a single chapter iteration with enhanced context"""
             part = self.book_structure["parts"][part_idx]
             chapter_title = part["chapters"][chapter_idx]
@@ -389,8 +264,8 @@ class SelfApiWriter:
             
             Blueprint Context: {self.context.get('full_original_blueprint', '')}
             
-            Additional Instructions: {section_context['additional_prompt']}
-            Custom Guidelines: {section_context['custom_instructions']}
+            Additional Instructions: {additional_prompt}
+            Custom Guidelines: {section_context.get('custom_instructions', '')}
             
             Previous Content Summary: {previous_summary}
             Points to Cover in This Section: {', '.join(points_to_cover)}
@@ -421,19 +296,204 @@ class SelfApiWriter:
             
             return response.content[0].text
 
-        # Update generation process to include additional context
         full_chapter_content = self._generate_with_continuity(
             generate_chapter_iteration,
             content_id,
             f"Chapter: {self.book_structure['parts'][part_idx]['chapters'][chapter_idx]}"
         )
-       
+        
         # Store context history
         self.content_states[content_id].update_context_history(
             content_id,
             self.content_states[content_id].get_section_context(content_id)
         )
-       
+        
+        if 'parts' not in self.context:
+            self.context['parts'] = []
+        
+        while len(self.context['parts']) <= part_idx:
+            self.context['parts'].append({'chapters': []})
+        
+        while len(self.context['parts'][part_idx]['chapters']) <= chapter_idx:
+            self.context['parts'][part_idx]['chapters'].append({})
+        
+        self.context['parts'][part_idx]['chapters'][chapter_idx] = {
+            'title': self.book_structure['parts'][part_idx]['chapters'][chapter_idx],
+            'content': full_chapter_content
+        }
+        
         return full_chapter_content
 
-    def
+    def _generate_with_continuity(self, 
+                                generate_func: callable,
+                                content_id: str,
+                                title: str,
+                                total_steps: int = 10) -> str:
+        """Enhanced generation with content continuity tracking"""
+        progress_bar = st.progress(0, text=f"Generating {title}...")
+        full_content = ""
+        state = self.content_states[content_id]
+        
+        try:
+            # If manual content exists, use it as a starting point
+            if state.manual_content:
+                full_content = state.manual_content + "\n\n"
+                # Generate initial summary from manual content
+                state.current_summary = self._generate_progressive_summary(
+                    content_id,
+                    full_content
+                )
+            
+            # Generate initial outline
+            outline = self._generate_section_outline(content_id, "section", title)
+            points_per_iteration = max(1, len(outline) // total_steps)
+            
+            for iteration in range(1, total_steps + 1):
+                progress = iteration / total_steps
+                progress_bar.progress(
+                    min(int(progress * 100), 100),
+                    text=f"Generating {title}... (Iteration {iteration}/{total_steps})"
+                )
+                
+                start_idx = (iteration - 1) * points_per_iteration
+                end_idx = min(start_idx + points_per_iteration, len(outline))
+                current_points = outline[start_idx:end_idx]
+                
+                new_content = generate_func(
+                    iteration=iteration,
+                    previous_summary=state.current_summary,
+                    points_to_cover=current_points,
+                    narrative_threads=state.narrative_threads
+                )
+                
+                state.generated_sections.append(new_content)
+                
+                if iteration > 1:
+                    transition = self._generate_transition(
+                        content_id,
+                        state.generated_sections[-2],
+                        new_content
+                    )
+                    full_content += transition
+                
+                full_content += new_content
+                
+                state.current_summary = self._generate_progressive_summary(
+                    content_id,
+                    full_content
+                )
+                state.key_points_covered.update(current_points)
+                
+                if len(full_content.split()) > self.pages_per_chapter * self.words_per_page:
+                    break
+            
+            conclusion = self._generate_conclusion(content_id, full_content)
+            full_content += conclusion
+            
+            progress_bar.progress(100, text=f"Finished generating {title}")
+            return full_content
+            
+        except Exception as e:
+            st.error(f"Error generating {title}: {e}")
+            progress_bar.empty()
+            return f"Error generating {title}: {e}"
+        finally:
+            progress_bar.empty()
+
+    def _generate_transition(self, content_id: str, prev_content: str, next_content: str) -> str:
+        """Generate smooth transition between sections"""
+        state = self.content_states[content_id]
+        
+        transition_prompt = f"""Create a smooth transition between these sections:
+        
+        Previous Section Summary: {self._summarize_text(prev_content)}
+        Next Section Key Points: {self._summarize_text(next_content)}
+        
+        Create a natural bridge that:
+        1. References relevant previous points
+        2. Introduces upcoming concepts
+        3. Maintains narrative flow
+        4. Feels organic and not forced"""
+
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=300,
+            temperature=0.7,
+            messages=[{"role": "user", "content": transition_prompt}]
+        )
+        
+        transition = response.content[0].text
+        state.transition_points.append(transition)
+        return transition
+
+    def _generate_progressive_summary(self, content_id: str, content: str) -> str:
+        """Generate a running summary of content progress"""
+        summary_prompt = f"""Summarize the key points and narrative progression of:
+
+        {content}
+
+        Focus on:
+        1. Main concepts introduced
+        2. Key arguments developed
+        3. Narrative threads established
+        4. Important conclusions reached
+        
+        Keep the summary concise but comprehensive."""
+
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=500,
+            temperature=0.3,
+            messages=[{"role": "user", "content": summary_prompt}]
+        )
+        
+        return response.content[0].text
+
+    def _summarize_text(self, text: str) -> str:
+        """Generate a concise summary of text"""
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=300,
+            temperature=0.3,
+            messages=[{
+                "role": "user",
+                "content": f"Summarize the key points from this text:\n\n{text}"
+            }]
+        )
+        return response.content[0].text
+
+    def _generate_conclusion(self, content_id: str, full_content: str) -> str:
+        """Generate a conclusion that ties everything together"""
+        state = self.content_states[content_id]
+        
+        conclusion_prompt = f"""Create a conclusion that ties together:
+
+        Content Summary: {state.current_summary}
+        Key Points Covered: {', '.join(state.key_points_covered)}
+        Narrative Threads: {', '.join(state.narrative_threads)}
+        
+        The conclusion should:
+        1. Summarize main arguments
+        2. Connect key themes
+        3. Reinforce core messages
+        4. Provide closure while maintaining interest"""
+
+        response = self.client.messages.create(
+            model=self.model,
+            max_tokens=500,
+            temperature=0.7,
+            messages=[{"role": "user", "content": conclusion_prompt}]
+        )
+        
+        return response.content[0].text
+
+    def get_current_structure(self) -> Optional[Dict[str, Any]]:
+        """Get current book structure and guidelines"""
+        if not self.initialized:
+            return None
+            
+        return {
+            "book_info": self.book_info,
+            "structure": self.book_structure,
+            "guidelines": self.writing_guidelines
+        }