codna 0.2.42__tar.gz → 0.2.44__tar.gz

{codna-0.2.42 → codna-0.2.44}/PKG-INFO

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

{codna-0.2.42 → codna-0.2.44}/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.42"
+__version__ = "0.2.44"

{codna-0.2.42 → codna-0.2.44}/codna/webhook_ci_triage.py

@@ -255,12 +255,21 @@ def triage(job: Any, token: str, github: Any, *, app_id: str | None = None,
         else:
             # A list, not a generator: `all()` on a lazy generator stops at the first refusal and
             # would leave every later workflow run un-re-run while the summary blames "the API".
-            outcomes = [bool(_call(getattr(github, "rerun_failed_jobs", None), repo, actions_token, rid))
-                        for rid in run_ids]
-            rerun = all(outcomes)
-            action = (f"Re-ran the failed jobs (workflow run{'s' if len(run_ids) > 1 else ''} "
-                      f"{', '.join(str(r) for r in run_ids)}, attempt {attempt + 1})." if rerun else
-                      "Re-running the failed jobs was refused by the API; re-run them manually.")
+            outcomes = {rid: bool(_call(getattr(github, "rerun_failed_jobs", None), repo, actions_token, rid))
+                        for rid in run_ids}
+            done = [str(r) for r, ok in outcomes.items() if ok]
+            refused = [str(r) for r, ok in outcomes.items() if not ok]
+            rerun = not refused
+            if rerun:
+                action = (f"Re-ran the failed jobs (workflow run{'s' if len(done) > 1 else ''} "
+                          f"{', '.join(done)}, attempt {attempt + 1}).")
+            elif done:
+                # Say exactly what happened: some runs were re-run, others the API refused.
+                action = (f"Re-ran the failed jobs of workflow run{'s' if len(done) > 1 else ''} "
+                          f"{', '.join(done)} (attempt {attempt + 1}); the API refused to re-run "
+                          f"{', '.join(refused)} -- re-run {'those' if len(refused) > 1 else 'that one'} manually.")
+            else:
+                action = "Re-running the failed jobs was refused by the API; re-run them manually."
         return CITriage("infrastructure", summary=_infrastructure_summary(infra, rerun_action=action),
                         rerun=rerun)
     if any(ev.verdict == "code" for ev in evidence):

{codna-0.2.42 → codna-0.2.44}/codna/webhook_github.py

@@ -8,6 +8,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 from typing import Any, Mapping
 
 from .webhook import WebhookError
@@ -567,12 +568,15 @@ def latest_completed_check_run(repo_full_name: str, token: str, *, head_sha: str
 _FAILED_CONCLUSIONS = frozenset({"failure", "timed_out"})
 
 
+_LINK_NEXT_RE = re.compile(r'<([^<>]+)>\s*;[^,<>]*\brel="next"')
+
+
 def _next_page(link_header: str) -> str | None:
-    """The URL of ``rel="next"`` in a GitHub ``Link`` header, or None on the last page."""
-    for part in (link_header or "").split(","):
-        if 'rel="next"' in part:
-            return part.split(";")[0].strip().strip("<>") or None
-    return None
+    """The URL of ``rel="next"`` in a GitHub ``Link`` header, or None on the last page. Matched
+    on the ``<url>; rel="next"`` shape itself rather than by splitting on commas, which a URL may
+    contain."""
+    m = _LINK_NEXT_RE.search(link_header or "")
+    return m.group(1) if m else None
 
 
 _SUITE_PAGES_MAX = 5  # 500 check runs; a suite beyond that is reported unknown, never falsely green

{codna-0.2.42 → codna-0.2.44}/codna/webhook_summaries.py

@@ -40,6 +40,7 @@ def _terse_cli_failure(summary: str) -> str:
     if not m:
         return summary
     code, rest = m.group(1), m.group(2)
+    rest = rest.split(_DETAILS_FENCE, 1)[0]  # the structured-detail block stays in the Check Run
     rest = re.sub(r"\s*\(patch ref: [^)]*\)?\s*$", "", rest)
     # The details payload may be TRUNCATED (the summary is capped), so never require a closing
     # brace: cut at the marker and pull stderr out with a regex that tolerates a missing end quote.
@@ -107,6 +108,35 @@ def _cli_completed_check(stdout: str, check_run_id: int | None) -> bool:
     return bool(check.get("updated_existing")) and check.get("id") == check_run_id
 
 
+# Structured-error fields worth showing under the sentence. `raw_head` / `raw_tail` are the review
+# agent's actual (redacted) output when it was not findings JSON: without them "did not return
+# parseable findings JSON" names a symptom and withholds the diagnosis (thyn-ai/test-codna-app-e2e#15,
+# 2026-09-19: three identical red runs, nothing to read). The agent-core fields (`status`,
+# `terminal_state`, `sidecar_url`, `error`) distinguish a stub runtime from a dead sidecar.
+_DETAIL_KEYS = ("cause_code", "status", "terminal_state", "error", "sidecar_url", "raw_chars", "raw_head", "raw_tail")
+_DETAILS_FENCE = "\n\n```\n"
+_DETAIL_VALUE_CHARS = 600
+
+
+def _details_block(details: object) -> str:
+    """The CLI's structured error details, bounded and fenced, or "" when there is nothing to show.
+    Values were redacted at the source (cline_agent._unparseable_output_details); this only bounds
+    them and keeps a stray fence from breaking out of the block."""
+    if not isinstance(details, dict):
+        return ""
+    lines = []
+    for key in _DETAIL_KEYS:
+        value = details.get(key)
+        if value in (None, "", [], {}):
+            continue
+        text = value if isinstance(value, str) else json.dumps(value, sort_keys=True)
+        text = text.replace("```", "'" * 3)
+        if len(text) > _DETAIL_VALUE_CHARS:
+            text = text[:_DETAIL_VALUE_CHARS] + "…"
+        lines.append(f"{key}: {text}")
+    return _DETAILS_FENCE + "\n".join(lines) + "\n```" if lines else ""
+
+
 def _error_json_summary(kind: str, *streams: str | None) -> str | None:
     """Short, markdown-safe summary when the CLI ended with its documented structured error.
 
@@ -132,6 +162,7 @@ def _error_json_summary(kind: str, *streams: str | None) -> str | None:
                 code = err.get("code") or "error"
                 # 1500, not 400: the CLI embeds git's stderr at the END of the message, and a
                 # 400-char cap cut every live push/apply failure right before its reason.
-                return f"{check_run_name(kind)} failed ({code}): {str(err['message'])[:1500]}"
+                return (f"{check_run_name(kind)} failed ({code}): {str(err['message'])[:1500]}"
+                        + _details_block(err.get("details")))
             pos = text.rfind('"error"', 0, pos)
     return None

{codna-0.2.42 → codna-0.2.44}/codna.egg-info/PKG-INFO

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

{codna-0.2.42 → codna-0.2.44}/pyproject.toml

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

{codna-0.2.42 → codna-0.2.44}/tests/test_webhook_ci_triage.py

@@ -247,3 +247,19 @@ def test_every_workflow_run_is_rerun_even_when_the_first_is_refused():
     t = triage(_job(), "fix-token", gh, app_id="a", private_key="p")
     assert t.verdict == "infrastructure" and not t.rerun
     assert [c for c in gh.calls if c[0] == "rerun"] == [("rerun", 1, "tok-ci_rerun"), ("rerun", 2, "tok-ci_rerun")]
+
+
+def test_a_partial_rerun_says_exactly_which_runs_were_refused():
+    class _Picky(_GitHub):
+        def rerun_failed_jobs(self, repo, token, run_id):
+            self.calls.append(("rerun", run_id, token))
+            return run_id != 1
+
+    run_b = {**RUN, "id": 9002, "name": "Other install"}
+    gh = _Picky(failing=[RUN, run_b], jobs={9001: JOB, 9002: {**JOB, "run_id": 2}},
+                logs={9001: BUN_LOG, 9002: BUN_LOG})
+    t = triage(_job(), "fix-token", gh, app_id="a", private_key="p")
+    assert not t.rerun
+    assert "Re-ran the failed jobs of workflow run 2" in t.summary
+    assert "refused to re-run 1" in t.summary
+    assert "refused by the API; re-run them manually" not in t.summary   # that line is for zero successes

{codna-0.2.42 → codna-0.2.44}/tests/test_webhook_github_ci.py

@@ -45,3 +45,9 @@ def test_next_page_parsing():
     assert gh._next_page('<https://a/b?page=2>; rel="next", <https://a/b?page=9>; rel="last"') == "https://a/b?page=2"
     assert gh._next_page('<https://a/b?page=9>; rel="last"') is None
     assert gh._next_page("") is None
+
+
+def test_next_page_tolerates_commas_inside_urls():
+    link = '<https://a/b?q=x,y&page=2>; rel="next", <https://a/b?q=x,y&page=9>; rel="last"'
+    assert gh._next_page(link) == "https://a/b?q=x,y&page=2"
+    assert gh._next_page('<https://a/b?page=1>; rel="prev", <https://a/b?page=3>; rel="next"') == "https://a/b?page=3"

{codna-0.2.42 → codna-0.2.44}/tests/test_webhook_worker.py

@@ -1729,3 +1729,31 @@ def test_a_fix_that_is_not_a_check_suite_failure_is_never_triaged(monkeypatch):
     process_job(_qjob(kind="fix"), app_id="a", private_key="p", github=gh,
                 runner=lambda job, **kw: JobResult(True, "done"), resolve_engine_key=lambda iid: "k")
     assert called == []
+
+
+# --- a structured CLI error keeps its diagnosis in the Check Run --------------------------------
+def test_error_summary_shows_the_review_agents_actual_output_when_it_was_not_json():
+    """'did not return parseable findings JSON' three times in 35 s on a sandbox PR, and nothing to
+    read: the CLI attached raw_head/raw_tail, the worker rendered only the sentence."""
+    from codna.webhook_summaries import _error_json_summary, _terse_cli_failure
+    err = {"error": {"code": "review_error",
+                     "message": "review agent failed: review agent did not return parseable findings JSON",
+                     "details": {"raw_chars": 812,
+                                 "raw_head": "I reviewed the workflow change. This PR intentionally breaks CI, so ```no findings```",
+                                 "raw_tail": "",
+                                 "looked_for": ["the whole message as JSON", "a ```json fence"]}}}
+    summary = _error_json_summary("review", None, json.dumps(err, indent=2))
+    assert summary.startswith("codna review failed (review_error): review agent failed")
+    assert "raw_head: I reviewed the workflow change." in summary
+    assert "raw_chars: 812" in summary
+    assert "looked_for" not in summary and "raw_tail" not in summary     # only informative keys
+    assert summary.count("```") == 2                                    # the agent's own fence is defanged
+    # the in-thread reply stays one clause: the block is for the Check Run
+    assert "raw_head" not in _terse_cli_failure(summary)
+    assert _terse_cli_failure(summary).endswith("[review_error]")
+
+
+def test_error_summary_without_details_is_unchanged():
+    from codna.webhook_summaries import _error_json_summary
+    err = {"error": {"code": "cli_error", "message": "no test runner detected", "details": {}}}
+    assert _error_json_summary("fix", json.dumps(err)) == "codna fix failed (cli_error): no test runner detected"