codna 0.1.44__tar.gz → 0.1.45__tar.gz

{codna-0.1.44 → codna-0.1.45}/PKG-INFO

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

{codna-0.1.44 → codna-0.1.45}/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.44"
+__version__ = "0.1.45"

{codna-0.1.44 → codna-0.1.45}/codna/fix_run.py

@@ -290,7 +290,7 @@ def _retry_issue_text(original_issue: str | None, verify_issue: str | None, stil
     return "\n\n".join(sections)
 
 
-def _apply_once(c, rid, snap, plan, *, open_pr, args, issue, summary):
+def _apply_once(c, rid, snap, plan, *, open_pr, args, issue, summary, repo):
     from . import cli as _cli
 
     sim = _cli._dump(c.simulate_repository(rid, {"snapshot_id": snap["snapshot_id"],
@@ -308,13 +308,191 @@ def _apply_once(c, rid, snap, plan, *, open_pr, args, issue, summary):
                                                                        "impacted_symbols": summary.get("impacted_symbols")}, plan),
         }))
         return {"mode": "remote_pr", "pull_request_url": res.get("pull_request_url"), "status": res.get("status")}
-    res = _cli._dump(c.apply_repository(rid, {
-        "mode": "local_branch", "write_permission": True,
-        "decision_plan_id": plan.get("decision_plan_id"), "simulation_id": sid}))
+    try:
+        res = _cli._dump(c.apply_repository(rid, {
+            "mode": "local_branch", "write_permission": True,
+            "decision_plan_id": plan.get("decision_plan_id"), "simulation_id": sid}))
+    except Exception as exc:  # noqa: BLE001
+        recovered = _recover_already_applied_local_branch(repo, plan, exc)
+        if recovered is None:
+            raise
+        return recovered
     return {"mode": "local_branch", "branch_name": res.get("branch_name"),
             "local_checkout_path": res.get("local_checkout_path"), "commit_sha": res.get("commit_sha")}
 
 
+def _recover_already_applied_local_branch(repo: str, plan: dict, exc: BaseException) -> dict | None:
+    """Commit an already-applied agent edit only when it exactly matches plan evidence.
+
+    Some local SDK apply paths call the agent first, then apply the generated diff with
+    git. If the agent already changed the worktree, the second git apply can reject the
+    patch even though the checkout is correct. Recovery is intentionally narrow: the
+    failure must be a git-apply rejection, the dirty tracked paths must exactly match the
+    plan's changed files, and generated patch artifacts are the only ignored untracked files.
+    """
+    if not _is_git_apply_rejection(exc):
+        return None
+    repo_path = os.path.abspath(os.path.expanduser(repo))
+    if not os.path.isdir(repo_path):
+        return None
+    plan_id = plan.get("decision_plan_id")
+    if not isinstance(plan_id, str) or not plan_id:
+        return None
+    patch_path = _generated_apply_patch_path(repo_path)
+    expected = _plan_changed_files(plan)
+    if not expected and patch_path is not None:
+        expected = _patch_changed_files(patch_path.read_text(encoding="utf-8", errors="surrogateescape"))
+    if not expected:
+        return None
+    state = _worktree_recovery_state(repo_path)
+    if state is None:
+        return None
+    tracked_dirty, untracked = state
+    ignored_untracked = {name for name in _GENERATED_APPLY_ARTIFACTS}
+    unexpected_untracked = [path for path in untracked if path not in ignored_untracked]
+    if unexpected_untracked:
+        return None
+    branch = "codna/" + plan_id.removeprefix("plan_")[:16]
+    _git_checked(repo_path, ["checkout", "-B", branch])
+    if tracked_dirty:
+        if sorted(tracked_dirty) != sorted(expected):
+            return None
+    elif patch_path is not None:
+        if not _git_apply_check(repo_path, patch_path):
+            return None
+        _git_checked(repo_path, ["apply", "--whitespace=nowarn", str(patch_path)])
+    else:
+        return None
+    _git_checked(repo_path, ["add", "--", *expected])
+    staged = _git_checked(repo_path, ["diff", "--cached", "--name-only", "-z"]).stdout
+    staged_files = sorted(path for path in staged.split("\0") if path)
+    if staged_files != sorted(expected):
+        return None
+    _git_checked(
+        repo_path,
+        [
+            "-c",
+            "user.name=Codna",
+            "-c",
+            "user.email=codna@example.invalid",
+            "commit",
+            "--no-gpg-sign",
+            "-m",
+            f"codna: apply {plan_id}",
+        ],
+    )
+    for artifact in _GENERATED_APPLY_ARTIFACTS:
+        Path(repo_path, artifact).unlink(missing_ok=True)
+    return {
+        "mode": "local_branch",
+        "branch_name": branch,
+        "local_checkout_path": repo_path,
+        "commit_sha": _git_checked(repo_path, ["rev-parse", "HEAD"]).stdout.strip(),
+        "recovered_after_apply_error": True,
+    }
+
+
+def _is_git_apply_rejection(exc: BaseException) -> bool:
+    text = str(exc).lower()
+    return (
+        "git apply" in text
+        or "patch does not apply" in text
+        or "git_command_failed" in text
+    ) and (
+        ".algenta.patch.diff" in text
+        or ".codna-packaged.patch.diff" in text
+        or "patch does not apply" in text
+    )
+
+
+def _plan_changed_files(plan: dict) -> list[str]:
+    candidates = [
+        plan.get("changed_files"),
+        (plan.get("decision_plan") or {}).get("changed_files"),
+        ((plan.get("decision_plan") or {}).get("repository_analysis") or {}).get("changed_files"),
+    ]
+    for value in candidates:
+        if isinstance(value, list) and value and all(isinstance(item, str) and item for item in value):
+            return sorted(set(value))
+    return []
+
+
+def _generated_apply_patch_path(repo: str) -> Path | None:
+    for artifact in _GENERATED_APPLY_ARTIFACTS:
+        path = Path(repo, artifact)
+        if path.is_file():
+            return path
+    return None
+
+
+def _patch_changed_files(patch_diff: str) -> list[str]:
+    changed: set[str] = set()
+    for line in patch_diff.splitlines():
+        if not line.startswith("+++ "):
+            continue
+        path = line[4:].strip()
+        if path == "/dev/null":
+            continue
+        if path.startswith("b/"):
+            path = path[2:]
+        if path:
+            changed.add(path)
+    return sorted(changed)
+
+
+def _git_apply_check(repo: str, patch_path: Path) -> bool:
+    result = subprocess.run(
+        ["git", "-C", repo, "apply", "--check", "--whitespace=nowarn", str(patch_path)],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=60,
+    )
+    return result.returncode == 0
+
+
+def _worktree_recovery_state(repo: str) -> tuple[list[str], list[str]] | None:
+    status = subprocess.run(
+        ["git", "-C", repo, "status", "--porcelain=v1", "-z", "--untracked-files=all"],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=30,
+    )
+    if status.returncode != 0:
+        return None
+    tracked: list[str] = []
+    untracked: list[str] = []
+    entries = [entry for entry in status.stdout.split("\0") if entry]
+    i = 0
+    while i < len(entries):
+        entry = entries[i]
+        code = entry[:2]
+        path = entry[3:] if len(entry) > 3 else ""
+        if code == "??":
+            untracked.append(path)
+        elif code[:1] in {"R", "C"} or code[1:2] in {"R", "C"}:
+            return None
+        elif path:
+            tracked.append(path)
+        i += 1
+    return sorted(set(tracked)), sorted(set(untracked))
+
+
+def _git_checked(repo: str, args: list[str]) -> subprocess.CompletedProcess:
+    result = subprocess.run(
+        ["git", "-C", repo, *args],
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=60,
+    )
+    if result.returncode != 0:
+        detail = (result.stderr or result.stdout or "").strip()
+        raise RuntimeError(f"git {' '.join(args)} failed during apply recovery: {detail}")
+    return result
+
+
 def run_fix(c, args) -> dict:
     """Run the fix (with optional verification loop) and return a structured result dict.
 
@@ -370,7 +548,7 @@ def run_fix(c, args) -> dict:
         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)
+            applied = _apply_once(c, rid, snap, plan, open_pr=open_pr, args=args, issue=issue, summary=summary, repo=repo)
             if applied.get("mode") == "local_branch":
                 _cleanup_generated_apply_artifacts(applied.get("local_checkout_path"), apply_artifacts_before)
         except Exception as exc:  # noqa: BLE001 — mirror the old cmd_fix: ALL apply errors (incl. a

{codna-0.1.44 → codna-0.1.45}/codna.egg-info/PKG-INFO

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

{codna-0.1.44 → codna-0.1.45}/memengine/lexical.py

@@ -136,7 +136,8 @@ class _BM25:
         df: dict = defaultdict(int)
         for i, d in enumerate(docs):
             for term, f in Counter(d).items():
-                self.post[term].append((i, f)); df[term] += 1
+                self.post[term].append((i, f))
+                df[term] += 1
         self.idf = {t: math.log(1 + (self.N - n + 0.5) / (n + 0.5)) for t, n in df.items()}
 
     def scores(self, qtoks) -> dict:
@@ -190,7 +191,8 @@ class LexicalCodeIndex:
             plist = bm.post[term]
             self._term_range[term] = (cur, len(plist))
             for d, f in plist:
-                post_docs.append(d); post_tfs.append(f)
+                post_docs.append(d)
+                post_tfs.append(f)
             cur += len(plist)
         self._post_docs = np.asarray(post_docs, np.int32)
         self._post_tfs = np.asarray(post_tfs, np.int32)
@@ -219,7 +221,9 @@ class LexicalCodeIndex:
             if rng is None:
                 continue
             st, cnt = rng
-            starts.append(st); ends.append(st + cnt); idfs.append(self._bm.idf[h])
+            starts.append(st)
+            ends.append(st + cnt)
+            idfs.append(self._bm.idf[h])
         if not starts:
             return []
         qs = np.asarray(starts, np.int32)

{codna-0.1.44 → codna-0.1.45}/pyproject.toml

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

{codna-0.1.44 → codna-0.1.45}/tests/test_fix_run.py

@@ -468,6 +468,114 @@ def test_cleanup_generated_apply_artifacts_removes_new_untracked_patch_file(tmp_
     assert not (repo / ".algenta.patch.diff").exists()
 
 
+def test_apply_once_recovers_when_agent_edit_already_matches_plan(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 / "src" / "lib.rs"
+    target.parent.mkdir()
+    target.write_text("fn main() {\n    broken()\n}\n", encoding="utf-8")
+    subprocess.run(["git", "add", "src/lib.rs"], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "base"], cwd=repo, check=True)
+    target.write_text("fn main() {\n    fixed()\n}\n", encoding="utf-8")
+
+    class AlreadyAppliedClient:
+        def simulate_repository(self, *_a, **_k):
+            return {"validated_inputs": {"simulation_id": "sim-1"}}
+
+        def apply_repository(self, *_a, **_k):
+            raise RuntimeError(
+                "git apply --index .algenta.patch.diff failed: patch does not apply"
+            )
+
+    plan = {
+        "decision_plan_id": "plan_1234567890abcdef",
+        "changed_files": ["src/lib.rs"],
+        "decision_plan": {"repository_analysis": {"generated_patch_ref": "patch-1"}},
+    }
+
+    result = fix_run._apply_once(
+        AlreadyAppliedClient(),
+        "rid",
+        {"snapshot_id": "snap-1"},
+        plan,
+        open_pr=False,
+        args=_Args(repo=str(repo)),
+        issue="fix rust parse error",
+        summary=fix_run.summarize_plan(plan),
+        repo=str(repo),
+    )
+
+    assert result["recovered_after_apply_error"] is True
+    assert result["branch_name"] == "codna/1234567890abcdef"
+    assert subprocess.check_output(["git", "status", "--porcelain"], cwd=repo, text=True) == ""
+    assert subprocess.check_output(["git", "show", "--format=", "--name-only", "HEAD"], cwd=repo, text=True).strip() == "src/lib.rs"
+
+
+def test_apply_recovery_rejects_unplanned_dirty_files(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 / "src" / "lib.rs"
+    extra = repo / "src" / "extra.rs"
+    target.parent.mkdir()
+    target.write_text("a\n", encoding="utf-8")
+    extra.write_text("x\n", encoding="utf-8")
+    subprocess.run(["git", "add", "src/lib.rs", "src/extra.rs"], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "base"], cwd=repo, check=True)
+    target.write_text("b\n", encoding="utf-8")
+    extra.write_text("y\n", encoding="utf-8")
+
+    recovered = fix_run._recover_already_applied_local_branch(
+        str(repo),
+        {"decision_plan_id": "plan_abcdef", "changed_files": ["src/lib.rs"]},
+        RuntimeError("git apply .algenta.patch.diff failed: patch does not apply"),
+    )
+
+    assert recovered is None
+    assert subprocess.check_output(["git", "status", "--porcelain"], cwd=repo, text=True).splitlines() == [
+        " M src/extra.rs",
+        " M src/lib.rs",
+    ]
+
+
+def test_apply_recovery_applies_generated_patch_when_index_apply_rejected(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 / "src" / "lib.rs"
+    target.parent.mkdir()
+    target.write_text("bad();\nok();\n", encoding="utf-8")
+    subprocess.run(["git", "add", "src/lib.rs"], cwd=repo, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "base"], cwd=repo, check=True)
+    (repo / ".algenta.patch.diff").write_text(
+        "--- a/src/lib.rs\n"
+        "+++ b/src/lib.rs\n"
+        "@@ -1,2 +1 @@\n"
+        "-bad();\n"
+        " ok();\n",
+        encoding="utf-8",
+    )
+
+    recovered = fix_run._recover_already_applied_local_branch(
+        str(repo),
+        {"decision_plan_id": "plan_abcdef1234567890"},
+        RuntimeError("git apply --index .algenta.patch.diff failed: patch does not apply"),
+    )
+
+    assert recovered is not None
+    assert recovered["recovered_after_apply_error"] is True
+    assert target.read_text(encoding="utf-8") == "ok();\n"
+    assert not (repo / ".algenta.patch.diff").exists()
+    assert subprocess.check_output(["git", "status", "--porcelain"], cwd=repo, text=True) == ""
+
+
 def test_rollback_failed_local_apply_resets_only_expected_codna_commit(tmp_path):
     repo = tmp_path / "repo"
     repo.mkdir()