codemop 0.1.0__py3-none-any.whl

codemop/providers/openai_compatible.py

@@ -0,0 +1,187 @@
+"""
+Any provider with an OpenAI-compatible chat completions API: Mistral, OpenAI, OpenRouter,
+and local models through Ollama or vLLM.
+
+The review schema is requested with response_format "json_schema". Not every provider
+enforces it strictly, so the answer is validated here, and an invalid one gets a single
+repair attempt with the validation errors before giving up.
+"""
+import asyncio
+import json
+import os
+from dataclasses import dataclass
+from typing import Optional
+
+import httpx
+import pydantic
+
+from codemop.providers.base import DEFAULT_CHUNK_TOKENS, NoReview, Usage
+from codemop.review.schema import ModelReview
+
+
+@dataclass(frozen=True)
+class Preset:
+    base_url: str
+    key_env: Optional[str]  # None: no key needed
+    chunk_tokens: int = DEFAULT_CHUNK_TOKENS
+    max_output_tokens: int = 16000
+    context_hint: str = "raise the model's context window"
+
+
+PRESETS = {
+    "openai": Preset("https://api.openai.com/v1", "OPENAI_API_KEY"),
+    "mistral": Preset("https://api.mistral.ai/v1", "MISTRAL_API_KEY"),
+    "openrouter": Preset("https://openrouter.ai/api/v1", "OPENROUTER_API_KEY"),
+    # Local models run with small context windows (Ollama defaults to 4096 tokens) and
+    # are slow on a CPU, so they get smaller chunks and a shorter review
+    "ollama": Preset(
+        "http://localhost:11434/v1", None, chunk_tokens=8_000, max_output_tokens=4096,
+        context_hint="set OLLAMA_CONTEXT_LENGTH for the Ollama server (16384 or more) and restart it",
+    ),
+}
+
+# Fewer than this many characters per reported prompt token means the server dropped
+# part of the input: real text and code run at about 3-4 characters per token
+TRUNCATED_CHARS_PER_TOKEN = 6
+# Below this size the ratio is too noisy to judge
+TRUNCATION_CHECK_MIN_CHARS = 2_000
+
+RETRY_STATUSES = {408, 409, 429, 500, 502, 503, 504}
+REPAIR_INSTRUCTION = (
+    "That reply didn't match the required JSON schema:\n{errors}\n"
+    "Reply again with only the corrected JSON object."
+)
+
+
+class OpenAICompatibleModel:
+    """A ReviewModel for any OpenAI-compatible chat completions API"""
+
+    def __init__(
+        self,
+        model: str,
+        *,
+        provider: str = "openai",
+        base_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        key_env: Optional[str] = None,
+        max_output_tokens: Optional[int] = None,
+        chunk_tokens: Optional[int] = None,
+        max_retries: int = 2,
+        timeout: float = 300.0,
+        transport: Optional[httpx.AsyncBaseTransport] = None,
+    ):
+        preset = PRESETS.get(provider, Preset("", None))
+        self.model = model
+        self.provider = provider
+        self.base_url = (base_url or preset.base_url).rstrip("/")
+        if not self.base_url:
+            raise ValueError(f"Unknown provider {provider!r}: give a base_url")
+        self.key_env = key_env or preset.key_env
+        self.api_key = api_key or (os.environ.get(self.key_env) if self.key_env else None)
+        self.max_output_tokens = max_output_tokens or preset.max_output_tokens
+        self.chunk_tokens = chunk_tokens or preset.chunk_tokens
+        self.context_hint = preset.context_hint
+        self.max_retries = max_retries
+        self.timeout = timeout
+        self._transport = transport
+
+    @property
+    def name(self) -> str:
+        return f"{self.provider}/{self.model}"
+
+    def cost(self, usage: Usage) -> Optional[float]:
+        # Local models cost nothing per request; hosted prices vary too much to guess
+        return 0.0 if self.provider == "ollama" else None
+
+    def _key_hint(self) -> str:
+        return f"check {self.key_env} is set to a valid key" if self.key_env else "check the API key"
+
+    async def _complete(self, client: httpx.AsyncClient, messages: list) -> tuple[dict, Usage]:
+        body = {
+            "model": self.model,
+            "messages": messages,
+            "max_tokens": self.max_output_tokens,
+            "response_format": {
+                "type": "json_schema",
+                "json_schema": {"name": "review", "schema": ModelReview.model_json_schema()},
+            },
+        }
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = await client.post("/chat/completions", json=body)
+            except httpx.TransportError:
+                if attempt < self.max_retries:
+                    await asyncio.sleep(2 ** attempt)
+                    continue
+                raise NoReview(f"Couldn't connect to {self.base_url}; check the network and base URL")
+            if response.status_code in RETRY_STATUSES and attempt < self.max_retries:
+                await asyncio.sleep(2 ** attempt)
+                continue
+            break
+
+        status = response.status_code
+        if status in (401, 403):
+            raise NoReview(f"{self.provider} rejected the API key: {self._key_hint()}", fatal=True)
+        if status == 404:
+            raise NoReview(f"Model {self.model} wasn't found at {self.base_url}", fatal=True)
+        if status == 429:
+            raise NoReview(f"{self.provider} rate limit reached (after retries); try again later")
+        if status == 400 and "response_format" in response.text:
+            raise NoReview(
+                f"{self.name} doesn't support structured output (response_format json_schema)",
+                fatal=True,
+            )
+        if status >= 400:
+            raise NoReview(f"{self.provider} returned an error ({status}): {response.text[:200]}")
+
+        data = response.json()
+        usage = data.get("usage") or {}
+        result = Usage(
+            input_tokens=usage.get("prompt_tokens", 0),
+            output_tokens=usage.get("completion_tokens", 0),
+        )
+        # Some servers (Ollama among them) silently drop input that doesn't fit the
+        # context window and review what's left; never pass that off as a review
+        sent = sum(len(message["content"]) for message in messages)
+        if sent >= TRUNCATION_CHECK_MIN_CHARS and 0 < result.input_tokens < sent / TRUNCATED_CHARS_PER_TOKEN:
+            raise NoReview(
+                f"{self.name} only read {result.input_tokens:,} tokens of a request of about "
+                f"{sent // 4:,}: its context window has to fit the request plus a review of up to "
+                f"{self.max_output_tokens:,} tokens. To fix it, {self.context_hint}, or lower --chunk-tokens",
+                fatal=True,
+                usage=result,
+            )
+        return data, result
+
+    async def review(self, instructions: str, diff_text: str) -> tuple[ModelReview, Usage]:
+        headers = {"Authorization": f"Bearer {self.api_key}"} if self.api_key else {}
+        messages = [
+            {"role": "system", "content": instructions},
+            {"role": "user", "content": diff_text},
+        ]
+        total = Usage()
+        async with httpx.AsyncClient(
+            base_url=self.base_url, headers=headers, timeout=self.timeout, transport=self._transport
+        ) as client:
+            for attempt in range(2):  # the answer, then one repair attempt
+                data, usage = await self._complete(client, messages)
+                total += usage
+                choice = (data.get("choices") or [{}])[0]
+                message = choice.get("message") or {}
+
+                if message.get("refusal") or choice.get("finish_reason") == "content_filter":
+                    raise NoReview.refused(self.name, total)
+                if choice.get("finish_reason") == "length":
+                    raise NoReview.cut_off(self.name, self.max_output_tokens, total)
+
+                content = message.get("content") or ""
+                try:
+                    return ModelReview.model_validate_json(content), total
+                except pydantic.ValidationError as e:
+                    errors = json.dumps(e.errors(include_url=False, include_context=False), default=str)[:2000]
+                    messages += [
+                        {"role": "assistant", "content": content},
+                        {"role": "user", "content": REPAIR_INSTRUCTION.format(errors=errors)},
+                    ]
+
+        raise NoReview(f"{self.name} returned a review that doesn't match the schema, even after a retry", usage=total)

codemop/providers/pricing.py

@@ -0,0 +1,45 @@
+"""
+Estimating what a review cost, from list prices.
+
+Prices change, so these are dated and the result is always described as an estimate. A model
+without a known price gets no estimate rather than a guess.
+"""
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+from codemop.providers.base import Usage
+
+PRICES_AS_OF = "2026-09-25"
+
+
+@dataclass(frozen=True)
+class Price:
+    """US dollars per million tokens"""
+    input: float
+    output: float
+    cache_read: Optional[float] = None  # default: a tenth of the input price
+
+    def cost(self, usage: Usage) -> float:
+        cache_read = self.cache_read if self.cache_read is not None else self.input / 10
+        return (
+            usage.input_tokens * self.input
+            + usage.output_tokens * self.output
+            + usage.cache_read_tokens * cache_read
+            + usage.cache_write_tokens * self.input * 1.25  # five-minute cache writes
+        ) / 1_000_000
+
+
+# Anthropic list prices on the Claude API
+ANTHROPIC_PRICES: Dict[str, Price] = {
+    "claude-fable-5-1": Price(10.00, 50.00, cache_read=0.25),
+    "claude-fable-5": Price(10.00, 50.00),
+    "claude-opus-5-5": Price(4.00, 20.00, cache_read=0.20),
+    "claude-opus-5": Price(5.00, 25.00),
+    "claude-opus-4-8": Price(5.00, 25.00),
+    "claude-opus-4-7": Price(5.00, 25.00),
+    "claude-opus-4-6": Price(5.00, 25.00),
+    "claude-sonnet-5-5": Price(2.00, 10.00, cache_read=0.20),
+    "claude-sonnet-5": Price(2.00, 10.00),
+    "claude-sonnet-4-6": Price(3.00, 15.00),
+    "claude-haiku-4-5": Price(1.00, 5.00),
+}

codemop/review/__init__.py

@@ -0,0 +1 @@
+"""Turning a diff into validated review suggestions; independent of any model provider."""

codemop/review/chunks.py

@@ -0,0 +1,131 @@
+"""
+Splitting a diff into chunks that each fit in one model request.
+
+Files are packed together up to a token budget. A file too big for one chunk is split by
+hunk, and anything that still doesn't fit, or isn't worth reviewing (lock files, binaries,
+deletions), is skipped with a reason, so a large PR is never silently cut short.
+"""
+import math
+from dataclasses import dataclass, field, replace
+from fnmatch import fnmatch
+from typing import Callable, Iterable, List, Sequence
+
+from codemop.review.diff import FileDiff, Hunk
+from codemop.review.prompt import render_hunks
+
+# Generated files that are rarely worth reviewing
+DEFAULT_IGNORED_PATHS = (
+    "*.lock",
+    "package-lock.json",
+    "pnpm-lock.yaml",
+    "go.sum",
+    "*.min.js",
+    "*.min.css",
+    "*.map",
+    "*.svg",
+)
+
+
+def estimate_tokens(text: str) -> int:
+    """A deliberately high estimate (code averages more than 3 characters per token)"""
+    return math.ceil(len(text) / 3)
+
+
+@dataclass
+class Chunk:
+    """Part of the diff, rendered for the model, and the files it shows (with only the hunks it shows)"""
+    files: List[FileDiff] = field(default_factory=list)
+    parts: List[str] = field(default_factory=list)
+    tokens: int = 0
+
+    @property
+    def text(self) -> str:
+        return "\n\n".join(self.parts)
+
+
+@dataclass(frozen=True)
+class Skipped:
+    path: str
+    reason: str
+
+
+@dataclass
+class ChunkPlan:
+    chunks: List[Chunk]
+    skipped: List[Skipped]
+
+
+def is_ignored(path: str, patterns: Sequence[str]) -> bool:
+    name = path.rsplit("/", 1)[-1]
+    return any(fnmatch(path, pattern) or fnmatch(name, pattern) for pattern in patterns)
+
+
+def _skip_reason(file: FileDiff, ignored_paths: Sequence[str]) -> str | None:
+    if file.status == "deleted":
+        return "deleted file"
+    if file.is_binary:
+        return "binary file"
+    if not file.hunks:
+        return "no changed lines" + (" (rename only)" if file.status == "renamed" else "")
+    if is_ignored(file.path, ignored_paths):
+        return "matches an ignored path pattern"
+    return None
+
+
+def _pieces(
+    file: FileDiff, budget: int, count_tokens: Callable[[str], int], skipped: List[Skipped]
+) -> Iterable[tuple[str, int, List[Hunk]]]:
+    """The file as one rendered piece if it fits, otherwise its hunks packed into pieces"""
+    whole = render_hunks(file, file.hunks)
+    whole_tokens = count_tokens(whole)
+    if whole_tokens <= budget:
+        yield whole, whole_tokens, list(file.hunks)
+        return
+
+    group: List[Hunk] = []
+    for hunk in file.hunks:
+        if count_tokens(render_hunks(file, [hunk])) > budget:
+            skipped.append(Skipped(file.path, f"hunk too large to review: {hunk.header}"))
+            continue
+        if group and count_tokens(render_hunks(file, group + [hunk])) > budget:
+            rendered = render_hunks(file, group)
+            yield rendered, count_tokens(rendered), group
+            group = []
+        group.append(hunk)
+    if group:
+        rendered = render_hunks(file, group)
+        yield rendered, count_tokens(rendered), group
+
+
+def plan_chunks(
+    files: Sequence[FileDiff],
+    budget_tokens: int,
+    count_tokens: Callable[[str], int] = estimate_tokens,
+    ignored_paths: Sequence[str] = DEFAULT_IGNORED_PATHS,
+) -> ChunkPlan:
+    """Pack the reviewable parts of a diff into chunks of at most `budget_tokens` each"""
+    chunks: List[Chunk] = []
+    skipped: List[Skipped] = []
+    current = Chunk()
+
+    for file in files:
+        reason = _skip_reason(file, ignored_paths)
+        if reason:
+            skipped.append(Skipped(file.path, reason))
+            continue
+        for rendered, tokens, hunks in _pieces(file, budget_tokens, count_tokens, skipped):
+            if current.parts and current.tokens + tokens > budget_tokens:
+                chunks.append(current)
+                current = Chunk()
+            current.parts.append(rendered)
+            current.tokens += tokens
+            # Only the hunks shown, so suggestions can only be placed on lines the model saw
+            shown = next((f for f in current.files if f.path == file.path), None)
+            if shown:
+                shown.hunks.extend(hunks)
+            else:
+                current.files.append(replace(file, hunks=list(hunks)))
+
+    if current.parts:
+        chunks.append(current)
+    return ChunkPlan(chunks=chunks, skipped=skipped)

codemop/review/diff.py

@@ -0,0 +1,123 @@
+"""
+Parsing unified diffs (as GitHub returns them) into files, hunks and lines.
+
+Each line keeps its number in the old and new versions of the file, because GitHub only
+accepts review comments on lines that appear in the diff.
+"""
+import re
+from dataclasses import dataclass, field
+from typing import List, Literal, Optional, Set
+
+HUNK_HEADER = re.compile(r"^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@")
+
+LineKind = Literal["added", "removed", "context"]
+FileStatus = Literal["added", "deleted", "modified", "renamed"]
+
+
+@dataclass(frozen=True)
+class DiffLine:
+    kind: LineKind
+    text: str
+    old_number: Optional[int]  # None for added lines
+    new_number: Optional[int]  # None for removed lines
+
+
+@dataclass
+class Hunk:
+    header: str  # the whole "@@ -a,b +c,d @@ context" line
+    lines: List[DiffLine] = field(default_factory=list)
+
+
+@dataclass
+class FileDiff:
+    old_path: Optional[str]  # None for an added file
+    new_path: Optional[str]  # None for a deleted file
+    status: FileStatus
+    hunks: List[Hunk] = field(default_factory=list)
+    is_binary: bool = False
+
+    @property
+    def path(self) -> str:
+        return self.new_path or self.old_path or ""
+
+    def commentable_lines(self) -> Set[int]:
+        """New-file line numbers a review comment can go on: added or unchanged lines shown in the diff"""
+        return {
+            line.new_number
+            for hunk in self.hunks
+            for line in hunk.lines
+            if line.new_number is not None
+        }
+
+
+def _strip_prefix(path: str, prefix: str) -> Optional[str]:
+    if path == "/dev/null":
+        return None
+    return path[len(prefix):] if path.startswith(prefix) else path
+
+
+def _paths_from_git_header(line: str) -> tuple[Optional[str], Optional[str]]:
+    """Paths from "diff --git a/x b/y", used when there are no ---/+++ lines (renames, binaries)"""
+    rest = line[len("diff --git "):]
+    split = rest.rfind(" b/")
+    if not rest.startswith("a/") or split == -1:
+        return None, None
+    return rest[2:split], rest[split + 3:]
+
+
+def parse_diff(diff: str) -> List[FileDiff]:
+    """Parse a unified diff, as `git diff` or the GitHub API produce, into files"""
+    files: List[FileDiff] = []
+    current: Optional[FileDiff] = None
+    hunk: Optional[Hunk] = None
+    old_number = new_number = 0
+
+    for line in diff.splitlines():
+        if line.startswith("diff --git "):
+            old_path, new_path = _paths_from_git_header(line)
+            current = FileDiff(old_path=old_path, new_path=new_path, status="modified")
+            files.append(current)
+            hunk = None
+            continue
+        if current is None:
+            continue
+
+        if hunk is None:
+            # File header lines, before the first hunk
+            if line.startswith("new file mode"):
+                current.status, current.old_path = "added", None
+            elif line.startswith("deleted file mode"):
+                current.status, current.new_path = "deleted", None
+            elif line.startswith("rename from "):
+                current.status, current.old_path = "renamed", line[len("rename from "):]
+            elif line.startswith("rename to "):
+                current.new_path = line[len("rename to "):]
+            elif line.startswith("Binary files ") or line.startswith("GIT binary patch"):
+                current.is_binary = True
+            elif line.startswith("--- "):
+                current.old_path = _strip_prefix(line[4:], "a/")
+            elif line.startswith("+++ "):
+                current.new_path = _strip_prefix(line[4:], "b/")
+
+        match = HUNK_HEADER.match(line)
+        if match:
+            old_number, new_number = int(match.group(1)), int(match.group(2))
+            hunk = Hunk(header=line)
+            current.hunks.append(hunk)
+            continue
+        if hunk is None or line.startswith("\\"):  # ""
+            continue
+
+        if line.startswith("+"):
+            hunk.lines.append(DiffLine("added", line[1:], None, new_number))
+            new_number += 1
+        elif line.startswith("-"):
+            hunk.lines.append(DiffLine("removed", line[1:], old_number, None))
+            old_number += 1
+        else:
+            # Context lines start with a space; some tools drop it from empty lines
+            hunk.lines.append(DiffLine("context", line[1:], old_number, new_number))
+            old_number += 1
+            new_number += 1
+
+    return files

codemop/review/pipeline.py

@@ -0,0 +1,86 @@
+"""
+Reviewing a whole diff: chunk it, review the chunks concurrently, and gather one report
+that says what was reviewed and what wasn't, and why.
+"""
+import asyncio
+from dataclasses import dataclass, field
+from typing import List, Literal, Optional, Sequence
+
+from codemop.config import DEFAULT_MIN_CONFIDENCE
+from codemop.providers.base import NoReview, NoReviewKind, ReviewModel, Usage
+from codemop.review.chunks import DEFAULT_IGNORED_PATHS, Skipped, plan_chunks
+from codemop.review.diff import parse_diff
+from codemop.review.placement import Unplaced, place_suggestions
+from codemop.review.prompt import SYSTEM_PROMPT
+from codemop.review.schema import ModelSuggestion
+
+DEFAULT_CONCURRENCY = 4
+
+
+@dataclass(frozen=True)
+class FailedChunk:
+    paths: List[str]
+    reason: str
+    kind: NoReviewKind | Literal["not_reviewed"] = "error"  # not_reviewed: skipped after a fatal error
+
+
+@dataclass
+class ReviewReport:
+    model: str
+    suggestions: List[ModelSuggestion] = field(default_factory=list)
+    unplaced: List[Unplaced] = field(default_factory=list)  # suggestions on lines GitHub can't comment on
+    below_confidence: int = 0  # suggestions dropped by min_confidence
+    skipped: List[Skipped] = field(default_factory=list)  # parts of the diff not reviewed
+    failed: List[FailedChunk] = field(default_factory=list)  # chunks the model gave no review for
+    stopped: Optional[str] = None  # why the review stopped early, if it did
+    chunks: int = 0
+    usage: Usage = Usage()
+    cost: Optional[float] = None  # estimated US dollars at list prices; None if unknown
+
+    @property
+    def complete(self) -> bool:
+        """Every reviewable part of the diff got a review"""
+        return not self.failed and self.stopped is None
+
+
+async def review_diff(
+    diff: str,
+    model: ReviewModel,
+    *,
+    chunk_tokens: Optional[int] = None,
+    concurrency: int = DEFAULT_CONCURRENCY,
+    ignored_paths: Sequence[str] = DEFAULT_IGNORED_PATHS,
+    min_confidence: float = DEFAULT_MIN_CONFIDENCE,
+) -> ReviewReport:
+    """Review a unified diff with `model` (chunk_tokens defaults to the model's own chunk size)"""
+    plan = plan_chunks(parse_diff(diff), chunk_tokens or model.chunk_tokens, ignored_paths=ignored_paths)
+    report = ReviewReport(model=model.name, skipped=list(plan.skipped), chunks=len(plan.chunks))
+    limit = asyncio.Semaphore(concurrency)
+
+    async def review_chunk(chunk):
+        async with limit:
+            paths = [file.path for file in chunk.files]
+            if report.stopped:
+                report.failed.append(FailedChunk(paths, f"not reviewed: {report.stopped}", "not_reviewed"))
+                return
+            try:
+                review, usage = await model.review(SYSTEM_PROMPT, chunk.text)
+            except NoReview as e:
+                report.usage += e.usage
+                report.failed.append(FailedChunk(paths, e.reason, e.kind))
+                if e.fatal and not report.stopped:
+                    report.stopped = e.reason
+                return
+            report.usage += usage
+            placement = place_suggestions(review.suggestions, chunk.files)
+            report.unplaced.extend(placement.unplaced)
+            for suggestion in placement.placed:
+                if suggestion.confidence >= min_confidence:
+                    report.suggestions.append(suggestion)
+                else:
+                    report.below_confidence += 1
+
+    await asyncio.gather(*(review_chunk(chunk) for chunk in plan.chunks))
+    report.suggestions.sort(key=lambda s: (s.file_path, s.line))
+    report.cost = model.cost(report.usage)
+    return report

codemop/review/placement.py

@@ -0,0 +1,44 @@
+"""
+Checking that each suggestion points at lines GitHub can comment on.
+
+A review comment has to be on an added or unchanged line shown in the diff; a model that
+points elsewhere (a removed line, a line outside the hunks, a file it wasn't shown) has
+made a mistake, and that suggestion is set aside rather than posted in the wrong place.
+"""
+from dataclasses import dataclass
+from typing import Dict, List, Sequence, Set
+
+from codemop.review.diff import FileDiff
+from codemop.review.schema import ModelSuggestion
+
+
+@dataclass(frozen=True)
+class Unplaced:
+    suggestion: ModelSuggestion
+    reason: str
+
+
+@dataclass
+class Placement:
+    placed: List[ModelSuggestion]
+    unplaced: List[Unplaced]
+
+
+def place_suggestions(suggestions: Sequence[ModelSuggestion], files: Sequence[FileDiff]) -> Placement:
+    """Split suggestions into those on commentable lines and those that aren't"""
+    commentable: Dict[str, Set[int]] = {file.path: file.commentable_lines() for file in files}
+    placed: List[ModelSuggestion] = []
+    unplaced: List[Unplaced] = []
+
+    for suggestion in suggestions:
+        lines = commentable.get(suggestion.file_path)
+        end_line = suggestion.end_line or suggestion.line
+        if lines is None:
+            unplaced.append(Unplaced(suggestion, "file isn't in the reviewed diff"))
+        elif end_line < suggestion.line:
+            unplaced.append(Unplaced(suggestion, "end_line is before line"))
+        elif not set(range(suggestion.line, end_line + 1)) <= lines:
+            unplaced.append(Unplaced(suggestion, "lines aren't added or unchanged lines in the diff"))
+        else:
+            placed.append(suggestion)
+    return Placement(placed=placed, unplaced=unplaced)

codemop/review/prompt.py

@@ -0,0 +1,54 @@
+"""
+The instructions given to every model, and how a diff is shown to it.
+
+Each line is shown with its new-file line number, so the model can say exactly which line
+an issue is on; those numbers are what GitHub review comments use.
+"""
+from typing import Iterable
+
+from codemop.review.diff import FileDiff, Hunk
+
+SYSTEM_PROMPT = """\
+You are reviewing a pull request. Report real problems in the changed code: bugs, security
+issues, performance problems, and code that is hard to maintain in a way that will cause bugs.
+Don't report style preferences, naming, formatting or missing comments.
+
+The diff shows each file's changes in hunks. Every line has a marker and a line number:
+  "+ 12 | ..." is an added line, number 12 in the new version of the file
+  "  12 | ..." is an unchanged line, number 12 in the new version
+  "-    | ..." is a removed line; it has no new line number, so never point at it
+
+For each problem:
+- file_path is the path exactly as it appears after "###"
+- line (and end_line, for several lines) are new-file numbers of added or unchanged lines
+  shown in the diff. Prefer pointing at added lines
+- suggested_code, if you have a concrete fix, replaces lines line..end_line exactly: the
+  complete new code for those lines, with no "+"/"-" markers and no line numbers
+- confidence is how sure you are the problem is real
+
+Only report problems you are confident about. If the changes look fine, return no suggestions.\
+"""
+
+
+def render_hunks(file: FileDiff, hunks: Iterable[Hunk]) -> str:
+    """A file's hunks with markers and new-file line numbers, as the model sees them"""
+    hunks = list(hunks)
+    width = max(
+        (len(str(line.new_number)) for hunk in hunks for line in hunk.lines if line.new_number),
+        default=1,
+    )
+    title = f"### {file.path} ({file.status}"
+    if file.status == "renamed" and file.old_path:
+        title += f" from {file.old_path}"
+    parts = [title + ")"]
+    for hunk in hunks:
+        parts.append(hunk.header)
+        for line in hunk.lines:
+            marker = {"added": "+", "removed": "-", "context": " "}[line.kind]
+            number = str(line.new_number).rjust(width) if line.new_number else " " * width
+            parts.append(f"{marker} {number} | {line.text}")
+    return "\n".join(parts)
+
+
+def render_file(file: FileDiff) -> str:
+    return render_hunks(file, file.hunks)