codna 0.1.1__tar.gz → 0.1.3__tar.gz

{codna-0.1.1 → codna-0.1.3}/PKG-INFO

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

{codna-0.1.1 → codna-0.1.3}/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.1"
+__version__ = "0.1.3"

{codna-0.1.1 → codna-0.1.3}/codna/memory.py

@@ -265,16 +265,19 @@ def _require_telys():
     """Lazily import the Telys surface. Raises CodeMemoryError with an install hint if absent."""
     try:
         from telys import Telys, scope_key
-        _configure_telys_kernel_env()
-        # Multigram fusion ([unigram|bigram|trigram], per-block L2): MC-validated to beat the plain bigram
-        # by ~+12-17 pts recall@10 on NL->code and to tie a 16 MB on-device semantic model on recall, at
-        # zero model cost. The local lexical default (no engine key) uses it.
-        from telys.embedding import AlgentaMultigramEmbedder as _LocalEmbedder
     except ImportError as exc:
         raise CodeMemoryError(
             "code memory needs the optional Telys SDK — install it with `pip install 'codna[memory]'`; "
             "if the SDK is already installed, install/activate the signed runtime with `telys runtime install`"
         ) from exc
+    _configure_telys_kernel_env()
+    try:
+        # Multigram fusion ([unigram|bigram|trigram], per-block L2): MC-validated to beat the plain bigram
+        # by ~+12-17 pts recall@10 on NL->code and to tie a 16 MB on-device semantic model on recall, at
+        # zero model cost. The local lexical default (no engine key) uses it.
+        from telys.embedding import AlgentaMultigramEmbedder as _LocalEmbedder
+    except ImportError as exc:
+        raise CodeMemoryError(_kernel_hint()) from exc
     return Telys, scope_key, _LocalEmbedder
 
 

{codna-0.1.1 → codna-0.1.3}/codna/packaged_agent_runner.py

@@ -5,7 +5,7 @@ import os
 import shutil
 import subprocess
 from dataclasses import dataclass
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from typing import Any, Mapping
 
 import httpx
@@ -33,6 +33,19 @@ _WORKSPACE_SKIP_DIRS = {
     "target",
     "venv",
 }
+_PATCH_CAPTURE_SKIP_DIRS = _WORKSPACE_SKIP_DIRS | {
+    ".cache",
+    ".mypy_cache",
+    ".pytest_cache",
+    ".ruff_cache",
+    ".tox",
+}
+_PATCH_CAPTURE_SKIP_FILES = {
+    ".coverage",
+    ".DS_Store",
+    "coverage.xml",
+}
+_PATCH_CAPTURE_SKIP_SUFFIXES = (".pyc", ".pyo")
 
 
 @dataclass(frozen=True)
@@ -205,15 +218,64 @@ def _cleanup_workspace(repo_root: Path, workspace: _Workspace) -> None:
 
 
 def _capture_patch(workspace: Path) -> str:
-    subprocess.run(
-        ["git", "-C", str(workspace), "add", "-N", "."],
+    _add_untracked_patch_candidates(workspace)
+    result = subprocess.run(
+        ["git", "-C", str(workspace), "diff", "--binary", "--no-ext-diff", "--"],
         capture_output=True,
         text=True,
         check=False,
         timeout=60,
     )
+    if result.returncode != 0:
+        raise PackagedRepositoryAdvancedError(
+            "agent_patch_capture_failed",
+            "Codna could not capture the local agent patch.",
+            {"workspace": str(workspace), "stderr": result.stderr[-2000:]},
+        )
+    return result.stdout
+
+
+def _add_untracked_patch_candidates(workspace: Path) -> None:
     result = subprocess.run(
-        ["git", "-C", str(workspace), "diff", "--binary", "--no-ext-diff", "--"],
+        ["git", "-C", str(workspace), "ls-files", "--others", "--exclude-standard", "-z"],
+        capture_output=True,
+        check=False,
+        timeout=60,
+    )
+    if result.returncode != 0:
+        raise PackagedRepositoryAdvancedError(
+            "agent_patch_capture_failed",
+            "Codna could not inspect untracked local agent patch files.",
+            {"workspace": str(workspace), "stderr": result.stderr.decode("utf-8", "replace")[-2000:]},
+        )
+    candidates = [
+        path
+        for path in _decode_git_z_paths(result.stdout)
+        if _should_capture_untracked_patch_file(path)
+    ]
+    for start in range(0, len(candidates), 100):
+        _git_add_intent_to_add(workspace, candidates[start : start + 100])
+
+
+def _decode_git_z_paths(raw: bytes) -> list[str]:
+    return [item.decode("utf-8", "surrogateescape") for item in raw.split(b"\0") if item]
+
+
+def _should_capture_untracked_patch_file(path: str) -> bool:
+    parsed = PurePosixPath(path)
+    if any(part in _PATCH_CAPTURE_SKIP_DIRS for part in parsed.parts):
+        return False
+    name = parsed.name
+    if name in _PATCH_CAPTURE_SKIP_FILES:
+        return False
+    return not name.endswith(_PATCH_CAPTURE_SKIP_SUFFIXES)
+
+
+def _git_add_intent_to_add(workspace: Path, paths: list[str]) -> None:
+    if not paths:
+        return
+    result = subprocess.run(
+        ["git", "-C", str(workspace), "add", "-N", "--", *paths],
         capture_output=True,
         text=True,
         check=False,
@@ -222,10 +284,9 @@ def _capture_patch(workspace: Path) -> str:
     if result.returncode != 0:
         raise PackagedRepositoryAdvancedError(
             "agent_patch_capture_failed",
-            "Codna could not capture the local agent patch.",
+            "Codna could not stage local agent patch candidates for capture.",
             {"workspace": str(workspace), "stderr": result.stderr[-2000:]},
         )
-    return result.stdout
 
 
 def _init_baseline_git_repo(workspace: Path) -> None:
@@ -255,7 +316,7 @@ def _is_clean_git_repo(repo_root: Path) -> bool:
     if inside.returncode != 0 or inside.stdout.strip() != "true":
         return False
     status = subprocess.run(
-        ["git", "-C", str(repo_root), "status", "--porcelain=v1", "-z", "--untracked-files=all"],
+        ["git", "-C", str(repo_root), "status", "--porcelain=v1", "-z", "--untracked-files=no"],
         capture_output=True,
         check=False,
         timeout=30,

{codna-0.1.1 → codna-0.1.3}/codna/packaged_repository_advanced.py

@@ -324,11 +324,12 @@ class PackagedRepositoryAdvanced:
 
     def _apply_local_branch(self, repo_root: Path, plan_id: str, patch_diff: str) -> str:
         _require_git_repo(repo_root)
-        if _git_dirty(repo_root):
+        blockers = _apply_blockers(repo_root, patch_diff)
+        if blockers:
             raise PackagedRepositoryAdvancedError(
                 "repository_apply_dirty_worktree",
-                "local_branch apply requires a clean git worktree.",
-                {"repo_root": str(repo_root)},
+                "local_branch apply requires no tracked changes and no untracked files that conflict with the patch.",
+                {"repo_root": str(repo_root), **blockers},
             )
         branch = "codna/" + plan_id.removeprefix("plan_")[:16]
         _run_git(repo_root, ["checkout", "-b", branch])
@@ -562,9 +563,35 @@ def _require_git_repo(repo_root: Path) -> None:
         )
 
 
-def _git_dirty(repo_root: Path) -> bool:
-    result = _run_git(repo_root, ["status", "--porcelain=v1", "-z", "--untracked-files=all"])
-    return bool(result.stdout)
+def _apply_blockers(repo_root: Path, patch_diff: str) -> dict[str, Any]:
+    tracked = _git_status(repo_root, include_untracked=False)
+    if tracked:
+        return {"tracked_status": tracked}
+    patch_targets = set(_changed_files_from_patch(patch_diff))
+    if not patch_targets:
+        return {"patch_targets": []}
+    conflicts = _conflicting_untracked_files(repo_root, patch_targets)
+    if conflicts:
+        return {"conflicting_untracked_files": conflicts}
+    return {}
+
+
+def _git_status(repo_root: Path, *, include_untracked: bool) -> list[str]:
+    untracked = "all" if include_untracked else "no"
+    result = _run_git(repo_root, ["status", "--porcelain=v1", "-z", f"--untracked-files={untracked}"])
+    return [entry for entry in result.stdout.split("\0") if entry]
+
+
+def _conflicting_untracked_files(repo_root: Path, patch_targets: set[str]) -> list[str]:
+    result = _run_git(repo_root, ["ls-files", "--others", "--exclude-standard", "-z"])
+    conflicts: list[str] = []
+    for raw in result.stdout.split("\0"):
+        path = raw.strip()
+        if not path:
+            continue
+        if path in patch_targets:
+            conflicts.append(path)
+    return conflicts
 
 
 def _run_git(repo_root: Path, args: list[str]) -> subprocess.CompletedProcess:

{codna-0.1.1 → codna-0.1.3}/codna.egg-info/PKG-INFO

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

{codna-0.1.1 → codna-0.1.3}/pyproject.toml

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

{codna-0.1.1 → codna-0.1.3}/tests/test_local_client.py

@@ -17,6 +17,41 @@ from codna.runtime.config import ConfigValue
 import codna.local_client as local_client_module
 import codna.local_mojo_daemon as mojo_daemon_module
 import codna.local_mojo_pool as mojo_pool_module
+import codna.packaged_agent_runner as packaged_agent_runner_module
+
+
+def _git(repo: Path, *args: str) -> str:
+    result = subprocess.run(
+        ["git", "-C", str(repo), *args],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr
+    return result.stdout
+
+
+def test_packaged_agent_patch_capture_excludes_generated_untracked_artifacts(tmp_path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "app.py").write_text("def price():\n    return 1\n", encoding="utf-8")
+    _git(repo, "init", "-b", "main")
+    _git(repo, "add", "app.py")
+    _git(repo, "-c", "user.email=a@example.com", "-c", "user.name=Tester", "commit", "-m", "initial")
+    (repo / "app.py").write_text("def price():\n    return 2\n", encoding="utf-8")
+    (repo / "new_module.py").write_text("def tax():\n    return 0\n", encoding="utf-8")
+    (repo / "__pycache__").mkdir()
+    (repo / "__pycache__" / "app.cpython-313.pyc").write_bytes(b"cache")
+    (repo / ".pytest_cache").mkdir()
+    (repo / ".pytest_cache" / "README.md").write_text("cache\n", encoding="utf-8")
+
+    patch = packaged_agent_runner_module._capture_patch(repo)
+
+    assert "diff --git a/app.py b/app.py" in patch
+    assert "diff --git a/new_module.py b/new_module.py" in patch
+    assert "__pycache__" not in patch
+    assert ".pytest_cache" not in patch
+    assert ".pyc" not in patch
 
 
 class _Dumpable:
@@ -313,6 +348,148 @@ def test_local_client_packaged_backend_runs_packaged_fix_steps(tmp_path, monkeyp
     assert all(row["status"] == "succeeded" for row in rows)
 
 
+def test_packaged_local_branch_allows_unrelated_untracked_files(tmp_path, monkeypatch) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "app.ts").write_text("export function price() { return 1 }\n", encoding="utf-8")
+    (repo / "__pycache__").mkdir()
+    (repo / "__pycache__" / "app.cpython-313.pyc").write_bytes(b"cache")
+    _git(repo, "init", "-b", "main")
+    _git(repo, "add", "app.ts")
+    _git(repo, "-c", "user.email=a@example.com", "-c", "user.name=Tester", "commit", "-m", "initial")
+    monkeypatch.delenv("ALGENTA_ENGINE_DIR", raising=False)
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    monkeypatch.setattr(local_client_module, "_import_repository_modules", _raise_missing_apps_backend)
+
+    def fake_run(_runner, _request):
+        return PackagedAgentRunResult(
+            status="succeeded",
+            terminal_state="succeeded",
+            agent_run_id="run-1",
+            session_id="session-1",
+            text="Fixed price return value.",
+            files_changed=["app.ts"],
+            telemetry={"tokens_in_uncached": 12, "tokens_out": 5, "total_cost": 0.01},
+            artifacts={},
+            runtime={"kind": "cline", "is_stub": False},
+            patch_diff=(
+                "diff --git a/app.ts b/app.ts\n"
+                "--- a/app.ts\n"
+                "+++ b/app.ts\n"
+                "@@ -1 +1 @@\n"
+                "-export function price() { return 1 }\n"
+                "+export function price() { return 2 }\n"
+            ),
+        )
+
+    monkeypatch.setattr(local_client_module.SidecarPackagedAgentRunner, "run", fake_run)
+
+    client = LocalCodnaRuntimeClient()
+    connector = client.create_connector(name="repo", connector_type="local_repo", config={"path": str(repo)})
+    snapshot = client.create_repository_snapshot(connector["id"], {})
+    triage = client.triage_repository(
+        connector["id"],
+        {"snapshot_id": snapshot["snapshot_id"], "signals": {"issue_text": "price bug"}},
+    )
+    plan = client.create_repository_decision_plan(
+        connector["id"],
+        {
+            "snapshot_id": snapshot["snapshot_id"],
+            "workspace_evidence_bundle_ref": triage["workspace_evidence_bundle_ref"],
+            "signals": {"issue_text": "price bug"},
+        },
+    )
+    simulation = client.simulate_repository(
+        connector["id"],
+        {"snapshot_id": snapshot["snapshot_id"], "decision_plan_id": plan["decision_plan_id"]},
+    )
+
+    result = client.apply_repository(
+        connector["id"],
+        {
+            "mode": "local_branch",
+            "write_permission": True,
+            "decision_plan_id": plan["decision_plan_id"],
+            "simulation_id": simulation["validated_inputs"]["simulation_id"],
+        },
+    )
+
+    assert result["status"] == "applied"
+    assert result["branch_name"].startswith("codna/")
+    assert (repo / "app.ts").read_text(encoding="utf-8") == "export function price() { return 2 }\n"
+    assert (repo / "__pycache__" / "app.cpython-313.pyc").exists()
+
+
+def test_packaged_local_branch_rejects_conflicting_untracked_target(tmp_path, monkeypatch) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    _git(repo, "init", "-b", "main")
+    (repo / "README.md").write_text("repo\n", encoding="utf-8")
+    _git(repo, "add", "README.md")
+    _git(repo, "-c", "user.email=a@example.com", "-c", "user.name=Tester", "commit", "-m", "initial")
+    (repo / "app.ts").write_text("local untracked content\n", encoding="utf-8")
+    monkeypatch.delenv("ALGENTA_ENGINE_DIR", raising=False)
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    monkeypatch.setattr(local_client_module, "_import_repository_modules", _raise_missing_apps_backend)
+
+    def fake_run(_runner, _request):
+        return PackagedAgentRunResult(
+            status="succeeded",
+            terminal_state="succeeded",
+            agent_run_id="run-1",
+            session_id="session-1",
+            text="Added app.",
+            files_changed=["app.ts"],
+            telemetry={"tokens_in_uncached": 12, "tokens_out": 5, "total_cost": 0.01},
+            artifacts={},
+            runtime={"kind": "cline", "is_stub": False},
+            patch_diff=(
+                "diff --git a/app.ts b/app.ts\n"
+                "new file mode 100644\n"
+                "--- /dev/null\n"
+                "+++ b/app.ts\n"
+                "@@ -0,0 +1 @@\n"
+                "+export function price() { return 2 }\n"
+            ),
+        )
+
+    monkeypatch.setattr(local_client_module.SidecarPackagedAgentRunner, "run", fake_run)
+
+    client = LocalCodnaRuntimeClient()
+    connector = client.create_connector(name="repo", connector_type="local_repo", config={"path": str(repo)})
+    snapshot = client.create_repository_snapshot(connector["id"], {})
+    triage = client.triage_repository(
+        connector["id"],
+        {"snapshot_id": snapshot["snapshot_id"], "signals": {"issue_text": "missing app"}},
+    )
+    plan = client.create_repository_decision_plan(
+        connector["id"],
+        {
+            "snapshot_id": snapshot["snapshot_id"],
+            "workspace_evidence_bundle_ref": triage["workspace_evidence_bundle_ref"],
+            "signals": {"issue_text": "missing app"},
+        },
+    )
+    simulation = client.simulate_repository(
+        connector["id"],
+        {"snapshot_id": snapshot["snapshot_id"], "decision_plan_id": plan["decision_plan_id"]},
+    )
+
+    with pytest.raises(PackagedRepositoryAdvancedError) as excinfo:
+        client.apply_repository(
+            connector["id"],
+            {
+                "mode": "local_branch",
+                "write_permission": True,
+                "decision_plan_id": plan["decision_plan_id"],
+                "simulation_id": simulation["validated_inputs"]["simulation_id"],
+            },
+        )
+
+    assert excinfo.value.code == "repository_apply_dirty_worktree"
+    assert excinfo.value.details["conflicting_untracked_files"] == ["app.ts"]
+
+
 def test_local_client_packaged_backend_fails_closed_when_agent_makes_no_patch(tmp_path, monkeypatch) -> None:
     repo = tmp_path / "repo"
     repo.mkdir()

{codna-0.1.1 → codna-0.1.3}/tests/test_memory_errors.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import os
 import json
 import sys
+import types
 
 import pytest
 
@@ -32,6 +33,22 @@ def test_require_telys_missing_extra_is_friendly(monkeypatch):
     assert "codna[memory]" in str(ei.value)        # tells the user exactly how to fix it
 
 
+def test_require_telys_missing_embedding_runtime_is_friendly(monkeypatch):
+    _clear_kernel_env(monkeypatch)
+    fake_telys = types.ModuleType("telys")
+    fake_telys.__path__ = []
+    fake_telys.Telys = object
+    fake_telys.scope_key = lambda *_args: "scope"
+    monkeypatch.setitem(sys.modules, "telys", fake_telys)
+    monkeypatch.setitem(sys.modules, "telys.embedding", None)
+
+    with pytest.raises(CodeMemoryError) as ei:
+        _require_telys()
+
+    assert "Telys kernel could not be loaded" in str(ei.value)
+    assert "telys runtime install" in str(ei.value)
+
+
 def test_embedder_missing_runtime_import_is_friendly(monkeypatch):
     class MissingKernelEmbedder:
         def __init__(self):