codna 0.2.36__tar.gz → 0.2.38__tar.gz

{codna-0.2.36 → codna-0.2.38}/PKG-INFO

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

{codna-0.2.36 → codna-0.2.38}/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.36"
+__version__ = "0.2.38"

{codna-0.2.36 → codna-0.2.38}/codna/cli.py

@@ -906,11 +906,11 @@ def build_parser() -> argparse.ArgumentParser:
     prv.add_argument("--base", help="diff against this ref (default: HEAD — all uncommitted changes)")
     prv.add_argument("--diff", help="diff range to review, e.g. origin/main...HEAD (overrides --base)")
     prv.add_argument("--pr", help="PR to review/post to: 123, owner/repo#123, or a PR URL")
-    prv.add_argument("--post", action="store_true", help="post the findings to the PR (one review + a 'Codna Review' check); needs --pr + a write token")
+    prv.add_argument("--post", action="store_true", help="post the findings to the PR (one review + a 'codna review' check); needs --pr + a write token")
     prv.add_argument("--github-token", dest="github_token", help="write token for --post (else $GITHUB_TOKEN / $CODNA_GITHUB_TOKEN)")
     prv.add_argument("--min-confidence", dest="min_confidence", type=float, help="only report findings at/above this confidence (default from codna.yaml or 0.75)")
     prv.add_argument("--max-findings", dest="max_findings", type=int, help="cap the number of findings (default from codna.yaml or 10)")
-    prv.add_argument("--blocking", action="store_true", help="make the 'Codna Review' check fail on a blocking-severity finding (default: non-blocking)")
+    prv.add_argument("--blocking", action="store_true", help="make the 'codna review' check fail on a blocking-severity finding (default: non-blocking)")
     prv.add_argument("--effort", choices=("low", "medium", "high"), help="review depth: high = more thorough (more agent iterations), low = cheaper (default: medium)")
     prv.add_argument("--full", action="store_true", help="review the WHOLE PR, not only commits pushed since Codna's last review (default: incremental)")
     prv.add_argument("--model", help="planner/review model (default: provider default)")

{codna-0.2.36 → codna-0.2.38}/codna/review.py

@@ -3,7 +3,7 @@
 Default: a **findings** review — diff the change and run the read-only Cline agent
 (``task_kind="review"``) over it to produce structured, deduped, noise-controlled
 :class:`~codna.review_findings.CodnaReviewFinding` records, optionally posted to a PR as one review
-(inline comments + summary + a "Codna Review" check). ``--triage`` keeps the older engine-backed risk
+(inline comments + summary + a "codna review" check). ``--triage`` keeps the older engine-backed risk
 triage (suspect files/symbols + context reduction).
 """
 from __future__ import annotations

{codna-0.2.36 → codna-0.2.38}/codna/review_findings.py

@@ -1,4 +1,4 @@
-"""Codna Review — turn a diff into validated, deduped, noise-controlled findings.
+"""codna review — turn a diff into validated, deduped, noise-controlled findings.
 
 The review pass runs the read-only Cline agent (``task_kind="review"``) over a diff and normalizes
 its output into :class:`CodnaReviewFinding` records: a stable schema plus a resolved GitHub *diff
@@ -324,7 +324,7 @@ def apply_noise_controls(
 
 
 def check_conclusion(findings: list[CodnaReviewFinding], config: ReviewConfig) -> str:
-    """The "Codna Review" check conclusion. NON-BLOCKING by default: ``failure`` only when blocking is
+    """The "codna review" check conclusion. NON-BLOCKING by default: ``failure`` only when blocking is
     explicitly enabled AND a finding hits a blocking severity; ``success`` = clean; else ``neutral``."""
     if not findings:
         return "success"

{codna-0.2.36 → codna-0.2.38}/codna/review_github.py

@@ -1,4 +1,4 @@
-"""Post a Codna Review to a GitHub PR: ONE review (inline comments + summary) + a check run.
+"""Post a codna review to a GitHub PR: ONE review (inline comments + summary) + a check run.
 
 Pure builders (comment body, review payload, existing-fingerprint scan, summary markdown) are
 unit-tested offline; only :func:`post_review` touches the network. Each inline comment carries a
@@ -17,7 +17,7 @@ import subprocess
 from .review_findings import CATEGORIES, SEVERITIES, CodnaReviewFinding, ReviewResult
 
 _API = "https://api.github.com"
-CHECK_NAME = "Codna Review"
+CHECK_NAME = "codna review"
 _MARKER_RE = re.compile(r"<!--\s*codna:review:fp=([0-9a-f]{6,40})\s*-->")
 # Machine-readable finding payload embedded in every inline comment so the `@codna fix` wedge can
 # reconstruct the finding EXACTLY (path/line/severity/category/title/explanation) — the human markdown
@@ -115,8 +115,8 @@ def summary_body(result: ReviewResult) -> str:
     n = len(result.findings)
     head_mark = reviewed_head_marker(result.head_sha)
     if n == 0:
-        return "**Codna Review** — no high-confidence issues found. ✅\n\n" + fp_marker("none") + "\n" + head_mark
-    lines = [f"**Codna Review** — {n} finding(s): "
+        return "**codna review** — no high-confidence issues found. ✅\n\n" + fp_marker("none") + "\n" + head_mark
+    lines = [f"**codna review** — {n} finding(s): "
              f"{len(result.inline_findings)} inline, {len(result.summary_findings)} in summary.", ""]
     for f in result.summary_findings:
         loc = f"`{f.path}:{f.line}`"
@@ -160,7 +160,7 @@ def build_review_payload(result: ReviewResult, *, skip_fingerprints: set[str] |
 
 
 def fetch_pr(repo_slug: str, pr_number: int, token: str | None) -> dict:
-    """GET the PR metadata Codna Review needs: base ref, head SHA, head ref, fork flag."""
+    """GET the PR metadata codna review needs: base ref, head SHA, head ref, fork flag."""
     import httpx
 
     headers = {"Accept": "application/vnd.github+json"}
@@ -275,13 +275,13 @@ def post_review(
     result: ReviewResult, *, repo_slug: str, pr_number: int, token: str, dedup: bool = True,
     check_run_id: int | None = None,
 ) -> dict:
-    """Post ONE review (+ the "Codna Review" check) to the PR. Returns a small status dict.
+    """Post ONE review (+ the "codna review" check) to the PR. Returns a small status dict.
 
     ``dedup`` fetches existing PR review comments and skips fingerprints Codna already posted, so a
     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."""
     try:
         import httpx
     except Exception as exc:  # noqa: BLE001

{codna-0.2.36 → codna-0.2.38}/codna/webhook.py

@@ -62,7 +62,7 @@ def verify_signature(secret: str, body: bytes, signature_header: str | None) ->
 class WebhookJob:
     """A Codna job derived from a verified GitHub event."""
 
-    kind: str  # "fix" | "secure" | "review"
+    kind: str  # "fix" | "secure" | "review" | "queue" (a merge-queue group inheriting the PR's review)
     repo_full_name: str
     ref: str | None = None
     installation_id: int | None = None
@@ -86,20 +86,36 @@ _FIX_WRITE_ASSOCIATIONS = frozenset({"OWNER", "MEMBER", "COLLABORATOR"})
 # Codna pushes its own fix branches as `codna/<plan-id>` (see packaged_git._validated_branch and
 # fix_run). Recognising that prefix is what stops a CI-failure fix from fixing its own fix PR.
 _CODNA_BRANCH_PREFIX = "codna/"
-# ONE Check Run per job, Title Case, named like a product: "Codna Review" is also the exact name the
-# org ruleset requires. Until 2026-09-18 the worker opened a lowercase "codna review" wrapper run
-# and the CLI added a second, capitalised "Codna Review" run beside it.
-CHECK_RUN_NAMES = {"review": "Codna Review", "fix": "Codna Fix", "secure": "Codna Secure"}
+# ONE Check Run per job, spelled exactly like the CLI command and the PR trigger (`codna review`,
+# `@codna review`): "codna review" is also the exact name the org ruleset requires. Until
+# 2026-09-19 the worker's wrapper run and the CLI's findings run carried different casings.
+CHECK_RUN_NAMES = {"review": "codna review", "fix": "codna fix", "secure": "codna secure"}
 
 
 def check_run_name(kind: str) -> str:
-    """The Check Run name for a job kind: ``Codna Review`` / ``Codna Fix`` / ``Codna Secure``."""
-    return CHECK_RUN_NAMES.get(kind, f"Codna {kind.replace('_', ' ').title()}")
+    """The Check Run name for a job kind: ``codna review`` / ``codna fix`` / ``codna secure``."""
+    return CHECK_RUN_NAMES.get(kind, f"codna {kind.replace('_', ' ')}")
 # The App's own slug on github.com. A self-hosted install runs under a different slug, so the id in
 # GITHUB_APP_ID is checked too (see _is_own_check_suite).
 _OWN_APP_SLUG = "codna-ai"
 
 
+# refs/heads/gh-readonly-queue/<base>/pr-<N>-<base sha> -- the only place a merge group names its PR.
+# Parsed by prefix + last path segment, not by a search over the whole ref: an unanchored regex with a
+# lazy `.+?` over attacker-shaped input is polynomial (CodeQL py/polynomial-redos on the first cut).
+_MERGE_GROUP_PREFIX = "refs/heads/gh-readonly-queue/"
+_MERGE_GROUP_TAIL = re.compile(r"pr-(\d+)-[0-9a-f]{40}")
+
+
+def merge_group_pr_number(head_ref: str) -> int | None:
+    """The pull request number a merge-group ref was built for, or None."""
+    if not head_ref.startswith(_MERGE_GROUP_PREFIX):
+        return None
+    tail = head_ref.rsplit("/", 1)[-1]  # "pr-<N>-<40 hex>"; the base branch may itself contain "/"
+    m = _MERGE_GROUP_TAIL.fullmatch(tail)
+    return int(m.group(1)) if m else None
+
+
 def _is_own_check_suite(suite: Mapping[str, Any]) -> bool:
     """True when a check_suite belongs to this App itself (its review / fix Check Runs)."""
     app = suite.get("app") or {}
@@ -326,6 +342,21 @@ def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
         return WebhookJob("secure", repo, ref=_safe_ref(payload.get("ref")),
                           installation_id=installation, reason="code_scanning_alert")
 
+    if event == "merge_group" and action == "checks_requested":
+        # A merge queue builds a temporary group commit and asks every REQUIRED check to report on
+        # it. "codna review" is required on repos that use one (algenta-sdk), and a check that only
+        # reacts to pull_request events would never appear there -- the queue would time out and
+        # kick the PR. The group is not re-reviewed: the PR head IS what was reviewed (GitHub only
+        # admits a PR to the queue once its required checks passed), so the worker copies that
+        # verdict onto the group commit. Requires the App to be subscribed to "Merge group" events.
+        group = payload.get("merge_group") or {}
+        head_sha = _safe_ref(group.get("head_sha"))
+        number = merge_group_pr_number(str(group.get("head_ref") or ""))
+        if not head_sha or number is None:
+            return None
+        return WebhookJob("queue", repo, ref=head_sha, pr_number=number,
+                          installation_id=installation, reason="merge_group_checks_requested")
+
     if event == "check_suite" and action == "completed":
         suite = payload.get("check_suite") or {}
         conclusion = str(suite.get("conclusion") or "")
@@ -458,7 +489,7 @@ def _fix_issue_text(ctx: Mapping[str, Any]) -> str:
     loc = ctx.get("path") or "(unknown file)"
     if ctx.get("line"):
         loc = f"{loc}:{ctx['line']}"
-    parts = ["Fix the issue Codna Review flagged in this pull request.", f"Location: {loc}"]
+    parts = ["Fix the issue codna review flagged in this pull request.", f"Location: {loc}"]
     if ctx.get("severity") or ctx.get("category"):
         parts.append(f"Severity: {ctx.get('severity') or '?'} ({ctx.get('category') or '?'})")
     if ctx.get("title"):
@@ -484,7 +515,7 @@ def codna_command(
              classification; opening security PRs uses the privilege-separated two-job
              workflow, never a single server process).
     review — ``codna review <url> --pr <n> [--ref <head_sha>] --post --json`` (read-only diff review;
-             completes the job's "Codna Review" check with the findings).
+             completes the job's "codna review" check with the findings).
     """
     url = repo_url or f"https://github.com/{job.repo_full_name}.git"
     if job.kind == "review":
@@ -519,7 +550,7 @@ def codna_command(
                 args += ["--ref", ctx["head_sha"]]
             args += ["--base-branch", ctx["head_ref"],
                      "--pr-title", f"codna: fix {(ctx.get('title') or 'review finding')[:60]}",
-                     "--pr-body", f"Verified fix for a Codna Review finding.\n\n{webhook_marker(job)}"]
+                     "--pr-body", f"Verified fix for a codna review finding.\n\n{webhook_marker(job)}"]
             return args
         args = ["codna", "fix", url, "--open-pr"]
         if job.ref:
@@ -676,6 +707,14 @@ class _Handler(BaseHTTPRequestHandler):
             pool_diag = pool.diagnostics() if pool is not None else None
             worker_ready = True if pool_diag is None else bool(pool_diag.get("ready"))
             ready = secret_ready and app_ready and worker_ready
+            queue = getattr(self.server, "queue", None)
+            try:
+                # Depth by status ({"queued": n, "running": n, "retry": n, ...}): 17 pull requests opened
+                # within a minute on 2026-09-19 sat behind a 2-thread pool for ~15 minutes and nothing
+                # public said why the checks were missing. Counts only -- no job content.
+                queue_counts = queue.counts() if queue is not None else None
+            except Exception:  # noqa: BLE001 -- readiness must never fail because a diagnostic did
+                queue_counts = None
             self._reply(200 if ready else 503, {
                 "service": "codna-webhook",
                 "ok": ready,
@@ -684,6 +723,7 @@ class _Handler(BaseHTTPRequestHandler):
                 "worker": None if pool_diag is None else {
                     k: pool_diag.get(k) for k in ("alive_threads", "busy_threads", "longest_running_s", "wedged")
                 },
+                "queue": queue_counts,
             })
             return
         if path == "/debug/queue":

{codna-0.2.36 → codna-0.2.38}/codna/webhook_github.py

@@ -41,6 +41,9 @@ def token_permissions_for(kind: str, *, workflows: bool = False) -> dict[str, st
     if kind == "review":
         # Read code, write PR review comments + a check. No contents:write — review never pushes.
         return {"contents": "read", "pull_requests": "write", "checks": "write"}
+    if kind == "queue":
+        # Read the PR head + its check runs, write ONE check on the merge-group commit.
+        return {"pull_requests": "read", "checks": "write"}
     raise WebhookError("unknown_job_kind", f"no token scope for job kind {kind!r}")
 
 
@@ -497,3 +500,49 @@ def fetch_code_scanning_sarif(repo_full_name: str, token: str, *, dest_dir: str)
     with open(path, "w", encoding="utf-8") as handle:
         handle.write(sarif.text)
     return path
+
+
+def pull_request_head_sha(repo_full_name: str, token: str, number: int) -> str | None:
+    """The current head SHA of a pull request, or None when it cannot be read."""
+    try:
+        import httpx
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        resp = httpx.get(f"{_API}/repos/{repo_full_name}/pulls/{number}", headers={"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"},
+                         timeout=20.0, follow_redirects=True)
+    except Exception:  # noqa: BLE001
+        return None
+    if resp.status_code != 200:
+        return None
+    try:
+        return str(resp.json()["head"]["sha"])
+    except (ValueError, KeyError, TypeError):
+        return None
+
+
+def latest_completed_check_run(repo_full_name: str, token: str, *, head_sha: str, name: str) -> dict | None:
+    """The newest COMPLETED check run named ``name`` on ``head_sha`` (``conclusion``, ``summary``,
+    ``html_url``), or None. Only this App's own runs are considered."""
+    try:
+        import httpx
+    except Exception:  # noqa: BLE001
+        return None
+    try:
+        resp = httpx.get(f"{_API}/repos/{repo_full_name}/commits/{head_sha}/check-runs",
+                         headers={"Authorization": f"Bearer {token}", "Accept": "application/vnd.github+json"}, params={"check_name": name, "status": "completed", "per_page": 20},
+                         timeout=20.0, follow_redirects=True)
+    except Exception:  # noqa: BLE001
+        return None
+    if resp.status_code != 200:
+        return None
+    try:
+        runs = [r for r in resp.json().get("check_runs", []) if isinstance(r, dict)]
+    except ValueError:
+        return None
+    runs.sort(key=lambda r: str(r.get("completed_at") or ""), reverse=True)
+    for run in runs:
+        if run.get("conclusion"):
+            return {"conclusion": str(run["conclusion"]), "summary": str((run.get("output") or {}).get("summary") or ""),
+                    "html_url": str(run.get("html_url") or "")}
+    return None

{codna-0.2.36 → codna-0.2.38}/codna/webhook_summaries.py

@@ -2,7 +2,7 @@
 behind, and the CLI-error parsing that produces it.
 
 Split out of webhook_worker.py on 2026-09-18 (the 1000-line modularity ceiling); pure functions,
-no I/O. Names are Title Case Check Run names ("Codna Fix failed (cli_error): ...") -- see
+no I/O. Names are the lowercase Check Run names ("codna fix failed (cli_error): ...") -- see
 webhook.check_run_name.
 """
 from __future__ import annotations
@@ -12,7 +12,7 @@ import re
 
 from .webhook import check_run_name
 
-# Summaries are Title Case now ("Codna Fix failed (...)"); lowercase ones may still be in flight.
+# Case-insensitive on purpose: summaries were briefly Title Case ("Codna Fix failed (...)") in 2026-09.
 _CLI_SUMMARY = re.compile(r"^codna \w+ failed \(([^)]+)\): (.*)$", re.S | re.IGNORECASE)
 
 
@@ -85,12 +85,12 @@ def _review_job_summary(stdout: str) -> str | None:
     findings = result.get("findings") or []
     if not findings:
         note = result.get("note")
-        return f"Codna Review: {note}" if note else "Codna Review: no high-confidence issues found ✅"
+        return f"codna review: {note}" if note else "codna review: no high-confidence issues found ✅"
     posted = result.get("posted") or {}
     inline = posted.get("inline_posted", 0)
     summary_n = result.get("summary_count", 0)
     return (
-        f"Codna Review: {len(findings)} finding(s) — {inline} inline, {summary_n} in summary "
+        f"codna review: {len(findings)} finding(s) — {inline} inline, {summary_n} in summary "
         f"(conclusion: {result.get('conclusion', 'unknown')}). See the PR's review comments for details."
     )
 

{codna-0.2.36 → codna-0.2.38}/codna/webhook_worker.py

@@ -134,10 +134,10 @@ def _prepare_comment_fix(job: WebhookJob, *, token: str, app_id: str | None, git
                 "branch). Apply the suggested change manually for now.")
     parent = github.get_pull_review_comment(job.repo_full_name, token, ctx.get("in_reply_to_id"))
     if not parent or not github.comment_authored_by_app(parent, app_id):
-        return "`@codna fix` only works as a reply to a Codna Review finding."
+        return "`@codna fix` only works as a reply to a codna review finding."
     finding = parse_codna_finding(parent.get("body") or "")
     if not finding:
-        return "Couldn't identify a Codna finding on this thread — reply `@codna fix` on a Codna review comment."
+        return "Couldn't identify a codna review finding on this thread — reply `@codna fix` on a codna review comment."
     if not ctx.get("head_ref"):
         return "Couldn't determine the pull-request branch to target for the fix."
     ctx.update({
@@ -286,7 +286,7 @@ def _job_env(
         env["CODNA_GIT_USER_NAME"], env["CODNA_GIT_USER_EMAIL"] = git_identity
     if check_run_id is not None:
         # The Check Run this job opened. `codna review --post` completes THAT run with its findings
-        # instead of opening a second one, so a review shows as ONE "Codna Review" check.
+        # instead of opening a second one, so a review shows as ONE "codna review" check.
         env["CODNA_CHECK_RUN_ID"] = str(check_run_id)
     return env
 
@@ -355,7 +355,7 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
             # consume -- capture_output means it's also sitting right here in proc.stdout. The
             # generic tail-of-stdout fallback below would dump that raw JSON as the Check Run
             # summary verbatim: an unreadable wall of braces where a human expects a sentence. The
-            # detailed findings already live on the "Codna Review" run this same subprocess
+            # detailed findings already live on the "codna review" run this same subprocess
             # completes (review_github.py::summary_body) and as inline PR comments; this summary is
             # only used when the CLI did not complete the run itself.
             summary = _review_job_summary(proc.stdout)
@@ -372,6 +372,33 @@ def run_codna_job(job: WebhookJob, *, token: str | None, engine_key: str | None,
                          check_completed=completed)
 
 
+def _inherit_review_for_merge_group(job: WebhookJob, token: str | None, github: Any) -> JobResult:
+    """Post the PR head's completed ``codna review`` verdict as the merge group's own check.
+
+    Fails CLOSED: when the PR head carries no completed review (a rename window, a repo where the
+    check was never required), the group check is a ``failure`` that says how to get one -- a
+    ``neutral`` would let an unreviewed PR through a queue that requires the review."""
+    name = check_run_name("review")
+    if not (token and job.ref and job.pr_number):
+        return JobResult(False, f"{name} (merge group): missing token, group sha or PR number", retryable=False)
+    head = github.pull_request_head_sha(job.repo_full_name, token, job.pr_number)
+    prior = github.latest_completed_check_run(job.repo_full_name, token, head_sha=head, name=name) if head else None
+    cid = github.create_check_run(job.repo_full_name, token, name=name, head_sha=job.ref,
+                                  summary=f"{name}: inheriting the verdict of PR #{job.pr_number}")
+    if prior is None:
+        text = (f"{name}: no completed review found on PR #{job.pr_number}'s head"
+                f"{' ' + head[:8] if head else ''}. Comment `@codna review` on the PR, then re-queue it.")
+        if cid:
+            github.update_check_run(job.repo_full_name, token, cid, conclusion="failure", summary=text, name=name)
+        return JobResult(False, text, retryable=False)
+    first_line = (prior.get("summary") or "").split("\n", 1)[0][:300]
+    text = (f"{name}: inherited from PR #{job.pr_number} at {head[:8]} ({prior['conclusion']}). "
+            f"Merge groups are not re-reviewed; the queued PR head is what was reviewed. {first_line}").strip()
+    if cid:
+        github.update_check_run(job.repo_full_name, token, cid, conclusion=prior["conclusion"], summary=text, name=name)
+    return JobResult(True, text)
+
+
 def process_job(
     qjob: QueuedJob,
     *,
@@ -393,6 +420,11 @@ def process_job(
             app_id, private_key, job.installation_id, repo_full_name=job.repo_full_name, kind=job.kind
         )
 
+    if job.kind == "queue":
+        # Merge-queue group: copy the PR head's `codna review` verdict onto the group commit. No
+        # metering, no CLI, no review of the group itself -- see classify_event's merge_group branch.
+        return _inherit_review_for_merge_group(job, token, github)
+
     # A `@codna fix` review-comment reply is answered IN-THREAD on every outcome (never silent).
     ctx = job.context or {}
     reply_to = ctx.get("in_reply_to_id") if (job.kind == "fix" and isinstance(ctx.get("in_reply_to_id"), int)) else None

{codna-0.2.36 → codna-0.2.38}/codna.egg-info/PKG-INFO

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

{codna-0.2.36 → codna-0.2.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.36"
+version = "0.2.38"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

{codna-0.2.36 → codna-0.2.38}/tests/test_review_findings.py

@@ -1,4 +1,4 @@
-"""Pure/offline tests for the Codna Review findings pipeline (no agent, no network)."""
+"""Pure/offline tests for the codna review findings pipeline (no agent, no network)."""
 from __future__ import annotations
 
 import os
@@ -571,7 +571,7 @@ def test_fetch_review_context_extracts_head_and_human_feedback(monkeypatch):
 
 
 def test_post_review_completes_the_callers_check_run_instead_of_opening_a_second(monkeypatch):
-    """The webhook opens `Codna Review` before the CLI runs; with its id the CLI completes THAT run
+    """The webhook opens `codna review` before the CLI runs; with its id the CLI completes THAT run
     (one check on the PR). Without an id -- the standalone CLI -- behavior is unchanged."""
     from codna import webhook_github
 
@@ -582,12 +582,12 @@ def test_post_review_completes_the_callers_check_run_instead_of_opening_a_second
     result = rf.ReviewResult(repository="u", base="b", head_sha="h", changed_files=["a.py"], inline_findings=[],
                              summary_findings=[], conclusion="success", dropped={})
     out = rg.post_review(result, repo_slug="o/r", pr_number=5, token="t", dedup=False, check_run_id=9001)
-    assert calls == [("update", 9001, "Codna Review", "success")]        # no create: ONE check
+    assert calls == [("update", 9001, "codna review", "success")]        # no create: ONE check
     assert out["check"] == {"id": 9001, "conclusion": "success", "updated_existing": True}
 
     calls.clear()
     out = rg.post_review(result, repo_slug="o/r", pr_number=5, token="t", dedup=False)
-    assert [c[0] for c in calls] == ["create", "update"] and calls[0][1] == "Codna Review"
+    assert [c[0] for c in calls] == ["create", "update"] and calls[0][1] == "codna review"
     assert out["check"]["updated_existing"] is False
 
 

{codna-0.2.36 → codna-0.2.38}/tests/test_webhook.py

@@ -532,6 +532,32 @@ def test_ready_endpoint_requires_webhook_secret_and_app_auth(monkeypatch):
         httpd.server_close()
 
 
+def test_ready_reports_queue_depth_by_status(tmp_path, monkeypatch):
+    """17 PRs opened within a minute sat behind the 2-thread pool for ~15 min on 2026-09-19 and
+    nothing public said why their checks were missing: /ready now carries the queue depth."""
+    import json as _json
+    import urllib.request
+
+    from codna.webhook_queue import WebhookQueue
+
+    monkeypatch.setenv("CODNA_GITHUB_WEBHOOK_SECRET", "s3cr3t")
+    monkeypatch.setenv("GITHUB_TOKEN", "single-repo-token")
+    queue = WebhookQueue(tmp_path / "q.db")
+    for i in range(3):
+        queue.enqueue(WebhookJob("review", "acme/app", ref=f"sha{i}", installation_id=7, pr_number=i, reason="test"),
+                      delivery_id=f"d{i}")
+    assert queue.claim() is not None                      # one running, two still queued
+    httpd, port = _serve_with_queue(queue)
+    try:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}/ready", timeout=5) as resp:
+            ready = _json.loads(resp.read())
+        assert ready["queue"] == {"queued": 2, "running": 1}   # counts only, never job content
+        assert "recent" not in ready and "jobs" not in ready
+    finally:
+        httpd.shutdown()
+        httpd.server_close()
+
+
 def test_debug_queue_requires_token_and_redacts_recent_results(tmp_path, monkeypatch):
     import json as _json
     import urllib.error
@@ -924,3 +950,43 @@ def test_prepare_scratch_root_without_tmpdir_changes_nothing(monkeypatch):
     monkeypatch.setattr(tempfile, "tempdir", None)
     assert prepare_scratch_root() is None
     assert tempfile.tempdir is None
+
+
+
+# ---- merge queues: the group commit inherits the PR head's review --------------------------------
+
+def _merge_group_payload(action="checks_requested", pr=48, base="main"):
+    return {
+        "action": action,
+        "repository": {"full_name": "acme/app"},
+        "installation": {"id": 42},
+        "merge_group": {
+            "head_sha": "feedfacefeedfacefeedfacefeedfacefeedface",
+            "head_ref": f"refs/heads/gh-readonly-queue/{base}/pr-{pr}-0123456789abcdef0123456789abcdef01234567",
+            "base_ref": f"refs/heads/{base}",
+        },
+    }
+
+
+def test_merge_group_pr_number_parses_the_queue_ref():
+    from codna.webhook import merge_group_pr_number
+
+    assert merge_group_pr_number("refs/heads/gh-readonly-queue/main/pr-48-0123456789abcdef0123456789abcdef01234567") == 48
+    assert merge_group_pr_number("refs/heads/gh-readonly-queue/release/1.x/pr-7-0123456789abcdef0123456789abcdef01234567") == 7
+    assert merge_group_pr_number("refs/heads/feature/pr-48-not-a-queue") is None
+    assert merge_group_pr_number("") is None
+
+
+def test_classify_merge_group_checks_requested_is_a_queue_job():
+    job = classify_event("merge_group", _merge_group_payload())
+    assert job is not None and job.kind == "queue"
+    assert job.repo_full_name == "acme/app" and job.pr_number == 48
+    assert job.ref == "feedfacefeedfacefeedfacefeedfacefeedface"
+    assert job.reason == "merge_group_checks_requested"
+
+
+def test_classify_merge_group_destroyed_or_unparseable_is_ignored():
+    assert classify_event("merge_group", _merge_group_payload(action="destroyed")) is None
+    p = _merge_group_payload()
+    p["merge_group"]["head_ref"] = "refs/heads/something-else"
+    assert classify_event("merge_group", p) is None