codna 0.1.39__tar.gz → 0.1.41__tar.gz

{codna-0.1.39 → codna-0.1.41}/PKG-INFO

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

{codna-0.1.39 → codna-0.1.41}/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.1.39"
+__version__ = "0.1.41"

{codna-0.1.39 → codna-0.1.41}/codna/fix_run.py

@@ -223,6 +223,49 @@ def _cleanup_generated_apply_artifacts(checkout: str | None, before: dict[str, b
             path.unlink()
 
 
+def _git_head(repo: str | None) -> str | None:
+    if not repo:
+        return None
+    result = subprocess.run(
+        ["git", "-C", os.path.abspath(os.path.expanduser(repo)), "rev-parse", "--verify", "HEAD"],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=10,
+    )
+    if result.returncode != 0:
+        return None
+    head = result.stdout.strip()
+    return head or None
+
+
+def _rollback_failed_local_apply(applied: dict, before_head: str | None) -> dict:
+    checkout = applied.get("local_checkout_path")
+    applied_commit = applied.get("commit_sha")
+    if not checkout or not before_head or not applied_commit:
+        raise RuntimeError("cannot rollback failed attempt: missing checkout, base commit, or applied commit")
+
+    repo = os.path.abspath(os.path.expanduser(str(checkout)))
+    current_head = _git_head(repo)
+    if current_head != applied_commit:
+        raise RuntimeError(
+            "cannot rollback failed attempt: current HEAD does not match Codna-applied commit "
+            f"(current={current_head or 'unknown'}, applied={applied_commit})"
+        )
+
+    reset = subprocess.run(
+        ["git", "-C", repo, "reset", "--hard", "--quiet", before_head],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=30,
+    )
+    if reset.returncode != 0:
+        detail = (reset.stderr or reset.stdout or "").strip()
+        raise RuntimeError(f"cannot rollback failed attempt: git reset failed ({detail})")
+    return {"mode": "local_branch", "local_checkout_path": repo, "reset_to": before_head}
+
+
 def _verify_applied_checkout(applied: dict, test_cmd: str | None):
     from .testrun import discover_failing_tests
 
@@ -230,6 +273,23 @@ def _verify_applied_checkout(applied: dict, test_cmd: str | None):
     return discover_failing_tests(checkout, test_cmd)
 
 
+def _retry_issue_text(original_issue: str | None, verify_issue: str | None, still_failing: list[str]) -> str:
+    """Build the next attempt's issue text from the user request plus live verification output."""
+    sections: list[str] = []
+    if original_issue and original_issue.strip():
+        sections.append("Original issue:\n" + original_issue.strip())
+    if verify_issue and verify_issue.strip():
+        sections.append("Verification after the previous fix is still failing:\n" + verify_issue.strip())
+    elif still_failing:
+        sections.append(
+            "Verification after the previous fix still reports failing tests:\n"
+            + "\n".join(f"- {test_id}" for test_id in still_failing[:12])
+        )
+    else:
+        sections.append("Verification after the previous fix is still failing.")
+    return "\n\n".join(sections)
+
+
 def _apply_once(c, rid, snap, plan, *, open_pr, args, issue, summary):
     from . import cli as _cli
 
@@ -284,6 +344,7 @@ def run_fix(c, args) -> dict:
 
     t0 = time.perf_counter()
     repo = args.repo
+    original_issue = issue
     result: dict = {"repository": repo, "issue": issue, "iterations": [], "applied": None,
                     "verified": None, "remaining_failing_tests": None, "pull_request_url": None}
 
@@ -306,6 +367,7 @@ def run_fix(c, args) -> dict:
             result["elapsed_s"] = round(time.perf_counter() - t0, 1)
             return attach_usage_totals(result)
 
+        pre_apply_head = _git_head(repo) if apply and not open_pr else None
         apply_artifacts_before = _snapshot_generated_apply_artifacts(repo) if apply and not open_pr else {}
         try:
             applied = _apply_once(c, rid, snap, plan, open_pr=open_pr, args=args, issue=issue, summary=summary)
@@ -355,8 +417,15 @@ def run_fix(c, args) -> dict:
         # Still red — re-fix ON the applied branch with the new failures, if iterations remain.
         result["verified"] = False
         result["remaining_failing_tests"] = still_failing
+        if i + 1 >= max_iterations:
+            break
+        if applied.get("mode") == "local_branch":
+            try:
+                iteration["rollback"] = _rollback_failed_local_apply(applied, pre_apply_head)
+            except Exception as exc:  # noqa: BLE001
+                raise _cli.CodnaError(f"retry rollback failed: {format_cli_error(exc)}") from exc
         failing = still_failing
-        issue = args.issue or verify_issue or f"{len(still_failing)} test(s) still failing after the previous fix"
+        issue = _retry_issue_text(args.issue or original_issue, verify_issue, still_failing)
         repo = checkout
 
     result["elapsed_s"] = round(time.perf_counter() - t0, 1)

{codna-0.1.39 → codna-0.1.41}/codna.egg-info/PKG-INFO

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

{codna-0.1.39 → codna-0.1.41}/pyproject.toml

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

{codna-0.1.39 → codna-0.1.41}/tests/test_fix_run.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import os
+import subprocess
 
 
 from codna import cli, fix_run
@@ -265,6 +266,7 @@ def test_test_cmd_with_apply_verifies_without_tests_flag(monkeypatch):
 def test_verify_refixes_until_green(monkeypatch):
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan()))
     monkeypatch.setattr(fix_run, "_apply_once", _apply)
+    monkeypatch.setattr(fix_run, "_rollback_failed_local_apply", lambda applied, before_head: {"local_checkout_path": "/co"})
     monkeypatch.setattr("os.path.isdir", lambda p: True)
     # resolve → fail; verify#1 → still failing (re-fix); verify#2 → green
     seq = iter([_FAIL, _FAIL, _GREEN])
@@ -274,6 +276,48 @@ def test_verify_refixes_until_green(monkeypatch):
     assert len(result["iterations"]) == 2  # took a re-fix
 
 
+def test_retry_preserves_verification_output_with_explicit_issue(monkeypatch):
+    """Regression: an explicit --issue must not hide traceback evidence on retry."""
+    captured: list[dict] = []
+
+    def fake_plan_once(_client, **kwargs):
+        captured.append(dict(kwargs))
+        return "rid", {"snapshot_id": "s"}, _plan(root=f"attempt-{len(captured)}")
+
+    verify = iter([
+        (
+            "tests are failing (no per-test JUnit ids were produced):\n"
+            "src/itsdangerous/encoding.py:34: binascii.Error: Incorrect padding",
+            [],
+        ),
+        _GREEN,
+    ])
+    monkeypatch.setattr(fix_run, "resolve_issue", lambda args, github_token=None: (args.issue, []))
+    monkeypatch.setattr(fix_run, "_plan_once", fake_plan_once)
+    monkeypatch.setattr(fix_run, "_apply_once", _apply)
+    monkeypatch.setattr(fix_run, "_rollback_failed_local_apply", lambda applied, before_head: {"local_checkout_path": "/co"})
+    monkeypatch.setattr(fix_run, "_verify_applied_checkout", lambda applied, test_cmd=None: next(verify))
+    monkeypatch.setattr("os.path.isdir", lambda p: True)
+
+    result = fix_run.run_fix(
+        object(),
+        _Args(
+            apply=True,
+            tests=True,
+            issue="base64_decode fails for stripped URL-safe padding",
+            max_iterations=2,
+        ),
+    )
+
+    assert result["verified"] is True
+    assert len(captured) == 2
+    retry_issue = captured[1]["issue"]
+    assert "Original issue:" in retry_issue
+    assert "base64_decode fails for stripped URL-safe padding" in retry_issue
+    assert "Verification after the previous fix is still failing:" in retry_issue
+    assert "src/itsdangerous/encoding.py:34" in retry_issue
+
+
 def test_usage_totals_sum_multiple_fix_iterations(monkeypatch):
     plans = iter([
         _plan(usage={"input_tokens": 100, "output_tokens": 10, "cache_read_tokens": 5, "cost_usd": 0.01}, model="m1"),
@@ -281,6 +325,7 @@ def test_usage_totals_sum_multiple_fix_iterations(monkeypatch):
     ])
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, next(plans)))
     monkeypatch.setattr(fix_run, "_apply_once", _apply)
+    monkeypatch.setattr(fix_run, "_rollback_failed_local_apply", lambda applied, before_head: {"local_checkout_path": "/co"})
     monkeypatch.setattr("os.path.isdir", lambda p: True)
     seq = iter([_FAIL, _FAIL, _GREEN])
     monkeypatch.setattr("codna.testrun.discover_failing_tests", lambda repo, cmd=None: next(seq))
@@ -307,6 +352,7 @@ def test_usage_totals_sum_multiple_fix_iterations(monkeypatch):
 def test_verify_gives_up_after_max_iterations(monkeypatch):
     monkeypatch.setattr(fix_run, "_plan_once", lambda c, **k: ("rid", {"snapshot_id": "s"}, _plan()))
     monkeypatch.setattr(fix_run, "_apply_once", _apply)
+    monkeypatch.setattr(fix_run, "_rollback_failed_local_apply", lambda applied, before_head: {"local_checkout_path": "/co"})
     monkeypatch.setattr("os.path.isdir", lambda p: True)
     monkeypatch.setattr("codna.testrun.discover_failing_tests", lambda repo, cmd=None: _FAIL)  # never green
     result = fix_run.run_fix(object(), _Args(apply=True, tests=True, max_iterations=2))
@@ -420,3 +466,54 @@ def test_cleanup_generated_apply_artifacts_removes_new_untracked_patch_file(tmp_
     fix_run._cleanup_generated_apply_artifacts(str(repo), before)
 
     assert not (repo / ".algenta.patch.diff").exists()
+
+
+def test_rollback_failed_local_apply_resets_only_expected_codna_commit(tmp_path):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.email", "codna-test@example.local"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.name", "Codna Test"], cwd=repo, check=True)
+    target = repo / "app.py"
+    target.write_text("value = 1\n", encoding="utf-8")
+    subprocess.run(["git", "add", "app.py"], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "base"], cwd=repo, check=True)
+    before = fix_run._git_head(str(repo))
+
+    target.write_text("value = 2\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "codna bad attempt", "-q"], cwd=repo, check=True)
+    applied_commit = fix_run._git_head(str(repo))
+
+    rollback = fix_run._rollback_failed_local_apply(
+        {"mode": "local_branch", "local_checkout_path": str(repo), "commit_sha": applied_commit},
+        before,
+    )
+
+    assert rollback["reset_to"] == before
+    assert fix_run._git_head(str(repo)) == before
+    assert target.read_text(encoding="utf-8") == "value = 1\n"
+
+
+def test_rollback_failed_local_apply_rejects_unknown_head(tmp_path):
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    subprocess.run(["git", "init", "-q"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.email", "codna-test@example.local"], cwd=repo, check=True)
+    subprocess.run(["git", "config", "user.name", "Codna Test"], cwd=repo, check=True)
+    target = repo / "app.py"
+    target.write_text("value = 1\n", encoding="utf-8")
+    subprocess.run(["git", "add", "app.py"], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "base"], cwd=repo, check=True)
+    before = fix_run._git_head(str(repo))
+    target.write_text("value = 2\n", encoding="utf-8")
+    subprocess.run(["git", "commit", "-am", "user commit", "-q"], cwd=repo, check=True)
+
+    try:
+        fix_run._rollback_failed_local_apply(
+            {"mode": "local_branch", "local_checkout_path": str(repo), "commit_sha": "0" * 40},
+            before,
+        )
+    except RuntimeError as exc:
+        assert "current HEAD does not match" in str(exc)
+    else:
+        raise AssertionError("rollback must reject unproven HEAD ownership")