codna 0.2.52__tar.gz → 0.2.54__tar.gz

{codna-0.2.52 → codna-0.2.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.52
+Version: 0.2.54
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.52 → codna-0.2.54}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.2.52"
+__version__ = "0.2.54"

{codna-0.2.52 → codna-0.2.54}/codna/fix_inputs.py

@@ -10,6 +10,8 @@ import shutil
 import subprocess
 import tempfile
 
+from .testrun import TestEnvironmentUnavailable
+
 
 class FixInputError(Exception):
     """Bad/unusable fix input, surfaced to the user (the CLI maps it to a clean error)."""
@@ -181,6 +183,10 @@ def resolve_issue(args, github_token: str | None = None):
             else:
                 repo_dir = os.path.abspath(os.path.expanduser(repo))
                 issue, failing = _discover_failing_tests_for_fix(repo_dir, getattr(args, "test_cmd", None))
+        except TestEnvironmentUnavailable:
+            # Keeps its own error code: the CLI prints it structured and the GitHub App ends the
+            # check neutral -- flattening it into a cli_error made the check red (mojo-kernels#1).
+            raise
         except Exception as exc:  # noqa: BLE001 - surface any discovery failure as a clean CLI error
             raise FixInputError(str(exc)) from exc
         merged = list(dict.fromkeys([*explicit_failing, *failing]))

{codna-0.2.52 → codna-0.2.54}/codna/review.py

@@ -136,13 +136,30 @@ def _is_git_url(value: str) -> bool:
 
 
 def _materialize_pr(url: str, pr_number: int, base_ref: str, token: str | None,
-                    incremental_base: str | None = None) -> tuple[str, str, str]:
+                    incremental_base: str | None = None) -> tuple[str, str, str, list[str] | None]:
     """Clone ``url`` and fetch the PR head into a temp dir. Returns ``(local_path, diff_range,
-    head_sha)``. Default diff_range is ``origin/<base>...codna-pr-head`` (3-dot merge-base diff, the
-    whole PR). If ``incremental_base`` (the last-reviewed head SHA) is given and is an ANCESTOR of the
-    current head (i.e. no force-push rewrote it) and not already the head, the range narrows to
-    ``<incremental_base>...codna-pr-head`` — only the commits pushed since the last review. Uses
-    ``pull/<n>/head`` so forked-PR heads materialize too, without any repo write."""
+    head_sha, diff_paths)``. Default diff_range is ``origin/<base>...codna-pr-head`` (3-dot merge-base
+    diff, the whole PR) with ``diff_paths=None`` (no restriction). If ``incremental_base`` (the
+    last-reviewed head SHA) is given and is an ANCESTOR of the current head (i.e. no force-push
+    rewrote it) and not already the head, the range narrows to ``<incremental_base>...codna-pr-head``
+    — only the commits pushed since the last review — and ``diff_paths`` is the pull request's OWN
+    file set (``git diff --name-only origin/<base>...codna-pr-head``), which the diff of that range
+    must be confined to (``review_findings.compute_diff``).
+
+    The confinement is what keeps base-branch history out of an incremental review. The narrowed
+    range covers everything reachable from the new head and not from the old one -- and that
+    includes whatever the base branch gained when the author pressed "Update branch". The new head is
+    then a merge commit whose SECOND parent is reachable from ``origin/<base>`` and whose FIRST parent
+    is the previously reviewed head, so the ancestor test above passes and the range's diff is the
+    base branch's own recent changes: files the pull request does not touch at all. Findings anchored
+    to them made GitHub reject the whole review (``422 Path could not be resolved``,
+    thyn-ai/codna-action#6, head bc1219d3 = merge of main into the branch). No merge detection is
+    needed to handle that case: a file the pull request does not change is never in ``diff_paths``,
+    so the merge's contribution is filtered out whether or not the head is a merge commit, while a
+    commit pushed after the merge is still reviewed through the files it changes. An empty
+    intersection means nothing new to review, and ``compute_diff`` reports it as no changes -- a
+    fast, clean result, not a failure. Uses ``pull/<n>/head`` so forked-PR heads materialize too,
+    without any repo write."""
     import subprocess
     import tempfile
 
@@ -162,12 +179,20 @@ def _materialize_pr(url: str, pr_number: int, base_ref: str, token: str | None,
     _git("-C", tmp, "checkout", "--quiet", "codna-pr-head")
     head_sha = _git("-C", tmp, "rev-parse", "HEAD").stdout.strip()
     diff_range = f"origin/{base_ref}...codna-pr-head"
+    diff_paths: list[str] | None = None
     if incremental_base and incremental_base != head_sha:
         # incremental only when the prior head is still in this branch's history (not force-pushed away)
         anc = _git("-C", tmp, "merge-base", "--is-ancestor", incremental_base, "codna-pr-head", allow_fail=True)
         if anc.returncode == 0:
-            diff_range = f"{incremental_base}...codna-pr-head"
-    return tmp, diff_range, head_sha
+            # The pull request's own files: the incremental diff is confined to these, so an
+            # "Update branch" merge in the range contributes nothing (see the docstring). The range
+            # narrows only together with its confinement -- if the file set cannot be read, the
+            # review stays a whole-PR review rather than an unconfined incremental one.
+            names = _git("-C", tmp, "diff", "--name-only", f"origin/{base_ref}...codna-pr-head", allow_fail=True)
+            if names.returncode == 0:
+                diff_range = f"{incremental_base}...codna-pr-head"
+                diff_paths = [ln.strip() for ln in names.stdout.splitlines() if ln.strip()]
+    return tmp, diff_range, head_sha, diff_paths
 
 
 def run_findings_review(args) -> dict:
@@ -182,6 +207,7 @@ def run_findings_review(args) -> dict:
 
     diff_range = getattr(args, "diff", None)
     base = None if diff_range else getattr(args, "base", None)
+    diff_paths: list[str] | None = None   # set by an incremental remote review: the PR's own files
     head_sha = None
     repo_slug = pr_number = None
     prior_feedback = None
@@ -220,7 +246,7 @@ def run_findings_review(args) -> dict:
             if incremental:
                 incremental_base = ctx.get("last_reviewed_head")
         try:
-            local, diff_range, head_sha = _materialize_pr(
+            local, diff_range, head_sha, diff_paths = _materialize_pr(
                 str(args.repo), pr_number, meta["base_ref"], token, incremental_base=incremental_base)
         except Exception as exc:  # noqa: BLE001
             _fail(f"could not materialize PR #{pr_number}: {exc}")
@@ -246,7 +272,7 @@ def run_findings_review(args) -> dict:
             result = rf.run_diff_review(
                 local, repository=args.repo, diff_range=diff_range, base=base, config=cfg,
                 guidance=guidance, prior_feedback=prior_feedback, head_sha=head_sha,
-                model=getattr(args, "model", None) or None,
+                model=getattr(args, "model", None) or None, diff_paths=diff_paths,
             )
         except ReviewTurnTimeout as exc:
             # The turn outran its adaptive budget: its message already names the diff size, the

{codna-0.2.52 → codna-0.2.54}/codna/review_findings.py

@@ -216,7 +216,7 @@ class DiffFile:
     added_lines: set[int] = field(default_factory=set)
 
 
-_HUNK_RE = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+_HUNK_RE = re.compile(r"^@@ -\d+(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
 _NEWFILE_RE = re.compile(r"^\+\+\+ (?:b/)?(.+)$")
 
 
@@ -225,41 +225,50 @@ def parse_diff(diff_text: str) -> dict[str, DiffFile]:
 
     ``right_lines`` = every new-file line number shown in a hunk (added + context) — the anchorable
     set for inline comments. ``added_lines`` = only the ``+`` lines. Deletion-only hunks contribute no
-    right-side lines (correctly un-anchorable → routed to the summary)."""
+    right-side lines (correctly un-anchorable → routed to the summary).
+
+    Hunk-range driven, like ``diff_changed_lines``: each ``@@ -a,b +c,d @@`` header says how many
+    old-side (``b``) and new-side (``d``) body lines follow, and while a hunk still owes lines every
+    line is body. Deciding "file header" by prefix instead mis-filed real changes: an added ``++ x``
+    renders as ``+++ x`` and used to open a bogus file named ``x``, so every later line of the hunk
+    anchored to the wrong file. Only between hunks may ``+++ path`` open a file."""
     files: dict[str, DiffFile] = {}
     current: DiffFile | None = None
     new_line = 0
+    old_left = new_left = 0            # body lines the current hunk still owes on each side
     for line in (diff_text or "").splitlines():
-        m = _NEWFILE_RE.match(line)
-        if m and line.startswith("+++"):
-            path = m.group(1).strip()
-            if path == "/dev/null":
-                current = None
+        if old_left <= 0 and new_left <= 0:            # between hunks: only headers matter
+            m = _NEWFILE_RE.match(line)
+            if m:
+                path = m.group(1).strip()
+                current = None if path == "/dev/null" else files.setdefault(path, DiffFile(path=path))
                 continue
-            current = files.setdefault(path, DiffFile(path=path))
-            continue
-        if line.startswith("@@"):
             hm = _HUNK_RE.match(line)
-            if hm and current is not None:
-                new_line = int(hm.group(1))
+            if hm:
+                old_left = int(hm.group(1)) if hm.group(1) is not None else 1
+                new_line = int(hm.group(2))
+                new_left = int(hm.group(3)) if hm.group(3) is not None else 1
             continue
-        if current is None:
+        # inside a hunk: body, whatever it starts with ("+++ x" here is an added "++ x")
+        if line.startswith("\\"):
+            # "": consumes nothing on either side
             continue
-        if line.startswith("+") and not line.startswith("+++"):
-            current.right_lines.add(new_line)
-            current.added_lines.add(new_line)
+        if line.startswith("+"):
+            if current is not None:
+                current.right_lines.add(new_line)
+                current.added_lines.add(new_line)
             new_line += 1
-        elif line.startswith("-") and not line.startswith("---"):
+            new_left -= 1
+        elif line.startswith("-"):
             # deletion: consumes an old-side line only; new-side cursor does not advance
-            continue
-        elif line.startswith("\\"):
-            # ""
-            continue
+            old_left -= 1
         else:
             # context line (present on both sides)
-            if line[:1] in (" ", ""):
+            if current is not None:
                 current.right_lines.add(new_line)
-                new_line += 1
+            new_line += 1
+            old_left -= 1
+            new_left -= 1
     return files
 
 
@@ -346,15 +355,25 @@ def _git(repo_dir: str, *args: str, timeout: int = 60) -> str:
     return out.stdout
 
 
-def compute_diff(repo_dir: str, *, diff_range: str | None = None, base: str | None = None) -> tuple[str, list[str]]:
+def compute_diff(repo_dir: str, *, diff_range: str | None = None, base: str | None = None,
+                 diff_paths: list[str] | None = None) -> tuple[str, list[str]]:
     """Return ``(unified_diff_text, changed_paths)``.
 
     ``diff_range`` (e.g. ``origin/main...HEAD``) → ``git diff <range>``; else ``base`` (or HEAD) →
-    ``git diff <base>`` (working tree vs base). Best-effort: returns ``("", [])`` if git is unavailable."""
+    ``git diff <base>`` (working tree vs base). ``diff_paths`` (None = no restriction) limits the diff
+    and the changed-path list to those paths -- ``git diff <spec> -- <paths>`` -- which is how an
+    incremental range that also swept in base-branch history (an "Update branch" merge commit, see
+    ``review._materialize_pr``) is cut back to the pull request's own files. An EMPTY list means
+    "restrict to nothing" and returns ``("", [])`` without running git: handing git no pathspec
+    would LIFT the restriction, the opposite of what an empty intersection means. Best-effort:
+    returns ``("", [])`` if git is unavailable."""
+    if diff_paths is not None and not diff_paths:
+        return "", []
     spec = diff_range or (base or "HEAD")
+    scope = ["--", *diff_paths] if diff_paths else []
     try:
-        diff_text = _git(repo_dir, "diff", "--unified=3", spec)
-        names = _git(repo_dir, "diff", "--name-only", spec)
+        diff_text = _git(repo_dir, "diff", "--unified=3", spec, *scope)
+        names = _git(repo_dir, "diff", "--name-only", spec, *scope)
     except Exception:  # noqa: BLE001 — git absent / not a repo
         return "", []
     changed = [ln.strip() for ln in names.splitlines() if ln.strip()]
@@ -528,17 +547,22 @@ def run_diff_review(
     provider: str = "anthropic",
     max_iterations: int | None = None,
     timeout_s: int | None = None,
+    diff_paths: list[str] | None = None,
 ) -> ReviewResult:
     """Run the read-only agent over the diff and return a fully finalized :class:`ReviewResult`.
 
     ``timeout_s`` is a caller's explicit pin on the review turn's budget. Unset (the default), the
     budget is adaptive -- sized from THIS diff's lines/files/tokens and the observed durations of
-    earlier review turns (review_budget) -- which is why the diff's size travels to the agent."""
+    earlier review turns (review_budget) -- which is why the diff's size travels to the agent.
+
+    ``diff_paths`` (None = the whole range) confines the diff to those paths (:func:`compute_diff`);
+    an incremental review passes the pull request's own file set. A range with nothing left in
+    those paths is a clean, agent-free result that says so in its ``note``, not a failure."""
     t0 = time.perf_counter()
     base_label = diff_range or base or "HEAD"
     # Effort → iteration budget (unless the caller pins max_iterations explicitly).
     iterations = max_iterations if max_iterations is not None else effort_iterations(config.effort)
-    diff_text, changed = compute_diff(repo_dir, diff_range=diff_range, base=base)
+    diff_text, changed = compute_diff(repo_dir, diff_range=diff_range, base=base, diff_paths=diff_paths)
     if not changed:
         return ReviewResult(
             repository=repository, base=base_label, head_sha=head_sha, changed_files=[],

{codna-0.2.52 → codna-0.2.54}/codna/review_github.py

@@ -13,6 +13,7 @@ import binascii
 import json
 import re
 import subprocess
+from dataclasses import replace
 
 from .review_findings import CATEGORIES, SEVERITIES, CodnaReviewFinding, ReviewResult
 
@@ -37,6 +38,7 @@ _SEV_EMOJI = {"high": "🔴", "medium": "🟡", "low": "⚪"}
 # severities that mean "do not merge this yet", and only then. Low findings never block approval.
 APPROVAL_BLOCKING_SEVERITIES = ("high", "medium")
 _MAX_THREADS = 100  # reviewThreads page size; more than that -> unknown -> no approval (fail closed)
+_MAX_FILE_PAGES = 30  # GitHub lists at most 3000 files per PR (30 pages of 100); more -> unknown
 
 
 def review_event(result: ReviewResult, *, unresolved_blocking: int | None, approve: bool = True) -> str:
@@ -238,12 +240,41 @@ def existing_fingerprints(comments: list[dict]) -> set[str]:
     return fps
 
 
+def demote_to_summary(result: ReviewResult, *, keep_paths: set[str] | frozenset[str] = frozenset(),
+                      drop_fingerprints: set[str] | frozenset[str] = frozenset()) -> ReviewResult:
+    """A copy of ``result`` in which every inline finding whose path is not in ``keep_paths`` is
+    routed to the summary instead (the default keeps none: every inline finding is demoted). A
+    demoted finding loses only its diff anchor -- text, severity and fingerprint are intact and the
+    review body lists it -- so a finding is never dropped because GitHub would refuse its anchor.
+
+    ``drop_fingerprints`` are the fingerprints already threaded on the PR (:func:`existing_fingerprints`,
+    the ``skip`` set dedup builds). A demoted finding with one of those is left out rather than
+    listed: dedup keeps it out of the inline comments precisely because the PR already carries it,
+    and the body must not say it a second time. The input is not modified; when no inline finding
+    is outside ``keep_paths`` it is returned as is."""
+    kept = [f for f in result.inline_findings if f.path in keep_paths]
+    outside = [f for f in result.inline_findings if f.path not in keep_paths]
+    if not outside:
+        return result
+    demoted = [replace(f, diff_anchor=None) for f in outside if f.fingerprint not in drop_fingerprints]
+    return replace(result, inline_findings=kept, summary_findings=[*result.summary_findings, *demoted])
+
+
 def build_review_payload(result: ReviewResult, *, skip_fingerprints: set[str] | None = None,
-                         event: str = "COMMENT", approval: str | None = None) -> dict:
+                         event: str = "COMMENT", approval: str | None = None,
+                         pr_files: set[str] | None = None) -> dict:
     """Build the ``POST …/reviews`` body: ``event`` (COMMENT, or APPROVE per :func:`review_event`),
     summary body, inline comments for anchored findings whose fingerprint has not already been
-    posted. Never REQUEST_CHANGES — the check conclusion is the gate, the review stays non-blocking."""
+    posted. Never REQUEST_CHANGES — the check conclusion is the gate, the review stays non-blocking.
+
+    ``pr_files`` is the pull request's diff as GitHub lists it (:func:`fetch_pr_files`; None =
+    unknown, filters nothing). An inline comment may only address a path in that set -- GitHub
+    rejects the WHOLE review otherwise -- so a finding on any other path goes to the body instead,
+    unless its fingerprint is already threaded on the PR (``skip_fingerprints``): then it is said
+    nowhere, exactly as dedup keeps it out of the inline comments."""
     skip = skip_fingerprints or set()
+    if pr_files is not None:
+        result = demote_to_summary(result, keep_paths=pr_files, drop_fingerprints=skip)
     comments = [inline_comment_payload(f) for f in result.inline_findings if f.fingerprint not in skip]
     payload: dict = {"event": event, "body": summary_body(result, approval), "comments": comments}
     if result.head_sha:
@@ -273,6 +304,43 @@ def fetch_pr(repo_slug: str, pr_number: int, token: str | None) -> dict:
     }
 
 
+def fetch_pr_files(repo_slug: str, pr_number: int, token: str | None) -> set[str] | None:
+    """The paths in the pull request's diff as GitHub sees it (``GET /pulls/{n}/files``, every page),
+    or None when the answer is not certain: no httpx, a request failed, a page did not parse, or
+    the PR has more files than GitHub serves. Best-effort by design -- None means "unknown", and an
+    unknown set filters nothing (the 422 retry in :func:`post_review` still covers that case).
+
+    This set, not the diff codna reviewed, is what GitHub resolves inline comment paths against. An
+    incremental review's diff can differ from it (an "Update branch" merge in the range), and one
+    comment on a path outside it fails the whole review with ``422 Path could not be resolved``."""
+    try:
+        import httpx
+    except Exception:  # httpx is optional at import time; without it the set is simply unknown
+        return None
+    headers = {"Accept": "application/vnd.github+json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    paths: set[str] = set()
+    for page in range(1, _MAX_FILE_PAGES + 1):
+        try:
+            r = httpx.get(f"{_API}/repos/{repo_slug}/pulls/{pr_number}/files", headers=headers,
+                          params={"per_page": 100, "page": page}, timeout=30.0, follow_redirects=True)
+            if r.status_code >= 300:
+                return None
+            batch = r.json()
+        except Exception:  # a transport error or an unparseable page: the set is incomplete -> unknown
+            return None
+        if not isinstance(batch, list):
+            return None
+        for entry in batch:
+            name = entry.get("filename") if isinstance(entry, dict) else None
+            if name:
+                paths.add(str(name))
+        if len(batch) < 100:
+            return paths
+    return None  # more pages than GitHub serves: incomplete, so unknown
+
+
 def fetch_review_context(repo_slug: str, pr_number: int, token: str | None, *, max_pages: int = 3) -> dict:
     """Gather cross-run context for a PR review (best-effort; empty on any failure):
 
@@ -377,7 +445,21 @@ def post_review(
     re-run on the same head does not duplicate threads. ``check_run_id`` (the webhook passes it as
     ``CODNA_CHECK_RUN_ID``) is a Check Run the caller already opened for this review: it is
     completed with the findings instead of a second run being created, so the PR shows exactly one
-    "codna review" check."""
+    "codna review" check.
+
+    Inline comments are anchored only to paths in the PR's diff as GitHub lists it
+    (:func:`fetch_pr_files`, read when there is an inline finding to check); a finding elsewhere is
+    listed in the review body. Should GitHub still answer 422 to a payload that carries inline
+    comments, the review is retried ONCE with every inline finding demoted to the body
+    (:func:`demote_to_summary`): no finding is lost and the check does not turn red because GitHub
+    would not place a thread. That retry composes with the APPROVE -> COMMENT fallback: each fires
+    at most once, the approval one first. Re-routing never changes what this pass FOUND: the event
+    and the approval note are decided from the full result before any finding moves, and a finding
+    already threaded on the PR (dedup's ``skip``) is left out of a demotion rather than repeated.
+
+    The returned counters partition the inline findings this pass found: every one is exactly one of
+    ``inline_posted``, ``demoted_to_summary`` (said in the body) or ``skipped_duplicates`` (already
+    threaded on the PR, wherever it would otherwise have gone)."""
     try:
         import httpx
     except Exception as exc:  # noqa: BLE001
@@ -397,27 +479,53 @@ def post_review(
             skip = set()
 
     unresolved = unresolved_blocking_findings(repo_slug, pr_number, token) if approve else None
+    # What THIS pass found decides the event -- before any finding is re-routed for posting.
+    # Demotion changes where a finding is said, never its severity, and a duplicate left out of the
+    # body is still a finding of this pass.
     event = review_event(result, unresolved_blocking=unresolved, approve=approve)
     note = approval_note(event, result, unresolved, approve=approve)
+
+    inline_found = len(result.inline_findings)
+    demoted = 0
+    if result.inline_findings:
+        # Only a path in the PR's diff (as GitHub lists it) can carry an inline comment; one comment
+        # elsewhere fails the whole review. Read only when there is an inline finding to check.
+        pr_files = fetch_pr_files(repo_slug, pr_number, token)
+        if pr_files is not None:
+            anchored = demote_to_summary(result, keep_paths=pr_files, drop_fingerprints=skip)
+            demoted += len(anchored.summary_findings) - len(result.summary_findings)
+            result = anchored
     payload = build_review_payload(result, skip_fingerprints=skip, event=event, approval=note)
     posted_review = False
+
+    def _create_review(body: dict):
+        return httpx.post(f"{_API}/repos/{repo_slug}/pulls/{pr_number}/reviews", headers=headers,
+                          json=body, timeout=60.0, follow_redirects=True)
+
     # Post the review if there is something new to say (new inline comments), findings exist, or the
     # review is an approval -- an approval with nothing else to say is exactly the review a clean PR
     # needs (a clean review used to post nothing, so no PR ever carried an approval).
     if payload["comments"] or result.findings or event == "APPROVE":
-        resp = httpx.post(
-            f"{_API}/repos/{repo_slug}/pulls/{pr_number}/reviews",
-            headers=headers, json=payload, timeout=60.0, follow_redirects=True,
-        )
+        resp = _create_review(payload)
         if resp.status_code == 422 and event == "APPROVE":
             # The App cannot approve a PR it authored (its own fix PRs). Say the same thing as a
             # comment, when there is anything to say.
             event = "COMMENT"
             note = approval_note(event, result, unresolved, approve=approve) + " (the App cannot approve its own pull request)"
             payload = build_review_payload(result, skip_fingerprints=skip, event=event, approval=note)
-            resp = (httpx.post(f"{_API}/repos/{repo_slug}/pulls/{pr_number}/reviews", headers=headers,
-                               json=payload, timeout=60.0, follow_redirects=True)
-                    if (payload["comments"] or result.findings) else None)
+            resp = _create_review(payload) if (payload["comments"] or result.findings) else None
+        if resp is not None and resp.status_code == 422 and payload["comments"]:
+            # GitHub refused an anchor this payload carried -- a path or line outside the PR's diff
+            # ("Path could not be resolved"); the review's text is not the problem. Say everything
+            # in the body instead and retry once: no finding is lost, and the check does not turn
+            # red because GitHub would not place a thread. Fires after the approval fallback so a
+            # refused approval on a payload with comments is still recognised as such first. A
+            # finding dedup already skipped stays skipped: the PR carries its thread.
+            in_body = demote_to_summary(result, drop_fingerprints=skip)
+            demoted += len(in_body.summary_findings) - len(result.summary_findings)
+            result = in_body
+            payload = build_review_payload(result, skip_fingerprints=skip, event=event, approval=note)
+            resp = _create_review(payload)
         if resp is not None and resp.status_code >= 300:
             raise RuntimeError(f"create review failed: {resp.status_code} {resp.text[:300]}")
         posted_review = resp is not None
@@ -452,6 +560,9 @@ def post_review(
         "event": event,
         "unresolved_blocking": unresolved,
         "inline_posted": len(payload["comments"]),
-        "skipped_duplicates": len(result.inline_findings) - len(payload["comments"]),
+        # inline_found == inline_posted + skipped_duplicates + demoted_to_summary, whichever
+        # fallbacks fired: what was neither posted inline nor said in the body was already on the PR.
+        "skipped_duplicates": inline_found - len(payload["comments"]) - demoted,
+        "demoted_to_summary": demoted,
         "check": check,
     }

{codna-0.2.52 → codna-0.2.54}/codna/scaffold.py

@@ -16,6 +16,11 @@ _CODNA_YAML = """\
 # model:
 #   provider: openai            # openai | anthropic | gemini | google | groq | mistral | openrouter | xai
 #   key: env:CODNA_MODEL_KEY    # env:NAME reads $NAME; keeps the secret out of the file
+#
+# Optional: how `codna fix --tests` (and the GitHub App) runs this repository's tests.
+# Default is pytest, or the runner the repo declares (a pixi `test` task, uv.lock).
+# fix:
+#   test_command: pixi run test
 privacy:
   redact_secrets: true        # posture; codna never disables secret redaction
   # Optional stricter sandbox for environments with kernel-level network isolation