bioguider 0.2.33__tar.gz → 0.2.34__tar.gz

{bioguider-0.2.33 → bioguider-0.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bioguider
-Version: 0.2.33
+Version: 0.2.34
 Summary: An AI-Powered package to help biomedical developers to generate clear documentation
 License: MIT
 Author: Cankun Wang

{bioguider-0.2.33 → bioguider-0.2.34}/bioguider/generation/llm_content_generator.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Dict
 import json
 import re
+import os
 from langchain_openai.chat_models.base import BaseChatOpenAI
 
 from bioguider.agents.common_conversation import CommonConversation
@@ -19,7 +20,6 @@ INPUTS (use only what is provided; never invent)
 - suggestion_category: {suggestion_category}
 - anchor_title: {anchor_title}
 - guidance: {guidance}
-- evidence_from_evaluation: {evidence}
 - repo_context_excerpt (analyze tone/formatting; do not paraphrase it blindly): <<{context}>>
 
 CRITICAL REQUIREMENTS
@@ -33,7 +33,7 @@ CRITICAL REQUIREMENTS
 - ABSOLUTELY FORBIDDEN: Do NOT add summary sections, notes, conclusions, or any text at the end of documents
 - ABSOLUTELY FORBIDDEN: Do NOT wrap content in markdown code fences (```markdown). Return pure content only.
 - ABSOLUTELY FORBIDDEN: Do NOT add phrases like "Happy analyzing!", "Ensure all dependencies are up-to-date", or any concluding statements
-- ALWAYS use the specific guidance provided above to create concrete, actionable content based on evidence
+- ALWAYS use the specific guidance provided above to create concrete, actionable content
 
 STYLE & CONSTRAINTS
 - Fix obvious errors in the content.
@@ -79,7 +79,7 @@ LLM_FULLDOC_PROMPT = """
 You are "BioGuider," a documentation rewriter with enhanced capabilities for complex documents.
 
 GOAL
-Rewrite a complete target document using only the provided evaluation report signals and the repository context excerpts. Output a full, ready-to-publish markdown file that is more complete and directly usable. You now have increased token capacity to handle complex documents comprehensively.
+Rewrite a complete target document by enhancing the existing content while maintaining the EXACT original structure, sections, and flow. Use only the provided evaluation report signals and repository context excerpts. Output a full, ready-to-publish markdown file that follows the original document structure precisely while incorporating improvements. You now have increased token capacity to handle complex documents comprehensively.
 
 INPUTS (authoritative)
 - evaluation_report (structured JSON excerpts): <<{evaluation_report}>>
@@ -94,11 +94,12 @@ This file requires improvements from {total_suggestions} separate evaluation sug
 4. **Write the document ONCE** with all improvements incorporated throughout
 
 INTEGRATION STRATEGY
-- Identify which suggestions target similar topics (e.g., setup, reproducibility, performance)
-- Group related improvements and apply them to the same document sections
-- For tutorial files: Enhance existing sections with all relevant suggestions, don't create duplicate sections
+- **CRITICAL**: Follow the EXACT structure of the original document. Do NOT create new sections.
+- Identify which suggestions target existing sections in the original document
+- Apply improvements ONLY to existing sections - do NOT create new sections
+- For tutorial files: Enhance existing sections with relevant suggestions, maintain original section order
 - For documentation files: Merge suggestions into existing structure, avoid redundant sections
-- Result: ONE enhanced document that addresses all {total_suggestions} suggestions simultaneously
+- Result: ONE enhanced document that follows the original structure and addresses all {total_suggestions} suggestions
 
 CAPACITY AND SCOPE
 - You have enhanced token capacity to handle complex documents comprehensively
@@ -107,23 +108,24 @@ CAPACITY AND SCOPE
 - Comprehensive documents: Full capacity for complete documentation with all necessary sections
 
 STRICT CONSTRAINTS
+- **CRITICAL**: Follow the EXACT structure and sections of the original document. Do NOT create new sections or reorganize content.
 - Base the content solely on the evaluation report and repo context. Do not invent features, data, or claims not supported by these sources.
 - CRITICAL: NEVER invent technical specifications including:
   * Hardware requirements (RAM, CPU, disk space) unless explicitly stated in guidance/context
   * Version numbers for dependencies unless explicitly stated in guidance/context
   * Performance metrics, benchmarks, or timing estimates
-  * Biological/computational parameters or thresholds without evidence
+  * Biological/computational parameters or thresholds without substantiation
   * Installation commands or package names not found in the repo context
-- Prefer completeness and usability: produce the full file content, not just minimal "added" snippets.
-- Preserve top-of-file badges/logos if they exist in the original; keep title and header area intact unless the report requires changes.
-- CRITICAL: Preserve the original document structure, sections, and flow. Only enhance existing content and add missing information.
-- For tutorial files, maintain all original sections while improving clarity and adding missing details based on evaluation suggestions.
+- **CRITICAL**: Preserve the original document structure, sections, and flow EXACTLY. Only enhance existing content and add missing information based on evaluation suggestions.
+- For tutorial files, maintain ALL original sections in their original order while improving clarity and adding missing details based on evaluation suggestions.
 - Fix obvious errors; improve structure and readability per report suggestions.
-- Include ONLY sections specifically requested by the evaluation report - do not add unnecessary sections.
+- Include ONLY sections that exist in the original document - do not add unnecessary sections.
 - Avoid redundancy: do not duplicate information across multiple sections.
-- ABSOLUTELY FORBIDDEN: Do NOT add summary sections, notes, conclusions, or any text at the end of documents
-- ABSOLUTELY FORBIDDEN: Do NOT wrap the entire document inside markdown code fences (```markdown). Do NOT start with ```markdown or end with ```. Return pure content suitable for copy/paste.
-- ABSOLUTELY FORBIDDEN: Do NOT add phrases like "Happy analyzing!" or any concluding statements
+- **ABSOLUTELY CRITICAL**: Do NOT add ANY conclusion, summary, or closing paragraph at the end
+- **ABSOLUTELY CRITICAL**: Do NOT wrap the entire document inside markdown code fences (```markdown). Do NOT start with ```markdown or end with ```. Return pure content suitable for copy/paste.
+- **ABSOLUTELY CRITICAL**: Do NOT add phrases like "Happy analyzing!", "This vignette demonstrates...", "By following the steps outlined...", or ANY concluding statements
+- **ABSOLUTELY CRITICAL**: Stop writing IMMEDIATELY after the last content section from the original document. Do NOT add "## Conclusion", "## Summary", or any final paragraphs
+- **CRITICAL**: Do NOT reorganize, rename, or create new sections. Follow the original document structure exactly.
 - Keep links well-formed; keep neutral, professional tone; concise, skimmable formatting.
 - Preserve file-specific formatting (e.g., YAML frontmatter, code fence syntax) and do not wrap content in extra code fences.
 
@@ -182,12 +184,47 @@ OUTPUT
 - Return only the full README.md content. No commentary, no fences.
 """
 
+# Continuation prompt template - used when document generation is truncated
+LLM_CONTINUATION_PROMPT = """
+You are "BioGuider," continuing a truncated documentation generation task.
+
+IMPORTANT: This is STRICT CONTINUATION ONLY. You are NOT creating new content.
+You are NOT adding conclusions or summaries. You are ONLY completing the missing sections from the original document.
+
+PREVIOUS CONTENT (do not repeat this):
+```
+{existing_content_tail}
+```
+
+STRICT CONTINUATION RULES:
+- Examine the previous content above and identify what section it ends with
+- Continue IMMEDIATELY after that section with the next missing section from the original document
+- Use the EXACT same structure, style, and tone as the existing content
+- Add ONLY the specific content that should logically follow from the last section
+- Do NOT add ANY conclusions, summaries, additional resources, or wrap-up content
+- Do NOT add phrases like "For further guidance", "Additional Resources", or "In conclusion"
+
+MISSING CONTENT TO ADD:
+Based on typical RMarkdown vignette structure, if the document ends with "Common Pitfalls", you should add:
+- SCT integration example (SCTransform section)
+- Session info section
+- Details section (if present in original)
+- STOP after these sections - do NOT add anything else
+
+CRITICAL: STOP IMMEDIATELY after completing the missing sections from the original document.
+Do NOT add "## Additional Resources" or any final sections.
+
+OUTPUT:
+- Return ONLY the continuation content that completes the original document structure
+- No commentary, no fences, no conclusions, no additional content
+"""
+
 
 class LLMContentGenerator:
     def __init__(self, llm: BaseChatOpenAI):
         self.llm = llm
 
-    def _detect_truncation(self, content: str, target_file: str) -> bool:
+    def _detect_truncation(self, content: str, target_file: str, original_content: str = None) -> bool:
         """
         Detect if content appears to be truncated based on common patterns.
         Universal detection for all file types.
@@ -195,6 +232,7 @@ class LLMContentGenerator:
         Args:
             content: Generated content to check
             target_file: Target file path for context
+            original_content: Original content for comparison (if available)
             
         Returns:
             True if content appears truncated, False otherwise
@@ -202,19 +240,27 @@ class LLMContentGenerator:
         if not content or len(content.strip()) < 100:
             return True
         
-        # 1. Check for very short content (applies to all files)
-        # Only flag as truncated if content is very short (< 1500 chars)
-        if len(content) < 1500:
+        # 1. Compare to original length if available (most reliable indicator)
+        if original_content:
+            original_len = len(original_content)
+            generated_len = len(content)
+            # If generated content is significantly shorter than original (< 80%), likely truncated
+            if generated_len < original_len * 0.8:
+                return True
+        
+        # 2. Check for very short content (applies to all files)
+        # Only flag as truncated if content is very short (< 500 chars)
+        if len(content) < 500:
             return True
             
-        # 2. Check for incomplete code blocks (any language)
+        # 3. Check for incomplete code blocks (any language)
         # Count opening and closing code fences
         code_fence_count = content.count('```')
         if code_fence_count > 0 and code_fence_count % 2 != 0:
             # Unbalanced code fences suggest truncation
             return True
             
-        # 3. Check for specific language code blocks
+        # 4. Check for specific language code blocks
         if target_file.endswith('.Rmd'):
             # R chunks should be complete
             r_chunks_open = re.findall(r'```\{r[^}]*\}', content)
@@ -278,14 +324,91 @@ class LLMContentGenerator:
                     
         return False
 
-    def _appears_complete(self, content: str, target_file: str) -> bool:
+    def _find_continuation_point(self, content: str, original_content: str = None) -> str:
+        """
+        Find a better continuation point than just the last 1000 characters.
+        Looks for the last complete section or code block to continue from.
+
+        Args:
+            content: The generated content so far
+            original_content: The original content for comparison
+
+        Returns:
+            A suitable continuation point, or None if not found
         """
-        Check if content appears to be complete based on structure and patterns.
+        if not content:
+            return None
+
+        lines = content.split('\n')
+        if len(lines) < 10:  # Too short to find good continuation point
+            return None
+
+        # Strategy 1: Find the last complete section (header with content after it)
+        for i in range(len(lines) - 1, -1, -1):
+            line = lines[i].strip()
+            if line.startswith('## ') and i + 1 < len(lines):
+                # Check if there's content after this header
+                next_lines = []
+                for j in range(i + 1, min(i + 10, len(lines))):  # Look at next 10 lines
+                    if lines[j].strip() and not lines[j].strip().startswith('##'):
+                        next_lines.append(lines[j])
+                    else:
+                        break
+
+                if next_lines:  # Found header with content after it
+                    # Return from this header onwards
+                    return '\n'.join(lines[i:])
+
+        # Strategy 2: Find the last complete code block
+        in_code_block = False
+        code_block_start = -1
+
+        for i in range(len(lines) - 1, -1, -1):
+            line = lines[i].strip()
+            if line.startswith('```') and not in_code_block:
+                in_code_block = True
+                code_block_start = i
+            elif line.startswith('```') and in_code_block:
+                # Found complete code block
+                return '\n'.join(lines[code_block_start:])
+
+        # Strategy 3: Find last complete paragraph (ends with period)
+        for i in range(len(lines) - 1, -1, -1):
+            line = lines[i].strip()
+            if line and line.endswith('.') and not line.startswith('#') and not line.startswith('```'):
+                # Found a complete sentence, return from there
+                return '\n'.join(lines[i:])
+
+        # Strategy 4: If original content is available, find where the generated content diverges
+        if original_content:
+            # Simple approach: find the longest common suffix
+            min_len = min(len(content), len(original_content))
+            common_length = 0
+
+            for i in range(1, min_len + 1):
+                if content[-i:] == original_content[-i:]:
+                    common_length = i
+                else:
+                    break
+
+            if common_length > 100:  # Found significant common ending
+                return content[-(common_length + 100):]  # Include some context
+
+        return None
+
+    def _appears_complete(self, content: str, target_file: str, original_content: str = None) -> bool:
+        """
+        Check if content appears to be complete based on structure, patterns, AND original length.
         Universal completion check for all file types.
         
+        CRITICAL: If original_content is provided, generated content MUST be at least 90% of original length
+        to be considered complete, regardless of other heuristics. This prevents the LLM from fooling us
+        with fake conclusions.
+        
         Args:
             content: Generated content to check
             target_file: Target file path for context
+            original_content: Original content for length comparison (optional but recommended)
             
         Returns:
             True if content appears complete, False if it needs continuation
@@ -293,6 +416,15 @@ class LLMContentGenerator:
         if not content or len(content.strip()) < 100:
             return False
         
+        # CRITICAL: If original content is provided, check length ratio first
+        # This prevents the LLM from fooling us with fake conclusions
+        if original_content and isinstance(original_content, str):
+            generated_len = len(content)
+            original_len = len(original_content)
+            if generated_len < original_len * 0.9:
+                # Generated content is too short compared to original - NOT complete
+                return False
+        
         # 1. Check for balanced code blocks (applies to all files)
         code_block_count = content.count('```')
         if code_block_count > 0 and code_block_count % 2 != 0:
@@ -441,61 +573,14 @@ class LLMContentGenerator:
             elif "suggestions" in evaluation_report and isinstance(evaluation_report["suggestions"], list):
                 total_suggestions = len(evaluation_report["suggestions"])
         
-        continuation_prompt = f"""
-You are "BioGuider," continuing a documentation generation task with enhanced capacity for complex documents.
-
-GOAL
-Continue generating the document "{target_file}" from where the previous generation left off. 
-The previous content was truncated and needs to be completed. You now have increased token 
-capacity to handle complex documents comprehensively.
-
-PREVIOUS CONTENT (do not repeat this):
-```
-{existing_content[-1000:]}  # Last 1000 chars for context
-```
-
-TASK
-Continue the document naturally from the last complete section. Maintain the same style, 
-structure, and flow as the previous content. Complete all remaining sections that should 
-be in this document.
-
-CAPACITY AND SCOPE
-- You have enhanced token capacity to handle complex documents comprehensively
-- Tutorial documents: Enhanced capacity for step-by-step content, code examples, and comprehensive explanations
-- Complex documents: Increased capacity for multiple sections, detailed explanations, and extensive content
-- Comprehensive documents: Full capacity for complete documentation with all necessary sections
-
-INPUTS
-- evaluation_report (contains {total_suggestions} suggestions to integrate): {json.dumps(evaluation_report)[:4000]}
-- context: {context[:2000]}
-
-REMINDER: SINGLE DOCUMENT APPROACH
-- The evaluation report contains {total_suggestions} SEPARATE suggestions
-- These should be integrated into ONE cohesive continuation
-- Do NOT create {total_suggestions} separate sections for each suggestion
-- Group related suggestions (e.g., setup, reproducibility, performance) and integrate them naturally
-
-REQUIREMENTS
-- Continue seamlessly from the previous content
-- Maintain the same tone and style
-- Complete all sections that should be in this document
-- Preserve file-specific formatting (e.g., YAML frontmatter, code block syntax appropriate to the language)
-- Do not repeat content already generated
-- Return only the continuation content, not the full document
-- Use the increased token capacity to provide thorough, complete content
-- NEVER invent technical specifications (hardware, versions, performance) unless explicitly in evaluation report or context
-- ABSOLUTELY FORBIDDEN: Do NOT wrap content in markdown code fences (```markdown). Return pure content only.
-- ABSOLUTELY FORBIDDEN: Do NOT add summary sections, notes, conclusions, or any text at the end of documents
-
-COMPLETENESS REQUIREMENTS
-- Generate complete, comprehensive content that addresses all remaining evaluation suggestions
-- For complex documents, ensure all sections are fully developed and detailed
-- For tutorial documents, include complete step-by-step instructions with examples
-- Use the increased token capacity to provide thorough, useful documentation
-
-OUTPUT
-Return only the continuation content that should be appended to the existing content.
-"""
+        # Use the centralized continuation prompt template
+        continuation_prompt = LLM_CONTINUATION_PROMPT.format(
+            target_file=target_file,
+            existing_content_tail=existing_content[-1000:],  # Last 1000 chars for context
+            total_suggestions=total_suggestions,
+            evaluation_report_excerpt=json.dumps(evaluation_report)[:4000],
+            context_excerpt=context[:2000],
+        )
         
         content, token_usage = conv.generate(
             system_prompt=continuation_prompt, 
@@ -514,14 +599,13 @@ Return only the continuation content that should be appended to the existing con
             section=section_name,
             anchor_title=section_name,
             suggestion_category=suggestion.category,
-            evidence=(suggestion.source.get("evidence", "") if suggestion.source else ""),
             context=context[:2500],
             guidance=(suggestion.content_guidance or "").strip(),
         )
         content, token_usage = conv.generate(system_prompt=system_prompt, instruction_prompt="Write the section content now.")
         return content.strip(), token_usage
 
-    def generate_full_document(self, target_file: str, evaluation_report: dict, context: str = "") -> tuple[str, dict]:
+    def generate_full_document(self, target_file: str, evaluation_report: dict, context: str = "", original_content: str = None) -> tuple[str, dict]:
         # Create LLM (uses 16k tokens by default - enough for any document)
         from bioguider.agents.agent_utils import get_llm
         import os
@@ -560,6 +644,11 @@ Return only the continuation content that should be appended to the existing con
         with open(debug_file, 'w', encoding='utf-8') as f:
             json.dump(debug_info, f, indent=2, ensure_ascii=False)
         
+        # Debug: Save raw evaluation_report to see what's being serialized
+        eval_report_file = os.path.join(debug_dir, f"{safe_filename}_raw_eval_report.json")
+        with open(eval_report_file, 'w', encoding='utf-8') as f:
+            json.dump(evaluation_report, f, indent=2, ensure_ascii=False)
+        
         # Use comprehensive README prompt for README.md files
         if target_file.endswith("README.md"):
             system_prompt = LLM_README_COMPREHENSIVE_PROMPT.format(
@@ -590,14 +679,24 @@ Return only the continuation content that should be appended to the existing con
             f.write(system_prompt)
             f.write("\n\n=== INSTRUCTION PROMPT ===\n")
             f.write("Write the full document now.")
-            f.write("\n\n=== EVALUATION REPORT ===\n")
-            f.write(json.dumps(evaluation_report, indent=2))
-            f.write("\n\n=== CONTEXT ===\n")
-            f.write(context[:2000] + "..." if len(context) > 2000 else context)
+            # Context is already embedded in system prompt; avoid duplicating here
         
         # Initial generation
-        content, token_usage = conv.generate(system_prompt=system_prompt, instruction_prompt="Write the full document now.")
-        content = content.strip()
+        # If the original document is long (RMarkdown > 8k chars), avoid truncation by chunked rewrite
+        # Lower threshold from 12k to 8k to catch more documents that would otherwise truncate
+        use_chunked = bool(target_file.endswith('.Rmd') and isinstance(original_content, str) and len(original_content) > 8000)
+        if use_chunked:
+            content, token_usage = self._generate_full_document_chunked(
+                target_file=target_file,
+                evaluation_report=evaluation_report,
+                context=context,
+                original_content=original_content or "",
+                debug_dir=debug_dir,
+                safe_filename=safe_filename,
+            )
+        else:
+            content, token_usage = conv.generate(system_prompt=system_prompt, instruction_prompt="Write the full document now.")
+            content = content.strip()
         
         # Save initial generation for debugging
         generation_file = os.path.join(debug_dir, f"{safe_filename}_generation_0.txt")
@@ -605,7 +704,9 @@ Return only the continuation content that should be appended to the existing con
             f.write(f"=== INITIAL GENERATION ===\n")
             f.write(f"Tokens: {token_usage}\n")
             f.write(f"Length: {len(content)} characters\n")
-            f.write(f"Truncation detected: {self._detect_truncation(content, target_file)}\n")
+            if original_content:
+                f.write(f"Original length: {len(original_content)} characters\n")
+            f.write(f"Truncation detected: {self._detect_truncation(content, target_file, original_content)}\n")
             f.write(f"\n=== CONTENT ===\n")
             f.write(content)
         
@@ -613,79 +714,39 @@ Return only the continuation content that should be appended to the existing con
         max_continuations = 3  # Limit to prevent infinite loops
         continuation_count = 0
         
-        while (self._detect_truncation(content, target_file) and 
+        while (not use_chunked and self._detect_truncation(content, target_file, original_content) and 
                continuation_count < max_continuations):
             
             # Additional check: if content appears complete, don't continue
-            if self._appears_complete(content, target_file):
+            # Pass original_content so we can check length ratio
+            if self._appears_complete(content, target_file, original_content):
                 break
             continuation_count += 1
             
-            # Save continuation prompt for debugging
-            continuation_prompt_file = os.path.join(debug_dir, f"{safe_filename}_continuation_{continuation_count}_prompt.txt")
-            continuation_prompt = f"""
-You are "BioGuider," continuing a documentation generation task with enhanced capacity for complex documents.
-
-GOAL
-Continue generating the document "{target_file}" from where the previous generation left off. 
-The previous content was truncated and needs to be completed. You now have increased token 
-capacity to handle complex documents comprehensively.
-
-PREVIOUS CONTENT (do not repeat this):
-```
-{content[-1000:]}  # Last 1000 chars for context
-```
-
-TASK
-Continue the document naturally from the last complete section. Maintain the same style, 
-structure, and flow as the previous content. Complete all remaining sections that should 
-be in this document.
-
-CRITICAL REQUIREMENTS:
-- Do NOT repeat any content already generated above
-- Do NOT duplicate sections, headers, or code blocks that already exist
-- Generate ONLY new, unique content that continues from where the previous content ended
-- If the previous content appears complete, add complementary sections that enhance the document
-- Focus on adding missing sections, examples, or explanations that weren't covered
-
-CAPACITY AND SCOPE
-- You have enhanced token capacity to handle complex documents comprehensively
-- Tutorial documents: Enhanced capacity for step-by-step content, code examples, and comprehensive explanations
-- Complex documents: Increased capacity for multiple sections, detailed explanations, and extensive content
-- Comprehensive documents: Full capacity for complete documentation with all necessary sections
-
-INPUTS
-- evaluation_report (contains {total_suggestions} suggestions to integrate): {json.dumps(evaluation_report)[:4000]}
-- context: {context[:2000]}
-
-REMINDER: SINGLE DOCUMENT APPROACH
-- The evaluation report contains {total_suggestions} SEPARATE suggestions
-- These should be integrated into ONE cohesive continuation
-- Do NOT create {total_suggestions} separate sections for each suggestion
-- Group related suggestions (e.g., setup, reproducibility, performance) and integrate them naturally
-
-REQUIREMENTS
-- Continue seamlessly from the previous content
-- Maintain the same tone and style
-- Complete all sections that should be in this document
-- Preserve file-specific formatting (e.g., YAML frontmatter, code block syntax appropriate to the language)
-- Do not repeat content already generated
-- Return only the continuation content, not the full document
-- Use the increased token capacity to provide thorough, complete content
-- NEVER invent technical specifications (hardware, versions, performance) unless explicitly in evaluation report or context
-- ABSOLUTELY FORBIDDEN: Do NOT wrap content in markdown code fences (```markdown). Return pure content only.
-- ABSOLUTELY FORBIDDEN: Do NOT add summary sections, notes, conclusions, or any text at the end of documents
-
-COMPLETENESS REQUIREMENTS
-- Generate complete, comprehensive content that addresses all remaining evaluation suggestions
-- For complex documents, ensure all sections are fully developed and detailed
-- For tutorial documents, include complete step-by-step instructions with examples
-- Use the increased token capacity to provide thorough, useful documentation
+            # Calculate total suggestions for debugging info
+            total_suggestions = 1
+            if isinstance(evaluation_report, dict):
+                if "total_suggestions" in evaluation_report:
+                    total_suggestions = evaluation_report["total_suggestions"]
+                elif "suggestions" in evaluation_report and isinstance(evaluation_report["suggestions"], list):
+                    total_suggestions = len(evaluation_report["suggestions"])
+            
+            # Find better continuation point - look for last complete section
+            continuation_point = self._find_continuation_point(content, original_content)
+            if not continuation_point:
+                continuation_point = content[-1000:]  # Fallback to last 1000 chars
 
-OUTPUT
-- Return only the continuation content. No commentary, no fences.
-"""
+            # Generate continuation prompt using centralized template
+            continuation_prompt = LLM_CONTINUATION_PROMPT.format(
+                target_file=target_file,
+                existing_content_tail=continuation_point,
+                total_suggestions=total_suggestions,
+                evaluation_report_excerpt=json.dumps(evaluation_report)[:4000],
+                context_excerpt=context[:2000],
+            )
             
+            # Save continuation prompt for debugging
+            continuation_prompt_file = os.path.join(debug_dir, f"{safe_filename}_continuation_{continuation_count}_prompt.txt")
             with open(continuation_prompt_file, 'w', encoding='utf-8') as f:
                 f.write(continuation_prompt)
             
@@ -768,4 +829,82 @@ OUTPUT
         
         return '\n'.join(cleaned_lines)
 
+    def _split_rmd_into_chunks(self, content: str) -> list[dict]:
+        chunks = []
+        if not content:
+            return chunks
+        lines = content.split('\n')
+        n = len(lines)
+        i = 0
+        if n >= 3 and lines[0].strip() == '---':
+            j = 1
+            while j < n and lines[j].strip() != '---':
+                j += 1
+            if j < n and lines[j].strip() == '---':
+                chunks.append({"type": "yaml", "content": '\n'.join(lines[0:j+1])})
+                i = j + 1
+        buffer = []
+        in_code = False
+        for k in range(i, n):
+            line = lines[k]
+            if line.strip().startswith('```'):
+                if in_code:
+                    buffer.append(line)
+                    chunks.append({"type": "code", "content": '\n'.join(buffer)})
+                    buffer = []
+                    in_code = False
+                else:
+                    if buffer and any(s.strip() for s in buffer):
+                        chunks.append({"type": "text", "content": '\n'.join(buffer)})
+                    buffer = [line]
+                    in_code = True
+            else:
+                buffer.append(line)
+        if buffer and any(s.strip() for s in buffer):
+            chunks.append({"type": "code" if in_code else "text", "content": '\n'.join(buffer)})
+        return chunks
+
+    def _generate_text_chunk(self, conv: CommonConversation, evaluation_report: dict, context: str, chunk_text: str) -> tuple[str, dict]:
+        LLM_CHUNK_PROMPT = (
+            "You are BioGuider improving a single markdown chunk of a larger RMarkdown document.\n\n"
+            "GOAL\nRefine ONLY the given chunk's prose per evaluation suggestions while preserving structure.\n"
+            "Do not add conclusions or new sections.\n\n"
+            "INPUTS\n- evaluation_report: <<{evaluation_report}>>\n- repo_context_excerpt: <<{context}>>\n- original_chunk:\n<<<\n{chunk}\n>>>\n\n"
+            "RULES\n- Preserve headers/formatting in this chunk.\n- Do not invent technical specs.\n- Output ONLY the refined chunk (no fences)."
+        )
+        system_prompt = LLM_CHUNK_PROMPT.format(
+            evaluation_report=json.dumps(evaluation_report)[:4000],
+            context=context[:1500],
+            chunk=chunk_text[:6000],
+        )
+        content, usage = conv.generate(system_prompt=system_prompt, instruction_prompt="Rewrite this chunk now.")
+        return content.strip(), usage
+
+    def _generate_full_document_chunked(self, target_file: str, evaluation_report: dict, context: str, original_content: str, debug_dir: str, safe_filename: str) -> tuple[str, dict]:
+        conv = CommonConversation(self.llm)
+        chunks = self._split_rmd_into_chunks(original_content)
+        merged = []
+        total_usage = {"total_tokens": 0, "prompt_tokens": 0, "completion_tokens": 0}
+        from datetime import datetime
+        for idx, ch in enumerate(chunks):
+            if ch["type"] in ("yaml", "code"):
+                merged.append(ch["content"])
+                continue
+            out, usage = self._generate_text_chunk(conv, evaluation_report, context, ch["content"])
+            if not out:
+                out = ch["content"]
+            merged.append(out)
+            try:
+                total_usage["total_tokens"] += int(usage.get("total_tokens", 0))
+                total_usage["prompt_tokens"] += int(usage.get("prompt_tokens", 0))
+                total_usage["completion_tokens"] += int(usage.get("completion_tokens", 0))
+            except Exception:
+                pass
+            chunk_file = os.path.join(debug_dir, f"{safe_filename}_chunk_{idx}.txt")
+            with open(chunk_file, 'w', encoding='utf-8') as f:
+                f.write(f"=== CHUNK {idx} ({ch['type']}) at {datetime.now().isoformat()} ===\n")
+                f.write(out)
+        content = '\n'.join(merged)
+        return content, total_usage
+