codna 0.1.9__tar.gz → 0.1.11__tar.gz

{codna-0.1.9 → codna-0.1.11}/PKG-INFO

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

{codna-0.1.9 → codna-0.1.11}/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.9"
+__version__ = "0.1.11"

{codna-0.1.9 → codna-0.1.11}/codna/local_repository_shims.py

@@ -31,6 +31,20 @@ _LOCAL_SDK_DIRECT_SUFFIX_LANGUAGES = {
     ".xml": "xml",
     ".properties": "properties",
 }
+_GENERATED_DIFF_SKIP_DIRS = frozenset({
+    ".cache",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+    "__pycache__",
+})
+_GENERATED_DIFF_SKIP_FILES = frozenset({
+    ".coverage",
+    ".DS_Store",
+    "coverage.xml",
+})
+_GENERATED_DIFF_SKIP_SUFFIXES = (".pyc", ".pyo")
 
 
 def install_precise_patch_changed_files() -> None:
@@ -206,6 +220,8 @@ def git_apply_compatible_unified_diff_from_tree_states(
 ) -> str:
     segments: list[str] = []
     for relative in sorted(set(before) | set(after)):
+        if _is_generated_diff_artifact(relative):
+            continue
         old_text = before.get(relative)
         new_text = after.get(relative)
         if old_text == new_text:
@@ -225,6 +241,15 @@ def git_apply_compatible_unified_diff_from_tree_states(
     return "".join(segments)
 
 
+def _is_generated_diff_artifact(relative: str) -> bool:
+    path = Path(relative)
+    if any(part in _GENERATED_DIFF_SKIP_DIRS for part in path.parts):
+        return True
+    if path.name in _GENERATED_DIFF_SKIP_FILES:
+        return True
+    return path.name.endswith(_GENERATED_DIFF_SKIP_SUFFIXES)
+
+
 def precise_patch_changed_files(patch_diff: str) -> dict[str, list[tuple[int, int]]]:
     changed_lines: dict[str, set[int]] = {}
     current_file: str | None = None

{codna-0.1.9 → codna-0.1.11}/codna/mcp_server.py

@@ -8,6 +8,7 @@ the same engine client the CLI uses. Add to your MCP config:
 """
 from __future__ import annotations
 
+import asyncio
 import json
 import os
 
@@ -83,6 +84,77 @@ def secure_json(repo: str = ".", sarif_path: str = "", ref: str = "") -> str:
         return f"codna_secure error: {exc}"
 
 
+def fix_json(repo: str = ".", issue: str = "", ref: str = "", open_pr: bool = False) -> str:
+    """Return a Codna fix plan/PR result as JSON text without crashing the MCP server.
+
+    This is deliberately synchronous because it reuses the CLI/local-client path. The MCP tool
+    runs it in a worker thread so local repository-intelligence calls can safely use their own
+    event loop internally.
+    """
+    repo = _default_repo(repo)
+    try:
+        c = _client()
+        if open_pr:
+            # Same path the CLI's `codna fix --open-pr` uses (engine apply -> real PR), so the
+            # MCP tool and CLI are one behavior. run_fix() would sys.exit on bad input, which
+            # must never kill the server - so we pre-validate and also trap SystemExit.
+            import types
+
+            from . import fix_run
+
+            token = os.environ.get("GITHUB_TOKEN") or os.environ.get("CODNA_GITHUB_TOKEN")
+            if not token:
+                return "codna_fix error: open_pr=true needs a GITHUB_TOKEN with write access."
+            if os.path.isdir(os.path.abspath(os.path.expanduser(repo))):
+                return "codna_fix error: open_pr=true needs a git URL (a local path has no remote to push to)."
+            if not issue:
+                return "codna_fix error: open_pr=true needs an `issue` describing what's broken."
+            ns = types.SimpleNamespace(
+                repo=repo, ref=ref or None, issue=issue, from_junit=None,
+                tests=False, apply=False, open_pr=True, github_token=token,
+                model="repository.verified_agentic_v1", max_iterations=1,
+                pr_title=None, pr_body=None, base_branch=None, test_cmd=None, as_json=True,
+            )
+            try:
+                result = fix_run.run_fix(c, ns)
+            except SystemExit as exc:  # _die() inside run_fix - surface, don't crash the server
+                return f"codna_fix error: {exc}"
+            it = (result.get("iterations") or [{}])[-1]
+            s = it.get("summary") or {}
+            applied = result.get("applied") or {}
+            return json.dumps({
+                "root_cause": s.get("root_cause"),
+                "confidence": s.get("confidence"),
+                "pull_request_url": result.get("pull_request_url"),
+                "status": applied.get("status"),
+                "model": s.get("runtime_model"),
+            }, indent=2)
+        # plan-only (default, read-only): locate + plan the fix, change nothing.
+        rid, snap = _register(c, repo, ref or None)
+        tri = _dump(c.triage_repository(rid, {"snapshot_id": snap["snapshot_id"],
+                                              "signals": {"issue_text": issue}}))
+        plan = _dump(c.create_repository_decision_plan(rid, {
+            "snapshot_id": snap["snapshot_id"],
+            "workspace_evidence_bundle_ref": tri.get("workspace_evidence_bundle_ref"),
+            "signals": {"issue_text": issue},
+            "model": "repository.verified_agentic_v1",
+        }))
+        dp = plan.get("decision_plan") or {}
+        ra = dp.get("repository_analysis") or {}
+        usage = plan.get("planner_usage") or {}
+        return json.dumps({
+            "root_cause": ra.get("root_cause"),
+            "impacted_symbols": ra.get("impacted_symbols"),
+            "blast_radius": ra.get("blast_radius"),
+            "confidence": dp.get("confidence"),
+            "patch_ref": ra.get("generated_patch_ref"),
+            "model": plan.get("runtime_model"),
+            "cost_usd": usage.get("cost_usd"),
+        }, indent=2)
+    except Exception as exc:  # noqa: BLE001
+        return f"codna_fix error: {exc}"
+
+
 def _build_server():
     from mcp.server.fastmcp import FastMCP
     from mcp.types import ToolAnnotations
@@ -113,7 +185,7 @@ def _build_server():
             return f"codna_triage error: {exc}"
 
     @server.tool(annotations=ToolAnnotations(title="Fix a bug (plan, or open a PR)", readOnlyHint=False))
-    def codna_fix(repo: str = ".", issue: str = "", ref: str = "", open_pr: bool = False) -> str:
+    async def codna_fix(repo: str = ".", issue: str = "", ref: str = "", open_pr: bool = False) -> str:
         """Find and fix a bug. Runs the full codna agent (Cline) + engine + risk simulation.
 
         repo: a local path or a git URL. issue: what's broken (e.g. the failing test).
@@ -122,68 +194,7 @@ def _build_server():
           PULL REQUEST — this needs a git URL for `repo` and a GITHUB_TOKEN with write access.
         Returns the root cause, confidence, model, and (when open_pr) the pull_request_url.
         """
-        repo = _default_repo(repo)
-        try:
-            c = _client()
-            if open_pr:
-                # Same path the CLI's `codna fix --open-pr` uses (engine apply → real PR), so the
-                # MCP tool and CLI are one behavior. run_fix() would sys.exit on bad input, which
-                # must never kill the server — so we pre-validate and also trap SystemExit.
-                import types
-
-                from . import fix_run
-
-                token = os.environ.get("GITHUB_TOKEN") or os.environ.get("CODNA_GITHUB_TOKEN")
-                if not token:
-                    return "codna_fix error: open_pr=true needs a GITHUB_TOKEN with write access."
-                if os.path.isdir(os.path.abspath(os.path.expanduser(repo))):
-                    return "codna_fix error: open_pr=true needs a git URL (a local path has no remote to push to)."
-                if not issue:
-                    return "codna_fix error: open_pr=true needs an `issue` describing what's broken."
-                ns = types.SimpleNamespace(
-                    repo=repo, ref=ref or None, issue=issue, from_junit=None,
-                    tests=False, apply=False, open_pr=True, github_token=token,
-                    model="repository.verified_agentic_v1", max_iterations=1,
-                    pr_title=None, pr_body=None, base_branch=None, test_cmd=None, as_json=True,
-                )
-                try:
-                    result = fix_run.run_fix(c, ns)
-                except SystemExit as exc:  # _die() inside run_fix — surface, don't crash the server
-                    return f"codna_fix error: {exc}"
-                it = (result.get("iterations") or [{}])[-1]
-                s = it.get("summary") or {}
-                applied = result.get("applied") or {}
-                return json.dumps({
-                    "root_cause": s.get("root_cause"),
-                    "confidence": s.get("confidence"),
-                    "pull_request_url": result.get("pull_request_url"),
-                    "status": applied.get("status"),
-                    "model": s.get("runtime_model"),
-                }, indent=2)
-            # plan-only (default, read-only): locate + plan the fix, change nothing.
-            rid, snap = _register(c, repo, ref or None)
-            tri = _dump(c.triage_repository(rid, {"snapshot_id": snap["snapshot_id"],
-                                                  "signals": {"issue_text": issue}}))
-            plan = _dump(c.create_repository_decision_plan(rid, {
-                "snapshot_id": snap["snapshot_id"],
-                "workspace_evidence_bundle_ref": tri.get("workspace_evidence_bundle_ref"),
-                "signals": {"issue_text": issue},
-                "model": "repository.verified_agentic_v1",
-            }))
-            dp = plan.get("decision_plan") or {}
-            ra = dp.get("repository_analysis") or {}
-            usage = plan.get("planner_usage") or {}
-            return json.dumps({
-                "root_cause": ra.get("root_cause"),
-                "impacted_symbols": ra.get("impacted_symbols"),
-                "blast_radius": ra.get("blast_radius"),
-                "confidence": dp.get("confidence"),
-                "patch_ref": ra.get("generated_patch_ref"),
-                "model": plan.get("runtime_model"),
-                "cost_usd": usage.get("cost_usd"),
-            }, indent=2)
-        except Exception as exc:  # noqa: BLE001
-            return f"codna_fix error: {exc}"
+        return await asyncio.to_thread(fix_json, repo, issue, ref, open_pr)
 
     @server.tool(annotations=ToolAnnotations(title="Prove scanner-finding reachability", readOnlyHint=True))
     def codna_secure(repo: str = ".", sarif_path: str = "", ref: str = "") -> str:

{codna-0.1.9 → codna-0.1.11}/codna.egg-info/PKG-INFO

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

{codna-0.1.9 → codna-0.1.11}/pyproject.toml

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

{codna-0.1.9 → codna-0.1.11}/tests/test_local_client.py

@@ -634,6 +634,43 @@ def test_verified_agentic_diff_adds_no_newline_marker_for_git_apply(tmp_path) ->
     assert target_path.read_bytes() == restored.encode("utf-8")
 
 
+def test_verified_agentic_diff_filters_generated_test_cache_artifacts(tmp_path) -> None:
+    before = {
+        "roles.py": 'def has_admin_role(roles):\n    return "admin" in roles\n',
+    }
+    after = {
+        **before,
+        ".pytest_cache/.gitignore": "# Created by pytest automatically.\n*\n",
+        ".pytest_cache/v/cache/nodeids": '[\n  "tests/test_roles.py::T::test_case_insensitive_roles"\n]',
+        "__pycache__/roles.cpython-313.pyc": "binary-cache-placeholder",
+        "roles.py": 'def has_admin_role(roles):\n    return "admin" in [role.lower() for role in roles]\n',
+    }
+
+    patch_diff = local_client_module._git_apply_compatible_unified_diff_from_tree_states(before, after)
+
+    assert ".pytest_cache" not in patch_diff
+    assert "__pycache__" not in patch_diff
+    assert "roles.py" in patch_diff
+    assert "role.lower()" in patch_diff
+
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    target = repo / "roles.py"
+    target.write_text(before["roles.py"], encoding="utf-8")
+    patch_path = repo / ".algenta.patch.diff"
+    patch_path.write_text(patch_diff, encoding="utf-8")
+    subprocess.run(["git", "-C", str(repo), "init", "-q"], check=True)
+    check = subprocess.run(
+        ["git", "-C", str(repo), "apply", "--check", str(patch_path)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert check.returncode == 0, check.stderr
+    subprocess.run(["git", "-C", str(repo), "apply", str(patch_path)], check=True)
+    assert target.read_text(encoding="utf-8") == after["roles.py"]
+
+
 def test_patch_artifact_read_preserves_crlf_payload_lines(tmp_path) -> None:
     patch_path = tmp_path / "patch.diff"
     patch_bytes = (

{codna-0.1.9 → codna-0.1.11}/tests/test_mcp_enrich.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 
 import pytest
 
@@ -24,3 +25,27 @@ def test_resource_and_prompt_registered():
     s = _build_server()
     assert "codna://capabilities" in [str(r.uri) for r in asyncio.run(s.list_resources())]
     assert "fix_bug" in [p.name for p in asyncio.run(s.list_prompts())]
+
+
+def test_codna_fix_runs_sync_client_path_outside_mcp_event_loop(monkeypatch):
+    """Local fix planning uses sync repository-client code that owns its own asyncio runner."""
+    from codna import mcp_server
+
+    async def _inner_plan() -> dict[str, object]:
+        return {"root_cause": "patched through worker thread"}
+
+    def fake_fix_json(repo=".", issue="", ref="", open_pr=False):
+        del repo, issue, ref, open_pr
+        return json.dumps(asyncio.run(_inner_plan()))
+
+    monkeypatch.setattr(mcp_server, "fix_json", fake_fix_json)
+
+    async def call_tool():
+        server = mcp_server._build_server()
+        content, structured = await server.call_tool("codna_fix", {"repo": ".", "issue": "x"})
+        return json.loads(content[0].text), json.loads(structured["result"])
+
+    assert asyncio.run(call_tool()) == (
+        {"root_cause": "patched through worker thread"},
+        {"root_cause": "patched through worker thread"},
+    )