codna 0.2.16__tar.gz → 0.2.18__tar.gz

{codna-0.2.16 → codna-0.2.18}/PKG-INFO

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

{codna-0.2.16 → codna-0.2.18}/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.16"
+__version__ = "0.2.18"

{codna-0.2.16 → codna-0.2.18}/codna/agent-core/run-server.bundle.mjs

@@ -110643,7 +110643,7 @@ var init_bowser = __esm(() => {
 
 // agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
 var require_client2 = __commonJS((exports) => {
-  var __dirname = "/Users/angel/actions-runner-mac-3/_work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
+  var __dirname = "/home/runner/work/codna/codna/agent-core/vendor/cline/node_modules/.bun/@aws-sdk+core@3.974.15/node_modules/@aws-sdk/core/dist-cjs/submodules/client";
   var retry2 = require_retry2();
   var protocols = require_protocols();
   var lambdaInvokeStore = require_invoke_store();

{codna-0.2.16 → codna-0.2.18}/codna/ci_admission.py

@@ -33,7 +33,6 @@ import os
 import platform
 import subprocess
 import time
-import uuid
 from dataclasses import dataclass, field
 from pathlib import Path
 

{codna-0.2.16 → codna-0.2.18}/codna/cline_agent.py

@@ -14,7 +14,42 @@ from pathlib import Path
 
 
 class ClineAgentError(Exception):
-    pass
+    def __init__(self, message: str, details: dict[str, object] | None = None) -> None:
+        super().__init__(message)
+        # Per-instance. `codna review` reports the exception's `.details` verbatim, so anything
+        # not put here is invisible to whoever has to act on the failure.
+        self.details: dict[str, object] = dict(details or {})
+
+
+# Enough of the agent's reply to tell the failure modes apart, bounded so a runaway response
+# cannot flood a check summary.
+_RAW_EXCERPT_CHARS = 400
+
+
+def _unparseable_output_details(raw: str) -> dict[str, object]:
+    """What the agent actually said, bounded and redacted.
+
+    Discarding `raw` made this failure undiagnosable: prose instead of JSON, JSON truncated by a
+    token limit, and an empty response all reported the identical sentence. Head AND tail are
+    kept because they show different things -- truncation is only visible at the end, while a
+    refusal or a prose preamble is only visible at the start.
+
+    Redacted through the same helper the agent-core log tail uses, because this text is echoed
+    into a check summary on a public pull request.
+    """
+    from codna.agent_core_runtime import _redact_log_text  # noqa: PLC0415 - avoids a cycle at import
+
+    text = _redact_log_text(raw or "")
+    return {
+        "raw_chars": len(raw or ""),
+        "raw_head": text[:_RAW_EXCERPT_CHARS],
+        "raw_tail": text[-_RAW_EXCERPT_CHARS:] if len(text) > 2 * _RAW_EXCERPT_CHARS else "",
+        "looked_for": [
+            "the whole message as JSON",
+            "a ```json fence",
+            "the first balanced {...} or [...]",
+        ],
+    }
 
 
 def _agent_core_dir() -> Path:
@@ -152,7 +187,10 @@ def extract_findings_json(text: str) -> list[dict]:
                         break
             start = raw.find(opener, start + 1)
 
-    raise ClineAgentError("review agent did not return parseable findings JSON")
+    raise ClineAgentError(
+        "review agent did not return parseable findings JSON",
+        _unparseable_output_details(raw),
+    )
 
 
 def run_cline_review(

{codna-0.2.16 → codna-0.2.18}/codna/evasion.py

@@ -28,6 +28,11 @@ _PATH_CATEGORIES: list[tuple[str, list[re.Pattern]]] = [
         re.compile(r"(^|/)\.snyk$"),
         re.compile(r"(^|/)trivy\.ya?ml$"),
         re.compile(r"\.qlpack\.ya?ml$"),
+        # thyn-ai/security-toolchain: gitleaks rules + path allowlist, repo-local Opengrep rule
+        # packs, and the pinned scanner versions + sha256 digests every binary is verified against.
+        re.compile(r"(^|/)\.gitleaks\.toml$"),
+        re.compile(r"(^|/)security/opengrep/"),
+        re.compile(r"(^|/)security/toolchain\.lock$"),
     ]),
     ("suppression_or_baseline", [
         re.compile(r"(^|/)\.semgrepignore$"),
@@ -36,6 +41,11 @@ _PATH_CATEGORIES: list[tuple[str, list[re.Pattern]]] = [
         re.compile(r"(^|/)\.snyk$"),
         re.compile(r"baseline.*\.sarif$"),
         re.compile(r"(^|/)\.sarif-baseline"),
+        # thyn-ai/security-toolchain: gitleaks fingerprint allowlist, osv-scanner ignore/override
+        # config, and the CI-measured `security/baseline/<tool>.txt` ratchet files.
+        re.compile(r"(^|/)\.gitleaksignore$"),
+        re.compile(r"(^|/)osv-scanner\.toml$"),
+        re.compile(r"(^|/)security/baseline/"),
     ]),
     ("ci_or_test_config", [
         re.compile(r"(^|/)\.github/workflows/"),
@@ -71,7 +81,7 @@ _LOCKFILES = {
 # No surrounding \b anchors — several directives start/end with non-word chars (#, [, :).
 _INLINE_SUPPRESSIONS = re.compile(
     r"(nosemgrep|nosem|lgtm\s*\[|#\s*nosec|NOSONAR|checkov:skip|eslint-disable"
-    r"|trivy:ignore|snyk:ignore|//\s*codeql[^\n]*\bignore)",
+    r"|trivy:ignore|snyk:ignore|gitleaks:allow|//\s*codeql[^\n]*\bignore)",
     re.IGNORECASE,
 )
 

{codna-0.2.16 → codna-0.2.18}/codna/findings.py

@@ -213,7 +213,7 @@ class NormalizedFinding:
 
 @dataclass
 class ScannerIdentity:
-    name: str  # canonical: codeql|semgrep|snyk|trivy|...
+    name: str  # canonical: codeql|semgrep|snyk|trivy|opengrep|gitleaks|osv-scanner|...
     raw_name: str
     version: str | None
     guid: str | None

{codna-0.2.16 → codna-0.2.18}/codna/memory.py

@@ -513,7 +513,7 @@ def _embedder():
 # Recall-time rerank pipeline — split into memory_rerank.py (MOD-FILESIZE 1000-line ceiling). The
 # names are re-imported here so the public import surface (`from codna.memory import ...`) and the
 # recall() call sites below are unchanged.
-from .memory_rerank import (  # noqa: F401
+from .memory_rerank import (  # noqa: E402, F401
     _is_test_symbol,
     _query_is_test_oriented,
     _semantic_rerank,

{codna-0.2.16 → codna-0.2.18}/codna/packaged_agent_runner.py

@@ -116,7 +116,11 @@ class SidecarPackagedAgentRunner:
                     "body": response.text[:2000],
                 },
             )
-        return _parse_final_frame(response.text, sidecar_url=endpoint.url)
+        return _parse_final_frame(
+            response.text,
+            sidecar_url=endpoint.url,
+            task_kind=_validated_task_kind(request.task_kind),
+        )
 
 
 def _sidecar_payload(request: PackagedAgentRunRequest, workspace: Path) -> dict[str, Any]:
@@ -521,7 +525,33 @@ def _is_relative_to(path: Path, parent: Path) -> bool:
         return False
 
 
-def _parse_final_frame(body: str, *, sidecar_url: str) -> dict[str, Any]:
+def _terminal_states_meaning_success(task_kind: str) -> set[str]:
+    """Which terminal states count as a completed run, for THIS kind of run.
+
+    A review is dispatched with NO write scope -- `_sidecar_payload` sets
+    `allowed_write_paths` and `allowed_write_scope` to `[]` for task_kind == "review", on
+    purpose, because a review analyses and must not modify the repository. agent-core emits
+    `apply_blocked` in exactly that situation (artifacts.ts: allowedWriteScope.length === 0
+    and some tool call succeeded).
+
+    So a review that works PERFECTLY always terminates in `apply_blocked`. It is the success
+    signal for a read-only run, not a failure. Demanding "succeeded" made `codna review`
+    impossible to pass -- not flaky, categorically impossible -- which is why it failed on
+    every pull request across the org with an identical message.
+
+    codna already encodes this judgement elsewhere: cline_parity_report.py:423 accepts
+    {"engine_evidence_missing", "succeeded", "apply_blocked"} as a proved engine gate. This
+    brings the runner into line with it.
+
+    For a FIX, `apply_blocked` stays a genuine failure: a fix that was not allowed to write
+    has not fixed anything.
+    """
+    if task_kind == "review":
+        return {"succeeded", "apply_blocked"}
+    return {"succeeded"}
+
+
+def _parse_final_frame(body: str, *, sidecar_url: str, task_kind: str = "fix") -> dict[str, Any]:
     final: dict[str, Any] | None = None
     for line in body.splitlines():
         if not line.strip():
@@ -544,7 +574,8 @@ def _parse_final_frame(body: str, *, sidecar_url: str) -> dict[str, Any]:
         )
     terminal_state = final.get("terminal_state")
     status = final.get("status")
-    if terminal_state != "succeeded" and status not in {"succeeded", "success", "completed"}:
+    accepted = _terminal_states_meaning_success(task_kind)
+    if terminal_state not in accepted and status not in {"succeeded", "success", "completed"}:
         raise PackagedRepositoryAdvancedError(
             "agent_core_run_failed",
             "Local agent-core did not complete the packaged fix run successfully.",
@@ -552,6 +583,8 @@ def _parse_final_frame(body: str, *, sidecar_url: str) -> dict[str, Any]:
                 "sidecar_url": sidecar_url,
                 "status": status,
                 "terminal_state": terminal_state,
+                "task_kind": task_kind,
+                "accepted_terminal_states": sorted(accepted),
                 "error": final.get("error"),
             },
         )

{codna-0.2.16 → codna-0.2.18}/codna/review.py

@@ -14,11 +14,37 @@ import subprocess
 
 class ReviewError(RuntimeError):
     code = "review_error"
-    details: dict[str, object] = {}
 
-
-def _fail(message: str) -> None:
-    raise ReviewError(message)
+    def __init__(self, message: str, details: dict[str, object] | None = None) -> None:
+        super().__init__(message)
+        # Per-INSTANCE. `details` used to be a bare class attribute, so it was one shared dict
+        # that nothing ever wrote to: every review failure serialised `"details": {}`. That
+        # included the agent-core failures, whose wrapped PackagedRepositoryAdvancedError
+        # carries sidecar_url / status / terminal_state / error -- all of it dropped by the
+        # stringifying `except` below. The check run then said only "review agent failed:
+        # Local agent-core did not complete the packaged fix run successfully." with an empty
+        # object, which names the symptom and withholds every field needed to act on it.
+        self.details: dict[str, object] = dict(details or {})
+
+
+def _fail(message: str, details: dict[str, object] | None = None) -> None:
+    raise ReviewError(message, details)
+
+
+def _wrapped_details(exc: BaseException) -> dict[str, object]:
+    """Structured detail carried by a wrapped error, if it has any.
+
+    Errors raised inside the runtime already describe themselves precisely -- a stub runtime, a
+    run that reached a terminal failure, and an unreachable sidecar are three different problems
+    that all stringify to nearly the same sentence. Keeping the fields is what makes them
+    distinguishable from the pull request, without leaking a traceback.
+    """
+    details = getattr(exc, "details", None)
+    out: dict[str, object] = dict(details) if isinstance(details, dict) else {}
+    code = getattr(exc, "code", None)
+    if isinstance(code, str) and code:
+        out.setdefault("cause_code", code)
+    return out
 
 
 def changed_files(repo_dir: str, base: str = "HEAD") -> list[str]:
@@ -195,7 +221,10 @@ def run_findings_review(args) -> dict:
             model=getattr(args, "model", None) or None,
         )
     except Exception as exc:  # noqa: BLE001 - agent/runtime failures must not leak tracebacks.
-        _fail(f"review agent failed: {exc}")
+        # Carry the wrapped error's own fields through. Not leaking a traceback is the rule;
+        # discarding the structured detail alongside it was an accident, and it is what left
+        # every agent-core failure reported as one sentence and an empty object.
+        _fail(f"review agent failed: {exc}", _wrapped_details(exc))
     out = result.to_dict()
 
     if getattr(args, "post", False):

{codna-0.2.16 → codna-0.2.18}/codna/sarif.py

@@ -74,6 +74,16 @@ _SCANNER_ALIASES = {
     "snyk open source": "snyk",
     "trivy": "trivy",
     "aqua trivy": "trivy",
+    # thyn-ai/security-toolchain drivers, `tool.driver.name` exactly as each binary writes it
+    # (lower-cased by `_canon_scanner`): opengrep `--sarif-output` says "Opengrep OSS" (toolchain
+    # tests/test_gate.py:23), `gitleaks -f sarif` says "gitleaks" (report/constants.go:4),
+    # `osv-scanner --format sarif` says "osv-scanner" (internal/output/sarif.go).
+    # Opengrep is a Semgrep fork but a distinct, separately pinned tool: never fold it into semgrep
+    # (the cross-run identity check below relies on distinct canonical names).
+    "opengrep": "opengrep",
+    "opengrep oss": "opengrep",
+    "gitleaks": "gitleaks",
+    "osv-scanner": "osv-scanner",
 }
 
 
@@ -369,7 +379,8 @@ def _has_cve(rule_id: str, rule: dict, result: dict) -> bool:
 def _classify_kind(rule_id: str, rule: dict, result: dict, scanner: str) -> FindingKind:
     tags = _tags(rule, result)
     has_flows = bool(result.get("codeFlows"))
-    if tags & {"secret", "credential", "credentials", "key", "token"}:
+    # gitleaks is a secrets-only scanner and its SARIF rules carry no tags: classify by identity.
+    if scanner == "gitleaks" or tags & {"secret", "credential", "credentials", "key", "token"}:
         return FindingKind.SECRET
     if _has_cve(rule_id, rule, result) or tags & {"sca", "supply-chain", "dependency", "vulnerability"}:
         return FindingKind.SCA

{codna-0.2.16 → codna-0.2.18}/codna/webhook.py

@@ -83,6 +83,10 @@ _CODNA_COMMENT_RE = re.compile(r"^\s*@codna\s+(review|fix)\b", re.IGNORECASE)
 # the commenter's standing; a drive-by/external commenter (CONTRIBUTOR / NONE) cannot trigger a fix.
 _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/"
+
 
 def _parse_codna_command(body: Any) -> str | None:
     """Return the verb ('review' | 'fix') from the first `@codna <verb>` line in a comment, else None."""
@@ -211,16 +215,22 @@ def _classify_feedback_repo_fix(payload: Mapping[str, Any], *, installation: int
 def classify_event(event: str, payload: Mapping[str, Any]) -> WebhookJob | None:
     """Map a GitHub ``(event, payload)`` to a Codna job, or ``None`` to ignore it.
 
-    fix    — an issue labeled ``codna-fix``, or ``@codna fix`` on a review-comment thread.
+    fix    — an issue labeled ``codna-fix``, ``@codna fix`` on a review-comment thread, or a
+             ``check_suite`` that FAILED on a pull request.
     secure — an issue labeled ``codna-secure``, or a ``code_scanning_alert`` appearing.
     review — a PR opened/updated, or ``@codna review`` on a PR (conversation or inline thread).
 
-    Deliberately does NOT react to a failing CI ``check_suite`` by itself — that reacts to ANY
-    red check on a push (including infra/outage-caused flakes that have nothing to do with the
-    code, and resolve on their own retry) rather than something a human actually asked for. That
-    is not how Cursor's Bugbot works either: it reacts to a pull request, not to a repo's overall
-    CI health. Every trigger here now requires an explicit human action -- a label, an @-mention,
-    or opening/updating a PR.
+    Still does NOT react to a repo's overall CI health. The original objection stands and is worth
+    restating, because it is what shapes the check_suite branch below: reacting to ANY red check on
+    a push catches infra/outage flakes that have nothing to do with the code and resolve on their
+    own retry, and it is not how Cursor's Bugbot works either — it reacts to a pull request, not to
+    a repo's CI health.
+
+    A check_suite that failed ON A PULL REQUEST is the case that objection does not cover. The PR
+    is itself the explicit human action this function requires (``opening/updating a PR`` was
+    already accepted as one), and the failure is scoped to that person's proposed change rather
+    than to the repo at large. So the branch below admits exactly that and nothing else: a
+    ``failure`` conclusion, associated with a PR, on a branch Codna did not open.
     """
     action = str(payload.get("action") or "")
     repo = _repo_full_name(payload)
@@ -289,6 +299,47 @@ 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 == "check_suite" and action == "completed":
+        suite = payload.get("check_suite") or {}
+        conclusion = str(suite.get("conclusion") or "")
+        if conclusion != "failure":
+            # `cancelled` / `timed_out` / `stale` / `neutral` / `skipped` are not evidence that the
+            # code is broken. Measured on thyn-ai/algenta across a single day: of 25 check suites,
+            # 19 succeeded, 5 were CANCELLED by a concurrency group and 1 genuinely failed. Treating
+            # anything but `failure` as fixable would spend a metered run on infrastructure noise —
+            # precisely the objection in this function's docstring.
+            return None
+        for pr in suite.get("pull_requests") or []:
+            number = pr.get("number")
+            if not isinstance(number, int):
+                continue
+            head = pr.get("head") or {}
+            head_ref = str(head.get("ref") or "")
+            if head_ref.startswith(_CODNA_BRANCH_PREFIX):
+                # Codna's own fix PRs run CI like any other. Without this, a fix PR whose checks go
+                # red triggers a fix OF THE FIX, whose checks go red, and so on — an unbounded loop
+                # that spends a metered run and opens a PR on every cycle.
+                continue
+            head_sha = _safe_ref(head.get("sha"))
+            # `head_ref` travels in context so the command builder can target the PR's OWN branch:
+            # a fix PR opened against the default branch would try to repair code that only exists
+            # on this PR's branch.
+            ctx = {"head_ref": head_ref} if head_ref else None
+            return WebhookJob("fix", repo, ref=head_sha, pr_number=number,
+                              installation_id=installation, context=ctx,
+                              reason="check_suite_failure")
+        # No associated pull request means this was a push to a branch — the repo-CI-health case
+        # the docstring rejects. Ignored on purpose.
+        #
+        # Two behaviours here are inherited rather than chosen, and are worth knowing:
+        #   - fork PRs are reported to arrive with an EMPTY `pull_requests` list, which would make
+        #     fork CI unable to trigger a fix. That is the behaviour we want, but it is GitHub's
+        #     to change and is NOT verified here — do not rely on it as a security boundary.
+        #   - draft PRs are not distinguishable from this payload (the PR objects are minimal), so
+        #     unlike the `review` branch above this does not skip them. A draft's red CI will be
+        #     fixed. If that turns out to be unwanted, it needs an API round-trip to detect.
+        return None
+
     return None
 
 
@@ -438,6 +489,11 @@ def codna_command(
             # A fix job with a ref but no comment context and no issue text -- let codna discover
             # what's actually failing by running the repo's own tests against this commit.
             args += ["--ref", job.ref, "--tests"]
+            if ctx.get("head_ref"):
+                # CI-failure fix on a PR: stack onto the PR's OWN branch. Targeting the default
+                # branch instead would try to repair code that does not exist there yet -- the
+                # failing change lives only on this PR's branch until it merges.
+                args += ["--base-branch", ctx["head_ref"]]
         elif job.issue_number or issue_text or ctx.get("feedback_issue"):
             # Label-triggered (labeled_codna_fix, or a feedback-routed report -- both have no
             # commit/tests to run): `codna fix` requires one of --issue/--tests/--from-junit or it

{codna-0.2.16 → codna-0.2.18}/codna.egg-info/PKG-INFO

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

{codna-0.2.16 → codna-0.2.18}/codna.egg-info/SOURCES.txt

@@ -105,6 +105,7 @@ tests/test_cli_fix.py
 tests/test_cli_parser.py
 tests/test_cli_register.py
 tests/test_cli_surface_parity.py
+tests/test_cline_agent_unparseable_details.py
 tests/test_cline_fork_guard.py
 tests/test_codeunits.py
 tests/test_codeunits_treesitter.py
@@ -154,6 +155,7 @@ tests/test_netjail.py
 tests/test_packaged_confidence.py
 tests/test_packaged_guidance.py
 tests/test_packaged_remote_pr.py
+tests/test_packaged_runner_review_terminal_state.py
 tests/test_packaged_test_fix_scope.py
 tests/test_packaging.py
 tests/test_patchgen.py
@@ -163,6 +165,7 @@ tests/test_release_readiness.py
 tests/test_repo_backend.py
 tests/test_report_cli.py
 tests/test_repository_artifacts.py
+tests/test_review_error_details.py
 tests/test_review_findings.py
 tests/test_rules_and_review.py
 tests/test_runtime_config.py
@@ -191,5 +194,6 @@ tests/test_webhook_worker_feedback_dispatch.py
 tests/test_wheel_guard.py
 tests/test_wheel_smoke_script.py
 tests/test_worker.py
+tests/test_workflows.py
 tests/test_worktree.py
 tests/test_writer.py

{codna-0.2.16 → codna-0.2.18}/pyproject.toml

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