codna 0.2.27__tar.gz → 0.2.28__tar.gz

{codna-0.2.27 → codna-0.2.28}/PKG-INFO

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

{codna-0.2.27 → codna-0.2.28}/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.27"
+__version__ = "0.2.28"

{codna-0.2.27 → codna-0.2.28}/codna/review.py

@@ -9,6 +9,7 @@ triage (suspect files/symbols + context reduction).
 from __future__ import annotations
 
 import os
+import shutil
 import subprocess
 
 
@@ -166,6 +167,7 @@ def run_findings_review(args) -> dict:
     token = (getattr(args, "github_token", None) or os.environ.get("CODNA_GITHUB_TOKEN")
              or os.environ.get("GITHUB_TOKEN"))
     pr = getattr(args, "pr", None)
+    materialized: str | None = None  # the clone this call made and must remove
 
     if _is_git_url(str(args.repo)):
         # Remote review (webhook / CI): needs a PR to materialize the diff. The repo slug ALWAYS comes
@@ -198,6 +200,7 @@ def run_findings_review(args) -> dict:
                 str(args.repo), pr_number, meta["base_ref"], token, incremental_base=incremental_base)
         except Exception as exc:  # noqa: BLE001
             _fail(f"could not materialize PR #{pr_number}: {exc}")
+        materialized = local
         base = None
     else:
         local = os.path.abspath(os.path.expanduser(args.repo))
@@ -209,36 +212,43 @@ def run_findings_review(args) -> dict:
                 _fail(f"--pr {pr!r}: could not resolve owner/repo#number (pass owner/repo#123 or a PR URL).")
 
     try:
-        cfg = _config_overrides(args, rf.load_review_config(local))
-    except Exception as exc:  # noqa: BLE001 — malformed config fails closed with a clear message
-        _fail(f"review config error: {exc}")
+        try:
+            cfg = _config_overrides(args, rf.load_review_config(local))
+        except Exception as exc:  # noqa: BLE001 — malformed config fails closed with a clear message
+            _fail(f"review config error: {exc}")
 
-    guidance = read_project_guidance(local)
-    try:
-        result = rf.run_diff_review(
-            local, repository=args.repo, diff_range=diff_range, base=base, config=cfg,
-            guidance=guidance, prior_feedback=prior_feedback, head_sha=head_sha,
-            model=getattr(args, "model", None) or None,
-        )
-    except Exception as exc:  # noqa: BLE001 - agent/runtime failures must not leak tracebacks.
-        # 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):
-        token = (getattr(args, "github_token", None) or os.environ.get("CODNA_GITHUB_TOKEN")
-                 or os.environ.get("GITHUB_TOKEN"))
-        if not (repo_slug and pr_number):
-            _fail("--post needs --pr owner/repo#123 (or a PR number in a repo with a github origin).")
-        if not token:
-            _fail("--post needs a write token: pass --github-token or set GITHUB_TOKEN.")
+        guidance = read_project_guidance(local)
         try:
-            out["posted"] = rg.post_review(result, repo_slug=repo_slug, pr_number=pr_number, token=token)
-        except Exception as exc:  # noqa: BLE001
-            _fail(f"posting the review failed: {exc}")
-    return out
+            result = rf.run_diff_review(
+                local, repository=args.repo, diff_range=diff_range, base=base, config=cfg,
+                guidance=guidance, prior_feedback=prior_feedback, head_sha=head_sha,
+                model=getattr(args, "model", None) or None,
+            )
+        except Exception as exc:  # noqa: BLE001 - agent/runtime failures must not leak tracebacks.
+            # 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):
+            token = (getattr(args, "github_token", None) or os.environ.get("CODNA_GITHUB_TOKEN")
+                     or os.environ.get("GITHUB_TOKEN"))
+            if not (repo_slug and pr_number):
+                _fail("--post needs --pr owner/repo#123 (or a PR number in a repo with a github origin).")
+            if not token:
+                _fail("--post needs a write token: pass --github-token or set GITHUB_TOKEN.")
+            try:
+                out["posted"] = rg.post_review(result, repo_slug=repo_slug, pr_number=pr_number, token=token)
+            except Exception as exc:  # noqa: BLE001
+                _fail(f"posting the review failed: {exc}")
+        return out
+    finally:
+        if materialized is not None:
+            # The clone lives in the process's temp dir, NOT in a per-call scratch dir. Without
+            # this, every remote review left a full checkout behind on the webhook machine until
+            # its root filesystem filled and reviews died with ENOSPC (thyn-ai/algenta#1023).
+            shutil.rmtree(materialized, ignore_errors=True)
 
 
 def dispatch(args, make_client) -> int:

{codna-0.2.27 → codna-0.2.28}/codna/webhook_worker.py

@@ -302,6 +302,11 @@ def _job_env(
         # two keys -- inheriting the host's shared values here would silently defeat the whole
         # point (every job would still resolve to the one shared runtime this exists to avoid).
         env.update(_isolated_runtime_env(tmp))
+        # Every scratch dir the job's tools create (the review clone, secure-pr checkouts, junit
+        # files, agent-core temp) lands INSIDE the job dir and is deleted with it. The review
+        # clone used to land in the machine's shared /tmp and was never removed -- a ~0.5 GB
+        # leak per algenta review that filled the root fs (ENOSPC, thyn-ai/algenta#1023).
+        env["TMPDIR"] = env["TMP"] = env["TEMP"] = tmp
     if token:
         env["GITHUB_TOKEN"] = token
     if engine_key:

{codna-0.2.27 → codna-0.2.28}/codna.egg-info/PKG-INFO

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

{codna-0.2.27 → codna-0.2.28}/pyproject.toml

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

{codna-0.2.27 → codna-0.2.28}/tests/test_review_findings.py

@@ -2,6 +2,8 @@
 from __future__ import annotations
 
 import os
+
+import pytest
 import subprocess
 from types import SimpleNamespace
 
@@ -289,6 +291,77 @@ def test_run_findings_review_url_materializes_pr(monkeypatch, tmp_path):
     assert out["conclusion"] == "success"
 
 
+def _remote_review_args():
+    return SimpleNamespace(repo="https://github.com/o/r.git", pr="o/r#5", diff=None, base=None,
+                           post=False, model=None, github_token="t", min_confidence=None,
+                           max_findings=None, blocking=False)
+
+
+def _stub_remote_pr(monkeypatch, clone_dir):
+    from codna import review
+
+    monkeypatch.setattr(rg, "fetch_pr",
+                        lambda slug, n, tok: {"base_ref": "main", "head_sha": "h",
+                                              "head_ref": "f", "is_fork": False})
+    monkeypatch.setattr(rg, "fetch_review_context",
+                        lambda *a, **k: {"last_reviewed_head": None, "prior_feedback": None})
+
+    def fake_materialize(url, n, base, tok, incremental_base=None):
+        clone_dir.mkdir()
+        (clone_dir / "a.py").write_text("x = 1\n", encoding="utf-8")
+        return str(clone_dir), "origin/main...codna-pr-head", "headsha"
+
+    monkeypatch.setattr(review, "_materialize_pr", fake_materialize)
+    return review
+
+
+def test_run_findings_review_url_removes_the_materialized_clone(monkeypatch, tmp_path):
+    """REGRESSION: the clone `_materialize_pr` makes lives in the process temp dir; the remote
+    review path must remove it once the review is done. It never did -- every webhook review
+    left a full checkout behind until the machine's root fs filled (ENOSPC, algenta#1023)."""
+    clone = tmp_path / "codna-review-abc"
+    review = _stub_remote_pr(monkeypatch, clone)
+    monkeypatch.setattr(rf, "run_diff_review",
+                        lambda local, **kw: rf.ReviewResult(repository="u", base="b", head_sha="h",
+                                                            changed_files=["a.py"], inline_findings=[],
+                                                            summary_findings=[], conclusion="success",
+                                                            dropped={}))
+    out = review.run_findings_review(_remote_review_args())
+    assert out["conclusion"] == "success"
+    assert not clone.exists()
+
+
+def test_run_findings_review_url_removes_the_clone_when_the_agent_fails(monkeypatch, tmp_path):
+    """The failure path leaks just the same unless the cleanup is in a finally."""
+    clone = tmp_path / "codna-review-def"
+    review = _stub_remote_pr(monkeypatch, clone)
+
+    def boom(local, **kw):
+        assert clone.exists()  # the clone is still there WHILE the agent runs
+        raise RuntimeError("agent died")
+
+    monkeypatch.setattr(rf, "run_diff_review", boom)
+    with pytest.raises(review.ReviewError, match="review agent failed"):
+        review.run_findings_review(_remote_review_args())
+    assert not clone.exists()
+
+
+def test_run_findings_review_local_path_is_never_removed(monkeypatch, tmp_path):
+    """Only what THIS call cloned is removed -- a user's local checkout is not ours to delete."""
+    from codna import review
+
+    (tmp_path / "a.py").write_text("x = 1\n", encoding="utf-8")
+    monkeypatch.setattr(rf, "run_diff_review",
+                        lambda local, **kw: rf.ReviewResult(repository="u", base="b", head_sha="h",
+                                                            changed_files=["a.py"], inline_findings=[],
+                                                            summary_findings=[], conclusion="success",
+                                                            dropped={}))
+    args = SimpleNamespace(repo=str(tmp_path), pr=None, diff=None, base=None, post=False, model=None,
+                           github_token=None, min_confidence=None, max_findings=None, blocking=False)
+    review.run_findings_review(args)
+    assert tmp_path.exists() and (tmp_path / "a.py").exists()
+
+
 def test_run_diff_review_end_to_end_real_git(tmp_path, monkeypatch):
     """Full pipeline against a REAL git working-tree diff (only the agent is stubbed)."""
     def git(*a):

{codna-0.2.27 → codna-0.2.28}/tests/test_webhook_worker.py

@@ -105,6 +105,23 @@ def test_job_env_with_tmp_overrides_the_hosts_own_shared_runtime_root(monkeypatc
     assert env["CODNA_RUNTIME_ROOT"].startswith(str(tmp_path))
 
 
+def test_job_env_with_tmp_points_the_jobs_temp_dir_into_its_own_scratch_dir(monkeypatch, tmp_path):
+    """REGRESSION: scratch dirs the job's own tools create with tempfile (the remote-review clone,
+    secure-pr checkouts, junit files) followed the HOST's TMPDIR into the machine's shared /tmp and
+    outlived the job. With TMPDIR/TMP/TEMP inside the job dir they die with it."""
+    monkeypatch.setenv("TMPDIR", "/host/shared/tmp")
+    env = worker_module._job_env("tok", "ekey", tmp=str(tmp_path))
+    assert env["TMPDIR"] == env["TMP"] == env["TEMP"] == str(tmp_path)
+
+
+def test_job_env_without_tmp_leaves_the_hosts_temp_dir_alone(monkeypatch):
+    monkeypatch.setenv("TMPDIR", "/host/shared/tmp")
+    monkeypatch.delenv("TMP", raising=False)
+    env = worker_module._job_env("tok", "ekey")
+    assert env["TMPDIR"] == "/host/shared/tmp"
+    assert "TMP" not in env
+
+
 def test_job_env_with_tmp_gives_two_concurrent_jobs_different_runtime_roots_and_ports(tmp_path):
     a = worker_module._job_env("tok-a", "ekey-a", tmp=str(tmp_path / "job-a"))
     b = worker_module._job_env("tok-b", "ekey-b", tmp=str(tmp_path / "job-b"))