bioguider 0.2.52__py3-none-any.whl

bioguider/generation/change_planner.py

@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+from typing import List, Dict
+
+from .models import SuggestionItem, StyleProfile, DocumentPlan, PlannedEdit
+
+
+class ChangePlanner:
+    def build_plan(
+        self,
+        repo_path: str,
+        style: StyleProfile,
+        suggestions: List[SuggestionItem],
+        available_files: Dict[str, str],
+    ) -> DocumentPlan:
+        planned: List[PlannedEdit] = []
+        seen_headers: set[tuple[str, str]] = set()
+
+        def section_header(title: str) -> str:
+            # use heading level 2 for inserts to be safe
+            h = style.heading_style or "#"
+            return f"{h*2} {title}\n\n"
+
+        for s in suggestions:
+            for target in s.target_files:
+                if target not in available_files:
+                    # allow planning; renderer will skip if missing
+                    pass
+
+                if s.action == "add_dependencies_section":
+                    # Use LLM generation instead of template
+                    header_key = (target, (s.anchor_hint or "Dependencies").strip().lower())
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "Dependencies"},
+                        content_template="",  # Will be generated by LLM
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "add_system_requirements_section":
+                    # Use LLM generation instead of template
+                    header_key = (target, (s.anchor_hint or "System Requirements").strip().lower())
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "System Requirements"},
+                        content_template="",  # Will be generated by LLM
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "mention_license_section":
+                    content = section_header("License") + "This project is released under the MIT License. See LICENSE for details.\n"
+                    header_key = (target, (s.anchor_hint or "License").strip().lower())
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "License"},
+                        content_template=content,
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "normalize_headings_structure":
+                    # Minimal placeholder: avoid heavy rewrites
+                    # Plan a no-op or a small note; actual normalization could be added later
+                    continue
+                elif s.action == "add_usage_section":
+                    content = section_header("Usage") + "- Brief example of typical workflow.\n"
+                    header_key = (target, "usage")
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": "Usage"},
+                        content_template=content,
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "replace_intro":
+                    # Replace intro block (between H1 and first H2) with a clean Overview section
+                    # Use empty content_template so LLM can generate content based on guidance
+                    header_key = (target, "overview")
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="replace_intro_block",
+                        anchor={"type": "header", "value": "Overview"},
+                        content_template="",  # Will be filled by LLM generation
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "clarify_mandatory_vs_optional":
+                    # Use specific guidance from evaluation report instead of generic template
+                    guidance = s.content_guidance or "Specify compatibility details for dependencies across operating systems and architectures."
+                    content = section_header("Dependencies") + f"- {guidance}\n"
+                    header_key = (target, "dependencies")
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": "Dependencies"},
+                        content_template=content,
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "add_hardware_requirements":
+                    # Use LLM generation instead of template
+                    header_key = (target, (s.anchor_hint or "Hardware Requirements").strip().lower())
+                    if header_key in seen_headers:
+                        continue
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "Hardware Requirements"},
+                        content_template="",  # Will be generated by LLM
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                    seen_headers.add(header_key)
+                elif s.action == "improve_clarity_and_error_handling":
+                    # Handle targeted improvements to user guides
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "Introduction"},
+                        content_template="",  # Will be filled by LLM generation
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                elif s.action == "improve_consistency":
+                    # Handle consistency improvements
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "Examples"},
+                        content_template="",  # Will be filled by LLM generation
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                elif s.action == "improve_tutorial_quality":
+                    # Handle tutorial quality improvements
+                    planned.append(PlannedEdit(
+                        file_path=target,
+                        edit_type="append_section",
+                        anchor={"type": "header", "value": s.anchor_hint or "Setup"},
+                        content_template="",  # Will be filled by LLM generation
+                        rationale=s.source.get("evidence", ""),
+                        suggestion_id=s.id,
+                    ))
+                # All actions now use full_replace mode
+                planned.append(PlannedEdit(
+                    file_path=target,
+                    edit_type="full_replace",
+                    anchor={"type": "document", "value": "full_document"},
+                    content_template="",  # Will be filled by LLM generation
+                    rationale=s.source.get("evidence", ""),
+                    suggestion_id=s.id,
+                ))
+
+        # If a file is planned for full_replace, suppress other edits for that file to avoid redundancy
+        by_file: Dict[str, List[PlannedEdit]] = {}
+        for e in planned:
+            by_file.setdefault(e.file_path, []).append(e)
+        filtered: List[PlannedEdit] = []
+        for fpath, edits in by_file.items():
+            has_full = any(e.edit_type == "full_replace" for e in edits)
+            if has_full:
+                filtered.extend([e for e in edits if e.edit_type == "full_replace"])
+            else:
+                filtered.extend(edits)
+
+        return DocumentPlan(repo_path=repo_path, style_profile=style, planned_edits=filtered)
+
+

bioguider/generation/document_renderer.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+from .models import PlannedEdit
+
+
+class DocumentRenderer:
+    def apply_edit(self, original: str, edit: PlannedEdit) -> Tuple[str, dict]:
+        content = original
+        added = 0
+
+        if edit.edit_type == "append_section":
+            # Avoid duplicate header if the same header already exists
+            header_line = None
+            if edit.content_template.lstrip().startswith("#"):
+                header_line = edit.content_template.strip().splitlines()[0].strip()
+            if header_line and header_line in content:
+                return content, {"added_lines": 0}
+            # Append with two leading newlines if needed
+            sep = "\n\n" if not content.endswith("\n\n") else ""
+            content = f"{content}{sep}{edit.content_template}"
+            added = len(edit.content_template.splitlines())
+
+        elif edit.edit_type == "replace_intro_block":
+            # Replace content from start to first level-2 header (##) with new intro
+            lines = content.splitlines()
+            end_idx = None
+            for i, ln in enumerate(lines):
+                if ln.strip().startswith("## "):
+                    end_idx = i
+                    break
+            if end_idx is None:
+                # No H2 header found; replace entire content
+                new_content = edit.content_template
+            else:
+                head = lines[:0]
+                tail = lines[end_idx:]
+                new_content = edit.content_template.rstrip() + "\n\n" + "\n".join(tail)
+            added = len(edit.content_template.splitlines())
+            content = new_content
+
+        elif edit.edit_type == "insert_after_header":
+            # Insert content after a specific header, but integrate naturally
+            header_value = edit.anchor.get("value", "")
+            if header_value:
+                lines = content.splitlines()
+                insert_idx = None
+                for i, line in enumerate(lines):
+                    if line.strip().startswith("#") and header_value.lower() in line.lower():
+                        # Find a good insertion point after the header and its immediate content
+                        insert_idx = i + 1
+                        # Skip empty lines and find the first substantial content
+                        while insert_idx < len(lines) and lines[insert_idx].strip() == "":
+                            insert_idx += 1
+                        # Insert after the first code block or paragraph, but before next major section
+                        while insert_idx < len(lines):
+                            line_content = lines[insert_idx].strip()
+                            if line_content.startswith("#") and not line_content.startswith("###"):
+                                break
+                            if line_content.startswith("```") and insert_idx > 0:
+                                # Found end of code block, insert after it
+                                insert_idx += 1
+                                break
+                            insert_idx += 1
+                        break
+                
+                if insert_idx is not None:
+                    # Insert the new content with minimal formatting
+                    new_content_lines = edit.content_template.splitlines()
+                    # Remove standalone headers to avoid creating new major sections
+                    filtered_lines = []
+                    for line in new_content_lines:
+                        if line.strip().startswith("## ") and len(line.strip()) < 50:
+                            # Convert major headers to minor explanations
+                            header_text = line.strip()[3:].strip()
+                            filtered_lines.append(f"\n**Note:** {header_text.lower()}")
+                        else:
+                            filtered_lines.append(line)
+                    
+                    # Insert with minimal spacing
+                    new_lines = lines[:insert_idx] + [""] + filtered_lines + lines[insert_idx:]
+                    content = "\n".join(new_lines)
+                    added = len(filtered_lines)
+                else:
+                    # Header not found, append at end
+                    sep = "\n\n" if not content.endswith("\n\n") else ""
+                    content = f"{content}{sep}{edit.content_template}"
+                    added = len(edit.content_template.splitlines())
+            else:
+                # No header specified, append at end
+                sep = "\n\n" if not content.endswith("\n\n") else ""
+                content = f"{content}{sep}{edit.content_template}"
+                added = len(edit.content_template.splitlines())
+
+        elif edit.edit_type == "rmarkdown_integration":
+            # Special handling for RMarkdown files - integrate content naturally
+            header_value = edit.anchor.get("value", "")
+            if header_value:
+                lines = content.splitlines()
+                insert_idx = None
+                for i, line in enumerate(lines):
+                    if line.strip().startswith("#") and header_value.lower() in line.lower():
+                        # Find insertion point after the first code block in this section
+                        insert_idx = i + 1
+                        while insert_idx < len(lines):
+                            line_content = lines[insert_idx].strip()
+                            if line_content.startswith("```") and insert_idx > 0:
+                                # Found code block, insert after it
+                                insert_idx += 1
+                                break
+                            if line_content.startswith("#") and not line_content.startswith("###"):
+                                # Next major section, insert before it
+                                break
+                            insert_idx += 1
+                        break
+                
+                if insert_idx is not None:
+                    # Process content to be more contextual
+                    new_content_lines = edit.content_template.splitlines()
+                    contextual_lines = []
+                    
+                    for line in new_content_lines:
+                        # Convert standalone sections to contextual notes
+                        if line.strip().startswith("## "):
+                            header_text = line.strip()[3:].strip()
+                            contextual_lines.append(f"\n**Note:** For this tutorial, {header_text.lower()}")
+                        elif line.strip().startswith("# "):
+                            header_text = line.strip()[2:].strip()
+                            contextual_lines.append(f"\n**Important:** {header_text.lower()}")
+                        else:
+                            contextual_lines.append(line)
+                    
+                    # Insert with minimal disruption
+                    new_lines = lines[:insert_idx] + [""] + contextual_lines + lines[insert_idx:]
+                    content = "\n".join(new_lines)
+                    added = len(contextual_lines)
+                else:
+                    # Fallback to append
+                    sep = "\n\n" if not content.endswith("\n\n") else ""
+                    content = f"{content}{sep}{edit.content_template}"
+                    added = len(edit.content_template.splitlines())
+            else:
+                sep = "\n\n" if not content.endswith("\n\n") else ""
+                content = f"{content}{sep}{edit.content_template}"
+                added = len(edit.content_template.splitlines())
+
+        elif edit.edit_type == "full_replace":
+            # Replace entire document content
+            content = edit.content_template
+            added = len(edit.content_template.splitlines())
+
+        # Other edit types (replace_block) can be added as needed
+
+        return content, {"added_lines": added}
+
+

bioguider/generation/llm_cleaner.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from langchain_openai.chat_models.base import BaseChatOpenAI
+
+from bioguider.agents.common_conversation import CommonConversation
+
+
+CLEANUP_PROMPT = """
+You are "BioGuider," a precise editor for biomedical/bioinformatics documentation.
+
+TASK
+Given a documentation file (README, RMarkdown, or other), produce a corrected version that:
+- Fixes typos, grammar, capitalization, and spacing
+- Corrects malformed markdown (headers, lists, links, code fences)
+- Repairs or normalizes link formatting; keep URLs absolute if present
+- Removes duplicated sections or repeated content; consolidate if needed
+- Preserves technical accuracy and biomedical domain terminology (do not invent features)
+- Keeps tone neutral and professional; avoid marketing language
+- Preserves all valid information; do not delete content unless it is a duplicate or malformed
+- For RMarkdown files (.Rmd): Preserve YAML frontmatter, R code chunks, and existing structure exactly
+
+CRITICAL REQUIREMENTS:
+- Do NOT wrap the entire document in markdown code fences (```markdown). Return pure content only.
+- If the document starts with ```markdown and ends with ```, remove these fences completely.
+- Do NOT modify YAML frontmatter in RMarkdown files
+- Do NOT modify R code chunks (```{r} blocks) in RMarkdown files
+- Do NOT change the overall structure or organization of the document
+
+ABSOLUTELY FORBIDDEN - REMOVE THESE COMPLETELY:
+- Any summary sections, concluding statements, or notes at the end of documents
+- Phrases like "Happy analyzing!", "Ensure all dependencies are up-to-date", "This concludes", "For more information"
+- Any text that appears to be AI-generated summaries or conclusions
+- Sentences starting with "Note:", "Remember:", "Important:", "Tip:", "Warning:" at the end
+- Any text after the last substantive content section
+- Phrases like "Happy coding!", "Good luck!", "Enjoy!", "Have fun!"
+- Any concluding remarks, final thoughts, or wrap-up statements
+- Text that sounds like AI-generated advice or encouragement
+
+DOCUMENT ENDING RULES:
+- The document must end naturally with the last substantive content section
+- Do NOT add any concluding statements, summaries, or notes
+- If the original document had a natural ending, preserve it exactly
+- If AI-added content appears at the end, remove it completely
+
+INPUT
+<<DOCUMENT>>
+{doc}
+<</DOCUMENT>>
+
+OUTPUT
+Return ONLY the revised content (no commentary, no explanations, no code fences).
+"""
+
+
+class LLMCleaner:
+    def __init__(self, llm: BaseChatOpenAI):
+        self.llm = llm
+
+    def clean_readme(self, content: str) -> tuple[str, dict]:
+        conv = CommonConversation(self.llm)
+        output, token_usage = conv.generate(
+            system_prompt=CLEANUP_PROMPT.format(doc=content[:30000]),
+            instruction_prompt="Provide the corrected documentation content only.",
+        )
+        return output.strip(), token_usage
+
+