bioguider 0.2.19__py3-none-any.whl → 0.2.21__py3-none-any.whl

bioguider/generation/document_renderer.py

@@ -0,0 +1,47 @@
+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
+
+        # Other edit types (insert_after_header, replace_block) can be added as needed
+
+        return content, {"added_lines": added}
+
+

bioguider/generation/llm_cleaner.py

@@ -0,0 +1,43 @@
+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 full README markdown, 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
+
+INPUT
+<<README>>
+{readme}
+<</README>>
+
+OUTPUT
+Return ONLY the revised markdown (no commentary, no explanations).
+"""
+
+
+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(readme=content[:30000]),
+            instruction_prompt="Provide the corrected README markdown only.",
+        )
+        return output.strip(), token_usage
+
+

bioguider/generation/llm_content_generator.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import Dict
+from langchain_openai.chat_models.base import BaseChatOpenAI
+
+from bioguider.agents.common_conversation import CommonConversation
+from .models import StyleProfile, SuggestionItem
+
+
+LLM_SECTION_PROMPT = """
+You are “BioGuider,” a concise documentation generator for biomedical/bioinformatics software.
+
+GOAL
+Write or refine a single documentation section named "{section}". Produce minimal, style-consistent content that addresses only this section.
+
+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}>>
+
+STYLE & CONSTRAINTS
+- Preserve the existing tone and style markers: {tone_markers}
+- Use heading style "{heading_style}" and list style "{list_style}"; link style "{link_style}".
+- Neutral, professional tone; avoid marketing claims.
+- Omit details you cannot substantiate from inputs/context; do not invent.
+- Prefer bullets; keep it short and skimmable.
+- Biomedical examples must avoid PHI; assume de-identified data.
+- Output must be plain markdown for this section only, with no commentary and no backticks.
+- Avoid duplication: if similar content exists in the repo context, rewrite succinctly instead of repeating.
+
+SECTION GUIDELINES
+- Dependencies: short bullet list; clearly separate Mandatory and Optional if applicable; avoid version numbers unless present in context.
+- System Requirements: runtime versions and supported OS; add hardware notes only if guidance provides specifics.
+- Hardware Requirements: brief bullets with RAM/CPU only if guidance includes numbers.
+- License: one sentence referencing the license and pointing to the LICENSE file.
+- Install (clarify dependencies): bullets under Mandatory and Optional.
+- If the section does not fit the above, produce a concise, accurate subsection aligned with the repo’s style.
+
+OUTPUT FORMAT
+- Return only the section markdown (no code fences).
+- Start with a level-2 header: "## {anchor_title}" unless the content already starts with a header.
+"""
+
+
+class LLMContentGenerator:
+    def __init__(self, llm: BaseChatOpenAI):
+        self.llm = llm
+
+    def generate_section(self, suggestion: SuggestionItem, style: StyleProfile, context: str = "") -> tuple[str, dict]:
+        conv = CommonConversation(self.llm)
+        section_name = suggestion.anchor_hint or suggestion.category.split(".")[-1].replace("_", " ").title()
+        system_prompt = LLM_SECTION_PROMPT.format(
+            tone_markers=", ".join(style.tone_markers or []),
+            heading_style=style.heading_style,
+            list_style=style.list_style,
+            link_style=style.link_style,
+            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
+
+

bioguider/generation/llm_injector.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import json
+from typing import Tuple, Dict, Any, List, Set
+import re
+from difflib import SequenceMatcher
+
+from langchain_openai.chat_models.base import BaseChatOpenAI
+from bioguider.agents.common_conversation import CommonConversation
+from bioguider.utils.utils import escape_braces
+
+
+INJECTION_PROMPT = """
+You are “BioGuider-Intro,” generating a deliberately flawed **INTRODUCTION** file
+(“README-lite”) to test an auto-fixer. Start from the provided clean INTRO doc that follows the
+BioGuider Intro structure (What is it? / What can it do? / Requirements / Install / Quick example /
+Learn more / License & Contact). Produce a corrupted version with small, realistic defects.
+
+GOAL
+Introduce subtle but meaningful issues while keeping the document recognizably the same.
+
+ERROR CATEGORIES (inject all)
+- typo: spelling/grammar/punctuation mistakes
+- link: malformed URL, wrong domain, or stray spaces in URL
+- duplicate: duplicate a short line/section fragment
+- bio_term: slightly wrong domain term (e.g., “single sell” for “single cell”); do not invent new science
+- function: misspell a known function/API name **from the input README-lite only**
+- markdown_structure: break a header level, list indentation, or code fence (one-off)
+
+CONSTRAINTS
+- Keep edits minimal and local; **≥85% token overlap** with input.
+- **Preserve section ORDER and TITLES** from the Intro spec:
+  1) # <project_name>
+     _<tagline>_
+  2) What is it?
+  3) What can it do?
+  4) Requirements
+  5) Install
+  6) Quick example
+  7) Learn more
+  8) License & Contact
+- Do **not** add or remove top-level sections. Subtle line-level corruption only.
+- Maintain a **concise length** (≤ {max_words} words).
+- Do **not** alter the protected keywords (exact casing/spelling): {keywords}
+- Keep at least **{min_per_category} errors per category** listed above.
+- If the input contains runnable code, keep it mostly intact but introduce **one** realistic break
+  (e.g., missing quote/paren or wrong function name) without adding new libraries.
+- Keep at least one **valid** URL so the fixer can compare.
+- Do not change the project identity, domain, or language.
+- Do not include markers, explanations, or commentary in the corrupted markdown.
+
+INPUT INTRO (clean README-lite)
+<<INTRO>>
+{readme}
+<</INTRO>>
+
+OUTPUT (JSON only):
+{{
+  "corrupted_markdown": "<the entire corrupted INTRO as markdown>",
+  "errors": [
+    {{
+      "id": "e1",
+      "category": "typo|link|duplicate|bio_term|function|markdown_structure",
+      "rationale": "why this mutation is realistic",
+      "original_snippet": "<verbatim snippet from input>",
+      "mutated_snippet": "<verbatim mutated text>"
+    }}
+    // include one entry per individual mutation you applied
+  ]
+}}
+"""
+
+
+class LLMErrorInjector:
+    def __init__(self, llm: BaseChatOpenAI):
+        self.llm = llm
+
+    def inject(self, readme_text: str, min_per_category: int = 3, preserve_keywords: list[str] | None = None, max_words: int = 450) -> Tuple[str, Dict[str, Any]]:
+        conv = CommonConversation(self.llm)
+        preserve_keywords = preserve_keywords or self._extract_preserve_keywords(readme_text)
+        system_prompt = escape_braces(INJECTION_PROMPT).format(
+            readme=readme_text[:30000],
+            min_per_category=min_per_category,
+            keywords=", ".join(preserve_keywords) if preserve_keywords else "",
+            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": []}
+        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):
+            corrupted, data = self._deterministic_inject(readme_text)
+        # Supplement to satisfy minimum per-category counts using deterministic local edits
+        corrupted, data = self._supplement_errors(readme_text, corrupted, data, min_per_category)
+        manifest = {
+            "errors": data.get("errors", []),
+        }
+        return corrupted, manifest
+
+    def _extract_preserve_keywords(self, text: str) -> List[str]:
+        # Extract capitalized terms, domain hyphenations, and hostnames in links
+        kws: Set[str] = set()
+        for m in re.finditer(r"\b[A-Z][A-Za-z0-9\-/]{2,}(?:\s[A-Z][A-Za-z0-9\-/]{2,})*\b", text):
+            term = m.group(0)
+            if len(term) <= 40:
+                kws.add(term)
+        for m in re.finditer(r"\b[\w]+-[\w]+\b", text):
+            if any(ch.isalpha() for ch in m.group(0)):
+                kws.add(m.group(0))
+        for m in re.finditer(r"https?://([^/\s)]+)", text):
+            kws.add(m.group(1))
+        # Keep a small set to avoid over-constraining
+        out = list(kws)[:20]
+        return out
+
+    def _validate_corrupted(self, baseline: str, corrupted: str, preserve_keywords: List[str]) -> bool:
+        # Similarity threshold
+        ratio = SequenceMatcher(None, baseline, corrupted).ratio()
+        if ratio < 0.7:
+            return False
+        # Preserve keywords
+        for k in preserve_keywords:
+            if k and k not in corrupted:
+                return False
+        # No new top-level sections
+        base_h2 = set([ln.strip() for ln in baseline.splitlines() if ln.strip().startswith("## ")])
+        corr_h2 = set([ln.strip() for ln in corrupted.splitlines() if ln.strip().startswith("## ")])
+        if not corr_h2.issubset(base_h2.union({"## Overview", "## Hardware Requirements", "## License", "## Usage", "## Dependencies", "## System Requirements"})):
+            return False
+        # New token ratio
+        btoks = set(re.findall(r"[A-Za-z0-9_\-]+", baseline.lower()))
+        ctoks = set(re.findall(r"[A-Za-z0-9_\-]+", corrupted.lower()))
+        new_ratio = len(ctoks - btoks) / max(1, len(ctoks))
+        if new_ratio > 0.25:
+            return False
+        return True
+
+    def _deterministic_inject(self, baseline: str) -> Tuple[str, Dict[str, Any]]:
+        errors: List[Dict[str, Any]] = []
+        text = baseline
+        # typo
+        if "successfully" in text:
+            text = text.replace("successfully", "succesfully", 1)
+            errors.append({"id": "e_typo_1", "category": "typo", "original_snippet": "successfully", "mutated_snippet": "succesfully", "rationale": "common misspelling"})
+        elif "installation" in text:
+            text = text.replace("installation", "instalation", 1)
+            errors.append({"id": "e_typo_1", "category": "typo", "original_snippet": "installation", "mutated_snippet": "instalation", "rationale": "common misspelling"})
+        # link
+        m = re.search(r"\]\(https?://[^)]+\)", text)
+        if m:
+            broken = m.group(0).replace("https://", "https//")
+            text = text.replace(m.group(0), broken, 1)
+            errors.append({"id": "e_link_1", "category": "link", "original_snippet": m.group(0), "mutated_snippet": broken, "rationale": "missing colon in scheme"})
+        # duplicate a small section (next header and paragraph)
+        lines = text.splitlines()
+        dup_idx = next((i for i, ln in enumerate(lines) if ln.strip().startswith("## ")), None)
+        if dup_idx is not None:
+            block = lines[dup_idx: min(len(lines), dup_idx+5)]
+            text = "\n".join(lines + ["", *block])
+            errors.append({"id": "e_dup_1", "category": "duplicate", "original_snippet": "\n".join(block), "mutated_snippet": "\n".join(block), "rationale": "duplicated section"})
+        # markdown structure: break a header
+        if "\n# " in text:
+            text = text.replace("\n# ", "\n#", 1)
+            errors.append({"id": "e_md_1", "category": "markdown_structure", "original_snippet": "\n# ", "mutated_snippet": "\n#", "rationale": "missing space in header"})
+        return text, {"errors": errors}
+
+    def _supplement_errors(self, baseline: str, corrupted: str, data: Dict[str, Any], min_per_category: int) -> Tuple[str, Dict[str, Any]]:
+        errors: List[Dict[str, Any]] = data.get("errors", []) or []
+        cat_counts: Dict[str, int] = {}
+        for e in errors:
+            cat = e.get("category", "")
+            cat_counts[cat] = cat_counts.get(cat, 0) + 1
+
+        def need(cat: str) -> int:
+            return max(0, min_per_category - cat_counts.get(cat, 0))
+
+        # typo supplements
+        for _ in range(need("typo")):
+            m = re.search(r"\b(installation|successfully|analysis|documentation|maintained|example|requirements|license|tutorials)\b", corrupted, flags=re.I)
+            if not m:
+                m = re.search(r"\b[A-Za-z]{6,}\b", corrupted)
+            if not m:
+                break
+            orig = m.group(0)
+            mut = orig[:-1] if len(orig) > 3 else orig + "e"
+            corrupted = corrupted.replace(orig, mut, 1)
+            errors.append({"id": f"e_typo_sup_{len(errors)}", "category": "typo", "original_snippet": orig, "mutated_snippet": mut, "rationale": "minor misspelling"})
+
+        # link supplements
+        for _ in range(need("link")):
+            m = re.search(r"\[[^\]]+\]\(https?://[^)]+\)", corrupted)
+            if not m:
+                break
+            orig = m.group(0)
+            mut = orig.replace("https://", "https//", 1)
+            if mut == orig:
+                mut = orig.replace("http://", "http//", 1)
+            corrupted = corrupted.replace(orig, mut, 1)
+            errors.append({"id": f"e_link_sup_{len(errors)}", "category": "link", "original_snippet": orig, "mutated_snippet": mut, "rationale": "scheme colon removed"})
+
+        # duplicate supplements
+        for _ in range(need("duplicate")):
+            lines = corrupted.splitlines()
+            idx = next((i for i, ln in enumerate(lines) if ln.strip().startswith("- ") or ln.strip().startswith("## ")), None)
+            if idx is None:
+                break
+            frag = lines[idx]
+            lines = lines[:idx+1] + [frag] + lines[idx+1:]
+            corrupted = "\n".join(lines)
+            errors.append({"id": f"e_dup_sup_{len(errors)}", "category": "duplicate", "original_snippet": frag, "mutated_snippet": frag, "rationale": "line duplicated"})
+
+        # bio_term supplements
+        bio_swaps = [(r"single cell", "single sell"), (r"genomics", "genomis"), (r"spatial", "spacial")]
+        for _ in range(need("bio_term")):
+            made = False
+            for pat, rep in bio_swaps:
+                m = re.search(pat, corrupted, flags=re.I)
+                if m:
+                    orig = m.group(0)
+                    mut = rep if orig.islower() else rep.title()
+                    corrupted = corrupted.replace(orig, mut, 1)
+                    errors.append({"id": f"e_bio_sup_{len(errors)}", "category": "bio_term", "original_snippet": orig, "mutated_snippet": mut, "rationale": "common domain typo"})
+                    made = True
+                    break
+            if not made:
+                break
+
+        # function supplements
+        for _ in range(need("function")):
+            m = re.search(r"\b([A-Za-z_][A-Za-z0-9_]*)\(", corrupted)
+            if not m:
+                break
+            fname = m.group(1)
+            if len(fname) > 3:
+                mut = fname[:-1]
+            else:
+                mut = fname + "x"
+            orig = fname + "("
+            mutated = mut + "("
+            corrupted = corrupted.replace(orig, mutated, 1)
+            errors.append({"id": f"e_func_sup_{len(errors)}", "category": "function", "original_snippet": orig, "mutated_snippet": mutated, "rationale": "misspelled API name"})
+
+        # markdown_structure supplements
+        for _ in range(need("markdown_structure")):
+            m = re.search(r"^## \s*", corrupted, flags=re.M)
+            if m:
+                orig = m.group(0)
+                mut = orig.replace("## ", "##", 1)
+                corrupted = corrupted.replace(orig, mut, 1)
+                errors.append({"id": f"e_md_sup_{len(errors)}", "category": "markdown_structure", "original_snippet": orig, "mutated_snippet": mut, "rationale": "removed header space"})
+            else:
+                fence = re.search(r"```[A-Za-z]*\n[\s\S]*?```", corrupted)
+                if fence:
+                    block = fence.group(0)
+                    mut = block.rstrip("`")  # drop a backtick
+                    corrupted = corrupted.replace(block, mut, 1)
+                    errors.append({"id": f"e_md_sup_{len(errors)}", "category": "markdown_structure", "original_snippet": block[:10], "mutated_snippet": mut[:10], "rationale": "broken code fence"})
+                else:
+                    break
+
+        data["errors"] = errors
+        return corrupted, data
+
+

bioguider/generation/models.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Optional, List, Dict, Any
+from pydantic import BaseModel, Field
+
+
+class EvaluationReport(BaseModel):
+    timestamp: Optional[str] = None
+    repo_url: Optional[str] = None
+
+    installation_evaluation: Optional[Dict[str, Any]] = None
+    installation_files: Optional[List[str]] = None
+
+    readme_evaluation: Optional[Dict[str, Any]] = None
+    readme_files: Optional[List[str]] = None
+
+    submission_requirements_evaluation: Optional[Dict[str, Any]] = None
+    submission_requirements_files: Optional[List[str]] = None
+
+
+class SuggestionItem(BaseModel):
+    id: str
+    category: str
+    severity: str = Field(default="should_fix")
+    source: Dict[str, str] = Field(default_factory=dict)
+    target_files: List[str] = Field(default_factory=list)
+    action: str
+    anchor_hint: Optional[str] = None
+    content_guidance: Optional[str] = None
+
+
+class StyleProfile(BaseModel):
+    heading_style: str = Field(default="#")
+    list_style: str = Field(default="-")
+    code_fence_style: str = Field(default="```")
+    tone_markers: List[str] = Field(default_factory=list)
+    link_style: str = Field(default="inline")
+
+
+class PlannedEdit(BaseModel):
+    file_path: str
+    edit_type: str
+    anchor: Dict[str, str] = Field(default_factory=dict)
+    content_template: str
+    rationale: str
+    minimal_diff: bool = Field(default=True)
+    suggestion_id: Optional[str] = None
+
+
+class DocumentPlan(BaseModel):
+    repo_path: str
+    style_profile: StyleProfile
+    planned_edits: List[PlannedEdit] = Field(default_factory=list)
+
+
+class OutputArtifact(BaseModel):
+    dest_rel_path: str
+    original_rel_path: str
+    change_summary: str
+    diff_stats: Dict[str, int] = Field(default_factory=dict)
+
+
+class GenerationManifest(BaseModel):
+    repo_url: Optional[str] = None
+    report_path: Optional[str] = None
+    output_dir: Optional[str] = None
+    suggestions: List[SuggestionItem] = Field(default_factory=list)
+    planned_edits: List[PlannedEdit] = Field(default_factory=list)
+    artifacts: List[OutputArtifact] = Field(default_factory=list)
+    skipped: List[str] = Field(default_factory=list)
+
+class GenerationReport(BaseModel):
+    repo_url: Optional[str] = None
+    output_dir: Optional[str] = None
+    sections: List[Dict[str, Any]] = Field(default_factory=list)
+
+

bioguider/generation/output_manager.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import os
+import json
+from datetime import datetime
+from typing import Dict, List, Tuple
+
+from .models import OutputArtifact, GenerationManifest, PlannedEdit
+
+
+class OutputManager:
+    def __init__(self, base_outputs_dir: str = "outputs"):
+        self.base_outputs_dir = base_outputs_dir
+
+    def prepare_output_dir(self, repo_url_or_name: str) -> str:
+        repo_name = self._extract_repo_name(repo_url_or_name)
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        out_dir = os.path.join(self.base_outputs_dir, f"{repo_name}", timestamp)
+        os.makedirs(out_dir, exist_ok=True)
+        return out_dir
+
+    def _extract_repo_name(self, url_or_name: str) -> str:
+        name = url_or_name.rstrip("/")
+        if "/" in name:
+            name = name.split("/")[-1]
+        name = name.replace(".git", "")
+        return name
+
+    def write_files(self, output_dir: str, files: Dict[str, str], diff_stats_by_file: Dict[str, dict] | None = None) -> List[OutputArtifact]:
+        artifacts: List[OutputArtifact] = []
+        for rel_path, content in files.items():
+            dest = os.path.join(output_dir, rel_path)
+            os.makedirs(os.path.dirname(dest), exist_ok=True)
+            with open(dest, "w", encoding="utf-8") as fobj:
+                fobj.write(content)
+            artifacts.append(OutputArtifact(
+                dest_rel_path=rel_path,
+                original_rel_path=rel_path,
+                change_summary="revised document",
+                diff_stats=(diff_stats_by_file or {}).get(rel_path, {})
+            ))
+        return artifacts
+
+    def write_manifest(
+        self,
+        output_dir: str,
+        manifest: GenerationManifest,
+    ) -> str:
+        dest = os.path.join(output_dir, "manifest.json")
+        with open(dest, "w", encoding="utf-8") as fobj:
+            json.dump(manifest.model_dump(), fobj, indent=2)
+        return dest
+
+

bioguider/generation/repo_reader.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import os
+from typing import Dict, Optional, List, Tuple
+
+
+class RepoReader:
+    def __init__(self, repo_path: str, gitignore_path: Optional[str] = None):
+        self.repo_path = repo_path
+        self.gitignore_path = gitignore_path
+
+    def read_files(self, rel_paths: List[str]) -> Tuple[Dict[str, str], List[str]]:
+        contents: Dict[str, str] = {}
+        missing: List[str] = []
+        for rel in rel_paths:
+            abs_path = os.path.join(self.repo_path, rel)
+            if not os.path.isfile(abs_path):
+                missing.append(rel)
+                continue
+            try:
+                with open(abs_path, "r", encoding="utf-8") as fobj:
+                    contents[rel] = fobj.read()
+            except Exception:
+                missing.append(rel)
+        return contents, missing
+
+    def read_default_targets(self) -> Tuple[Dict[str, str], List[str]]:
+        # Common targets we may need to modify
+        candidates = [
+            "README.md",
+            "README.rst",
+            "vignettes/install.Rmd",
+            "vignettes/install_v5.Rmd",
+        ]
+        return self.read_files(candidates)
+
+