codna 0.2.36__tar.gz → 0.2.37__tar.gz

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

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

{codna-0.2.36 → codna-0.2.37}/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.37"

{codna-0.2.36 → codna-0.2.37}/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.37}/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.37}/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.37}/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.37}/codna/webhook.py

@@ -86,15 +86,15 @@ _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"
@@ -458,7 +458,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 +484,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 +519,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:

{codna-0.2.36 → codna-0.2.37}/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.37}/codna/webhook_worker.py

@@ -134,7 +134,7 @@ 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."
@@ -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)

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

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

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

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

{codna-0.2.36 → codna-0.2.37}/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.37}/tests/test_webhook_worker.py

@@ -538,13 +538,13 @@ def test_review_job_summary_reformats_valid_json_into_a_short_sentence():
     assert summary is not None
     assert "{" not in summary and "}" not in summary  # never raw JSON
     assert "2 finding(s)" in summary and "2 inline" in summary and "neutral" in summary
-    assert "Codna Review" in summary  # points at the check that has the real detail
+    assert "codna review" in summary  # points at the check that has the real detail
 
 
 def test_review_job_summary_no_findings():
     stdout = json.dumps({"findings": [], "inline_count": 0, "summary_count": 0, "conclusion": "success"})
     summary = worker_module._review_job_summary(stdout)
-    assert summary == "Codna Review: no high-confidence issues found ✅"
+    assert summary == "codna review: no high-confidence issues found ✅"
 
 
 def test_review_job_summary_falls_back_to_none_on_anything_else():
@@ -583,13 +583,13 @@ def test_error_json_summary_renders_the_documented_cli_error_as_a_sentence():
         {"error": {"code": "cli_error", "message": "could not prepare remote checkout for --tests: timed out", "details": {}}},
         indent=2)
     s = worker_module._error_json_summary("fix", "", stderr)
-    assert s == "Codna Fix failed (cli_error): could not prepare remote checkout for --tests: timed out"
+    assert s == "codna fix failed (cli_error): could not prepare remote checkout for --tests: timed out"
 
 
 def test_error_json_summary_picks_the_last_error_object_and_ignores_noise():
     text = 'garbage {"not": "json"\n' + json.dumps({"error": {"code": "a", "message": "first"}}) + "\nmore\n" \
            + json.dumps({"error": {"code": "b", "message": "second"}}) + "\ntrailing"
-    assert worker_module._error_json_summary("secure", text) == "Codna Secure failed (b): second"
+    assert worker_module._error_json_summary("secure", text) == "codna secure failed (b): second"
 
 
 def test_error_json_summary_is_none_without_a_structured_error():
@@ -607,7 +607,7 @@ def test_run_codna_job_fix_kind_failure_uses_the_error_message_not_raw_stderr(mo
     job = WebhookJob("fix", "acme/app", ref="sha1", installation_id=42, reason="check_suite_failure")
     res = run_codna_job(job, token="t", engine_key="k", codna_bin=str(fake_bin))
     assert res.ok is False
-    assert res.summary == "Codna Fix failed (cli_error): pytest is not installed"
+    assert res.summary == "codna fix failed (cli_error): pytest is not installed"
 
 
 # --- check runs: a retry must supersede a dead in_progress run, not stack a second one ----------
@@ -626,7 +626,7 @@ def test_process_job_completes_stale_in_progress_runs_before_opening_a_new_one()
     assert "complete_stale" in names and "create_check" in names
     assert names.index("complete_stale") < names.index("create_check")
     stale = next(c for c in gh.calls if c[0] == "complete_stale")
-    assert stale[1] == "sha1" and stale[2] == "Codna Fix"
+    assert stale[1] == "sha1" and stale[2] == "codna fix"
 
 
 def test_process_job_tolerates_a_github_client_without_stale_cleanup():
@@ -915,7 +915,7 @@ def test_comment_fix_skips_when_parent_is_not_codna_authored():
                          runner=lambda job, **kw: ran.append(1) or JobResult(True, "x"),
                          resolve_engine_key=lambda iid: "org-key")
     assert result.ok and ran == []
-    assert any("only works as a reply to a Codna Review finding" in b for (_p, _r, b) in gh.replies)
+    assert any("only works as a reply to a codna review finding" in b for (_p, _r, b) in gh.replies)
 
 
 def test_comment_fix_unlinked_org_replies_in_thread_and_never_spends():
@@ -1536,10 +1536,10 @@ def test_process_job_hands_the_app_bot_identity_to_the_runner():
 def test_check_run_name_is_title_case_and_matches_the_ruleset():
     from codna.webhook import check_run_name
 
-    assert check_run_name("review") == "Codna Review"   # the exact name the org ruleset requires
-    assert check_run_name("fix") == "Codna Fix"
-    assert check_run_name("secure") == "Codna Secure"
-    assert check_run_name("odd_kind") == "Codna Odd Kind"
+    assert check_run_name("review") == "codna review"   # the exact name the org ruleset requires
+    assert check_run_name("fix") == "codna fix"
+    assert check_run_name("secure") == "codna secure"
+    assert check_run_name("odd_kind") == "codna odd kind"
 
 
 def test_job_env_hands_the_jobs_check_run_id_to_the_cli():
@@ -1561,7 +1561,7 @@ def test_cli_completed_check_detects_only_this_jobs_run():
 def test_process_job_opens_one_title_case_check_and_leaves_it_to_the_cli_when_it_completed_it():
     """REGRESSION (2026-09-18, owner: "one is capital and the other all lowercase, not professional"):
     a review used to show TWO checks -- the worker's lowercase `codna review` wrapper and the CLI's
-    `Codna Review`. Now the worker opens `Codna Review`, hands its id to the CLI, and does not
+    `codna review`. Now the worker opens `codna review`, hands its id to the CLI, and does not
     overwrite the findings the CLI completed it with."""
     class _Gh(_FakeGitHub):
         def create_check_run(self, repo, token, *, name, head_sha, summary):
@@ -1573,13 +1573,13 @@ def test_process_job_opens_one_title_case_check_and_leaves_it_to_the_cli_when_it
 
     def runner(job, **kw):
         seen.update(kw)
-        return JobResult(True, "Codna Review: 2 finding(s)", check_completed=True)
+        return JobResult(True, "codna review: 2 finding(s)", check_completed=True)
 
     result = process_job(_qjob(kind="review"), app_id="a", private_key="p", github=gh, runner=runner,
                          resolve_engine_key=lambda iid: "org-key")
     assert result.ok
     assert seen["check_run_id"] == 9001                                   # the CLI got the run to complete
-    assert ("create_check", "Codna Review", "Codna Review started (test)") in gh.calls
+    assert ("create_check", "codna review", "codna review started (test)") in gh.calls
     assert not any(c[0] == "update_check" for c in gh.calls)              # findings left untouched
 
 
@@ -1594,14 +1594,14 @@ def test_process_job_still_completes_the_check_itself_when_the_cli_did_not():
                          runner=lambda job, **kw: JobResult(True, "opened PR #5"),
                          resolve_engine_key=lambda iid: "org-key")
     assert result.ok
-    assert ("create_check", "Codna Fix", "Codna Fix started (test)") in gh.calls
+    assert ("create_check", "codna fix", "codna fix started (test)") in gh.calls
     assert ("update_check", "success") in gh.calls
 
 
 def test_terse_cli_failure_handles_the_title_case_summary():
     """REGRESSION (Codna review of #539): the terse-clause regex matched only `codna fix failed (`;
     with Title-Case summaries it fell through and pasted the raw paths/argv into the PR thread."""
-    raw = ('Codna Fix failed (cli_error): apply failed: Git command failed | code=git_command_failed | '
+    raw = ('codna fix failed (cli_error): apply failed: Git command failed | code=git_command_failed | '
            'details={"args": ["git", "apply"], "cwd": "/tmp/x", "stderr": "error: corrupt patch at line 99"}')
     terse = worker_module._terse_cli_failure(raw)
     assert "/tmp/x" not in terse and '"args"' not in terse