bioguider 0.2.33__py3-none-any.whl → 0.2.34__py3-none-any.whl

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
+
 

bioguider/generation/llm_injector.py

@@ -115,13 +115,9 @@ class LLMErrorInjector:
             max_words=max_words,
         )
         output, _ = conv.generate(system_prompt=system_prompt, instruction_prompt="Return the JSON now.")
-        try:
-            data = json.loads(output)
-        except Exception:
-            # try to locate JSON block
-            start = output.find("{")
-            end = output.rfind("}")
-            data = json.loads(output[start:end+1]) if start != -1 and end != -1 else {"corrupted_markdown": readme_text, "errors": []}
+        
+        # Enhanced JSON parsing with better error handling
+        data = self._parse_json_output(output, readme_text)
         corrupted = data.get("corrupted_markdown", readme_text)
         # Validate output stays within original context; fallback to deterministic if invalid
         if not self._validate_corrupted(readme_text, corrupted, preserve_keywords):
@@ -133,6 +129,63 @@ class LLMErrorInjector:
         }
         return corrupted, manifest
 
+    def _parse_json_output(self, output: str, fallback_text: str) -> Dict[str, Any]:
+        """Enhanced JSON parsing with multiple fallback strategies."""
+        import re
+        
+        # Strategy 1: Direct JSON parsing
+        try:
+            return json.loads(output)
+        except json.JSONDecodeError:
+            pass
+        
+        # Strategy 2: Extract JSON block between ```json and ```
+        json_pattern = r'```(?:json)?\s*(\{.*?\})\s*```'
+        match = re.search(json_pattern, output, re.DOTALL)
+        if match:
+            try:
+                return json.loads(match.group(1))
+            except json.JSONDecodeError:
+                pass
+        
+        # Strategy 3: Find first complete JSON object
+        start = output.find("{")
+        if start != -1:
+            # Find matching closing brace
+            brace_count = 0
+            end = start
+            for i, char in enumerate(output[start:], start):
+                if char == "{":
+                    brace_count += 1
+                elif char == "}":
+                    brace_count -= 1
+                    if brace_count == 0:
+                        end = i
+                        break
+            
+            if brace_count == 0:  # Found complete JSON object
+                try:
+                    json_str = output[start:end+1]
+                    return json.loads(json_str)
+                except json.JSONDecodeError:
+                    pass
+        
+        # Strategy 4: Try to fix common JSON issues
+        try:
+            # Remove markdown code fences
+            cleaned = re.sub(r'```(?:json)?\s*', '', output)
+            cleaned = re.sub(r'```\s*$', '', cleaned)
+            # Remove leading/trailing whitespace
+            cleaned = cleaned.strip()
+            # Try parsing again
+            return json.loads(cleaned)
+        except json.JSONDecodeError:
+            pass
+        
+        # Strategy 5: Fallback to deterministic injection
+        print(f"Warning: Failed to parse LLM JSON output, using fallback. Output preview: {output[:200]}...")
+        return {"corrupted_markdown": fallback_text, "errors": []}
+
     def _extract_preserve_keywords(self, text: str) -> List[str]:
         # Extract capitalized terms, domain hyphenations, and hostnames in links
         kws: Set[str] = set()

bioguider/generation/suggestion_extractor.py

@@ -21,7 +21,7 @@ class SuggestionExtractor:
                             id=f"readme-dependencies-{file_name}",
                             category="readme.dependencies",
                             severity="should_fix",
-                            source={"section": "readme", "field": "dependency_suggestions", "evidence": dep_suggestions, "score": dep_score},
+                            source={"section": "readme", "field": "dependency_suggestions", "score": dep_score},
                             target_files=[file_name],
                             action="add_dependencies_section",
                             anchor_hint="Dependencies",
@@ -36,7 +36,7 @@ class SuggestionExtractor:
                             id=f"readme-hardware-{file_name}",
                             category="readme.hardware",
                             severity="should_fix",
-                            source={"section": "readme", "field": "hardware_and_software_spec_suggestions", "evidence": hw_sw_suggestions, "score": hw_sw_score},
+                            source={"section": "readme", "field": "hardware_and_software_spec_suggestions", "score": hw_sw_score},
                             target_files=[file_name],
                             action="add_system_requirements_section",
                             anchor_hint="System Requirements",
@@ -51,7 +51,7 @@ class SuggestionExtractor:
                             id=f"readme-purpose-{file_name}",
                             category="readme.purpose",
                             severity="should_fix",
-                            source={"section": "readme", "field": "project_purpose_suggestions", "evidence": purpose_suggestions, "score": purpose_score},
+                            source={"section": "readme", "field": "project_purpose_suggestions", "score": purpose_score},
                             target_files=[file_name],
                             action="full_replace",
                             anchor_hint="Overview",
@@ -66,7 +66,7 @@ class SuggestionExtractor:
                             id=f"readme-readability-{file_name}",
                             category="readme.readability",
                             severity="should_fix",
-                            source={"section": "readme", "field": "readability_suggestions", "evidence": readability_suggestions, "score": readability_score},
+                            source={"section": "readme", "field": "readability_suggestions", "score": readability_score},
                             target_files=[file_name],
                             action="full_replace",
                             anchor_hint="Introduction",
@@ -78,7 +78,7 @@ class SuggestionExtractor:
                         id=f"readme-intro-cleanup-{file_name}",
                         category="readme.intro_cleanup",
                         severity="should_fix",
-                        source={"section": "readme", "field": "overview", "evidence": "Improve top-level overview for clarity and tone.", "score": "Fair"},
+                        source={"section": "readme", "field": "overview", "score": "Fair"},
                         target_files=[file_name],
                         action="replace_intro",
                         anchor_hint="Overview",
@@ -92,7 +92,7 @@ class SuggestionExtractor:
                             id=f"readme-dependencies-clarify-{file_name}",
                             category="readme.dependencies",
                             severity="should_fix",
-                            source={"section": "readme", "field": "dependencies", "evidence": str(dep_sugg), "score": dep_score},
+                            source={"section": "readme", "field": "dependencies", "score": dep_score},
                             target_files=[file_name],
                             action="add_dependencies_section",
                             anchor_hint="Dependencies",
@@ -103,7 +103,7 @@ class SuggestionExtractor:
                             id=f"readme-dependencies-fallback-{file_name}",
                             category="readme.dependencies",
                             severity="should_fix",
-                            source={"section": "readme", "field": "dependencies", "evidence": f"score={dep_score}", "score": dep_score},
+                            source={"section": "readme", "field": "dependencies", "score": dep_score},
                             target_files=[file_name],
                             action="add_dependencies_section",
                             anchor_hint="Dependencies",
@@ -118,7 +118,7 @@ class SuggestionExtractor:
                             id=f"readme-sysreq-clarify-{file_name}",
                             category="readme.system_requirements",
                             severity="should_fix",
-                            source={"section": "readme", "field": "hardware_and_software", "evidence": str(hw_sugg), "score": hw_score},
+                            source={"section": "readme", "field": "hardware_and_software", "score": hw_score},
                             target_files=[file_name],
                             action="add_system_requirements_section",
                             anchor_hint="System Requirements",
@@ -129,7 +129,7 @@ class SuggestionExtractor:
                             id=f"readme-sysreq-fallback-{file_name}",
                             category="readme.system_requirements",
                             severity="should_fix",
-                            source={"section": "readme", "field": "hardware_and_software", "evidence": f"score={hw_score}", "score": hw_score},
+                            source={"section": "readme", "field": "hardware_and_software", "score": hw_score},
                             target_files=[file_name],
                             action="add_system_requirements_section",
                             anchor_hint="System Requirements",
@@ -144,7 +144,7 @@ class SuggestionExtractor:
                             id=f"readme-license-{file_name}",
                             category="readme.license",
                             severity="nice_to_have",
-                            source={"section": "readme", "field": "license", "evidence": str(lic_sugg)},
+                            source={"section": "readme", "field": "license"},
                             target_files=[file_name],
                             action="mention_license_section",
                             anchor_hint="License",
@@ -159,7 +159,7 @@ class SuggestionExtractor:
                             id=f"readme-structure-clarify-{file_name}",
                             category="readme.readability",
                             severity="should_fix",
-                            source={"section": "readability", "field": "readability_suggestions", "evidence": str(read_sugg), "score": read_score},
+                            source={"section": "readability", "field": "readability_suggestions", "score": read_score},
                             target_files=[file_name],
                             action="normalize_headings_structure",
                             anchor_hint="Installation",
@@ -170,7 +170,7 @@ class SuggestionExtractor:
                             id=f"readme-structure-fallback-{file_name}",
                             category="readme.readability",
                             severity="should_fix",
-                            source={"section": "readability", "field": "readability_score", "evidence": f"score={read_score}", "score": read_score},
+                            source={"section": "readability", "field": "readability_score", "score": read_score},
                             target_files=[file_name],
                             action="normalize_headings_structure",
                             anchor_hint="Installation",
@@ -182,7 +182,7 @@ class SuggestionExtractor:
                                 id=f"readme-usage-{file_name}",
                                 category="readme.usage",
                                 severity="nice_to_have",
-                                source={"section": "readability", "field": "usage", "evidence": "Add Usage section as suggested."},
+                                source={"section": "readability", "field": "usage"},
                                 target_files=[file_name],
                                 action="add_usage_section",
                                 anchor_hint="Usage",
@@ -208,7 +208,7 @@ class SuggestionExtractor:
                             id=f"install-full-replace-{target}",
                             category="installation.full_replace",
                             severity="should_fix",
-                            source={"section": "installation", "field": "overall", "evidence": str(structured)},
+                            source={"section": "installation", "field": "overall"},
                             target_files=[target],
                             action="full_replace",
                             anchor_hint=None,
@@ -235,7 +235,7 @@ class SuggestionExtractor:
                                     id=f"userguide-readability-{file_name}-{i}",
                                     category="userguide.readability",
                                     severity="should_fix",
-                                    source={"section": "userguide", "field": "readability_suggestions", "evidence": suggestion, "score": readability_score},
+                                    source={"section": "userguide", "field": "readability_suggestions", "score": readability_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint=f"Readability-{i+1}",
@@ -252,7 +252,7 @@ class SuggestionExtractor:
                                     id=f"userguide-context-{file_name}-{i}",
                                     category="userguide.context",
                                     severity="should_fix",
-                                    source={"section": "userguide", "field": "context_and_purpose_suggestions", "evidence": suggestion, "score": context_score},
+                                    source={"section": "userguide", "field": "context_and_purpose_suggestions", "score": context_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint=f"Context-{i+1}",
@@ -269,7 +269,7 @@ class SuggestionExtractor:
                                     id=f"userguide-error-{file_name}-{i}",
                                     category="userguide.error_handling",
                                     severity="should_fix",
-                                    source={"section": "userguide", "field": "error_handling_suggestions", "evidence": suggestion, "score": error_score},
+                                    source={"section": "userguide", "field": "error_handling_suggestions", "score": error_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint=f"Error-Handling-{i+1}",
@@ -284,7 +284,7 @@ class SuggestionExtractor:
                             id=f"userguide-consistency-{file_name}",
                             category="userguide.consistency",
                             severity="should_fix",
-                            source={"section": "userguide", "field": "consistency", "evidence": f"score={score}"},
+                            source={"section": "userguide", "field": "consistency", "score": score},
                             target_files=[file_name],
                             action="full_replace",
                             anchor_hint="Examples",
@@ -309,7 +309,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-readability-{file_name}-{i}",
                                     category="tutorial.readability",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "readability_suggestions", "evidence": suggestion, "score": readability_score},
+                                    source={"section": "tutorial", "field": "readability_suggestions", "score": readability_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Introduction",
@@ -326,7 +326,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-setup-{file_name}-{i}",
                                     category="tutorial.setup",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "setup_and_dependencies_suggestions", "evidence": suggestion, "score": setup_score},
+                                    source={"section": "tutorial", "field": "setup_and_dependencies_suggestions", "score": setup_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Setup",
@@ -343,7 +343,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-reproducibility-{file_name}-{i}",
                                     category="tutorial.reproducibility",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "reproducibility_suggestions", "evidence": suggestion, "score": reproducibility_score},
+                                    source={"section": "tutorial", "field": "reproducibility_suggestions", "score": reproducibility_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Setup",
@@ -360,7 +360,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-structure-{file_name}-{i}",
                                     category="tutorial.structure",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "structure_and_navigation_suggestions", "evidence": suggestion, "score": structure_score},
+                                    source={"section": "tutorial", "field": "structure_and_navigation_suggestions", "score": structure_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Introduction",
@@ -377,7 +377,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-code-{file_name}-{i}",
                                     category="tutorial.code_quality",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "executable_code_quality_suggestions", "evidence": suggestion, "score": code_score},
+                                    source={"section": "tutorial", "field": "executable_code_quality_suggestions", "score": code_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Code Examples",
@@ -394,7 +394,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-verification-{file_name}-{i}",
                                     category="tutorial.verification",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "result_verification_suggestions", "evidence": suggestion, "score": verification_score},
+                                    source={"section": "tutorial", "field": "result_verification_suggestions", "score": verification_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Results",
@@ -411,7 +411,7 @@ class SuggestionExtractor:
                                     id=f"tutorial-performance-{file_name}-{i}",
                                     category="tutorial.performance",
                                     severity="should_fix",
-                                    source={"section": "tutorial", "field": "performance_and_resource_notes_suggestions", "evidence": suggestion, "score": performance_score},
+                                    source={"section": "tutorial", "field": "performance_and_resource_notes_suggestions", "score": performance_score},
                                     target_files=[file_name],
                                     action="full_replace",
                                     anchor_hint="Performance",
@@ -424,7 +424,7 @@ class SuggestionExtractor:
                             id=f"tutorial-consistency-{file_name}",
                             category="tutorial.consistency",
                             severity="should_fix",
-                            source={"section": "tutorial", "field": "consistency", "evidence": f"score={score}"},
+                            source={"section": "tutorial", "field": "consistency", "score": score},
                             target_files=[file_name],
                             action="full_replace",
                             anchor_hint=None,

bioguider/managers/generation_manager.py

@@ -208,8 +208,7 @@ class DocumentationGenerationManager:
                     suggestions_list.append({
                         "suggestion_number": idx,
                         "category": s.category if hasattr(s, 'category') else "general",
-                        "content_guidance": s.content_guidance,
-                        "evidence": s.source.get("evidence", "") if s.source else ""
+                        "content_guidance": s.content_guidance
                     })
                 
                 merged_evaluation_report = {
@@ -233,11 +232,12 @@ class DocumentationGenerationManager:
                     f.write(f"Merged into single call: YES\n")
                     f.write(f"Suggestion IDs: {[s.id for s in file_suggestions]}\n\n")
                 
-                gen_content, gen_usage = self.llm_gen.generate_full_document(
-                    target_file=fpath,
-                    evaluation_report=merged_evaluation_report,
-                    context=original_content,
-                )
+                    gen_content, gen_usage = self.llm_gen.generate_full_document(
+                        target_file=fpath,
+                        evaluation_report=merged_evaluation_report,
+                        context=original_content,
+                        original_content=original_content,
+                    )
                 
                 # Debug: Log completion
                 with open(debug_log_file, 'a', encoding='utf-8') as f:
@@ -261,8 +261,9 @@ class DocumentationGenerationManager:
                             self.print_step(step_name="GeneratingContent", step_output=f"Fallback: Generating full document for {e.suggestion_id} using LLM...")
                             gen_content, gen_usage = self.llm_gen.generate_full_document(
                                 target_file=e.file_path,
-                                evaluation_report={"suggestion": suggestion.content_guidance, "evidence": suggestion.source.get("evidence", "") if suggestion.source else ""},
+                                evaluation_report={"suggestion": suggestion.content_guidance},
                                 context=original_content,
+                                original_content=original_content,
                             )
                             if isinstance(gen_content, str) and gen_content:
                                 self.print_step(step_name="LLMFullDoc", step_output=f"✓ Generated full document for {e.suggestion_id} ({gen_usage.get('total_tokens', 0)} tokens)")
@@ -495,7 +496,6 @@ class DocumentationGenerationManager:
             for e in edits:
                 sug = next((s for s in suggestions if s.id == e.suggestion_id), None)
                 guidance = sug.content_guidance if sug else ""
-                evidence = sug.source.get("evidence", "") if sug and sug.source else ""
                 section = e.anchor.get('value', 'General improvements')
                 
                 # Convert technical action names to user-friendly descriptions
@@ -567,61 +567,18 @@ class DocumentationGenerationManager:
                 
                 # Show evaluation reasoning that triggered this improvement
                 if sug and sug.source:
-                    evidence = sug.source.get("evidence", "")
                     score = sug.source.get("score", "")
                     category = sug.category or ""
                     
                     # Format category for display (e.g., "readme.dependencies" -> "Dependencies")
                     category_display = category.split('.')[-1].replace('_', ' ').title() if category else ""
                     
-                    if evidence:
-                        # Handle different evidence types
-                        if isinstance(evidence, dict):
-                            # Extract key information from dict evidence
-                            evidence_text = evidence.get("dependency_suggestions", "") or evidence.get("evidence", "")
-                            if not evidence_text:
-                                evidence_text = f"Installation evaluation: {evidence.get('overall_score', 'Unknown')} score"
-                        else:
-                            evidence_text = str(evidence)
-                            # Handle Python dict string evidence (from full_replace actions)
-                            if evidence_text.startswith("{") and evidence_text.endswith("}"):
-                                try:
-                                    import ast
-                                    evidence_dict = ast.literal_eval(evidence_text)
-                                    # Extract specific suggestions from the evaluation report
-                                    dep_sugg = evidence_dict.get("dependency_suggestions", "")
-                                    hw_req = evidence_dict.get("hardware_requirements", False)
-                                    compat_os = evidence_dict.get("compatible_os", True)
-                                    overall_score = evidence_dict.get("overall_score", "")
-                                    
-                                    # Build specific reason based on evaluation findings
-                                    reasons = []
-                                    if dep_sugg:
-                                        reasons.append(f"Dependencies: {dep_sugg}")
-                                    if hw_req is False:
-                                        reasons.append("Hardware requirements not specified")
-                                    if compat_os is False:
-                                        reasons.append("Operating system compatibility unclear")
-                                    if overall_score and overall_score not in ("Excellent", "Good"):
-                                        reasons.append(f"Overall score: {overall_score}")
-                                    
-                                    if reasons:
-                                        evidence_text = "; ".join(reasons)
-                                    else:
-                                        evidence_text = f"Installation evaluation score: {overall_score}"
-                                except:
-                                    evidence_text = "Installation documentation needs improvement"
-                        
-                        if score and category_display:
-                            lines.append(f"  - *Reason:* [{category_display} - {score}] {evidence_text}")
-                        elif score:
-                            lines.append(f"  - *Reason:* [{score}] {evidence_text}")
-                        elif category_display:
-                            lines.append(f"  - *Reason:* [{category_display}] {evidence_text}")
-                        else:
-                            lines.append(f"  - *Reason:* {evidence_text}")
+                    if score and category_display:
+                        lines.append(f"  - *Reason:* [{category_display} - {score}]")
                     elif score:
-                        lines.append(f"  - *Reason:* Evaluation score was '{score}' - needs improvement")
+                        lines.append(f"  - *Reason:* [{score}]")
+                    elif category_display:
+                        lines.append(f"  - *Reason:* [{category_display}]")
                 
                 # Show what was actually implemented (different from reason)
                 if guidance:

{bioguider-0.2.33.dist-info → bioguider-0.2.34.dist-info}/METADATA

@@ -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.dist-info → bioguider-0.2.34.dist-info}/RECORD

@@ -46,17 +46,17 @@ bioguider/generation/__init__.py,sha256=esV02QgCsY67-HBwSHDbA5AcbKzNRIT3wDwwh6N4
 bioguider/generation/change_planner.py,sha256=0N10jvkfn2J9b598FKOKPQecwmQv68yeuUvMZn81nOI,9715
 bioguider/generation/document_renderer.py,sha256=Md8NMo0CXNIqatWOdKE-_4k02Y3T_BCLmEPLTEiYUCA,7984
 bioguider/generation/llm_cleaner.py,sha256=qFgS5xi7bBO8HAJ9WFNzH3p9AhOsAkYjchKQHuAUWWM,2917
-bioguider/generation/llm_content_generator.py,sha256=DEgk4uAgZrxBTVEN3ZuhL7W-tBfXOyn2X4e9rM1Gfhc,39748
-bioguider/generation/llm_injector.py,sha256=bVxP6Asv2em4MBOB5yFsS14AuaeT7NLKQQMcsEqXjPY,17352
+bioguider/generation/llm_content_generator.py,sha256=iG8tDhZqzwu9NdJ2KrGdlHlC14u86nEe1mFxeZsWJMM,46696
+bioguider/generation/llm_injector.py,sha256=MAT4wrjTiG0In94khfo23TqtF71iur6eQKQNH9SBCB8,19295
 bioguider/generation/models.py,sha256=MlJOLjPHk8xs-UGW-TGN_M9cevTuxTG4tjm1d1L15go,2699
 bioguider/generation/output_manager.py,sha256=uwLyavND4kXOHlsXB0Berab3y8u6bhaEmQOQLl7wDAM,1963
 bioguider/generation/repo_reader.py,sha256=ivTURU61fR8er4ev7gSpOxER3FJv2d9GAx_X5JoVTvQ,1177
 bioguider/generation/report_loader.py,sha256=bxajeTDxod36iFsbSZhXSQjotxqP7LuAg5MC9OqX_p0,5911
 bioguider/generation/style_analyzer.py,sha256=Vn9FAK1qJBNLolLC1tz362k4UBaPl107BlvkQc8pV2I,983
-bioguider/generation/suggestion_extractor.py,sha256=kkPOYE6FXRtYlogV0GQdBraZZJm08I6Oux5YKGUF1UU,29442
+bioguider/generation/suggestion_extractor.py,sha256=UKQPUUEvbfJI-EuvH6O5DPRyRn8GaQMNvUWBkuuUhDk,28694
 bioguider/generation/test_metrics.py,sha256=ACXmSZc2L_UkkmC5h2s4tG44MXW1d-hClFwPCD5_BFI,7505
 bioguider/managers/evaluation_manager.py,sha256=7WlshfnqFkk34dDlf50qAINK5sFTaoCFE0f0vGYyRdc,5789
-bioguider/managers/generation_manager.py,sha256=m6hGu9_1HcL1YS0PMoFfXfVgDqsps1ahcj6L9E4jtoo,38636
+bioguider/managers/generation_manager.py,sha256=2l44jG4iErug51YQ1eMKIDudb7uy84VocwR4zyuL410,35454
 bioguider/managers/generation_test_manager.py,sha256=3mOBzQVpsLo_LpSspJcofn3CNtvgagS1DMr9Zuwkzq4,5307
 bioguider/rag/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bioguider/rag/config.py,sha256=5g4IqTzgyfZfax9Af9CTkXShgItPOt4_9TEMSekCPik,4602
@@ -74,7 +74,7 @@ bioguider/utils/pyphen_utils.py,sha256=cdZc3qphkvMDeL5NiZ8Xou13M_uVNP7ifJ-FwxO-0
 bioguider/utils/python_file_handler.py,sha256=BERiE2RHxpu3gAzv26jr8ZQetkrtnMZOv9SjpQ7WIdg,2650
 bioguider/utils/r_file_handler.py,sha256=y57Y04wjgtFWve0lPg1EOrNNOccPfnNF0z2WnlFMX74,19616
 bioguider/utils/utils.py,sha256=h8OhCjzLpHkb3ndnjRBUOBHD7csbHdEVNXf75SRN8Zc,4413
-bioguider-0.2.33.dist-info/LICENSE,sha256=qzkvZcKwwA5DuSuhXMOm2LcO6BdEr4V7jwFZVL2-jL4,1065
-bioguider-0.2.33.dist-info/METADATA,sha256=Yyqyvrm_CLNHy1fgDluqbCsePUqA_mYwkzRupFTHbRU,1962
-bioguider-0.2.33.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-bioguider-0.2.33.dist-info/RECORD,,
+bioguider-0.2.34.dist-info/LICENSE,sha256=qzkvZcKwwA5DuSuhXMOm2LcO6BdEr4V7jwFZVL2-jL4,1065
+bioguider-0.2.34.dist-info/METADATA,sha256=9uU3UneURALPzQ7WoE2w4HhEy8ALUHQ2SXBq-sds2p8,1962
+bioguider-0.2.34.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+bioguider-0.2.34.dist-info/RECORD,,