localcode 0.3.58__tar.gz → 0.3.60__tar.gz

{localcode-0.3.58/src/localcode.egg-info → localcode-0.3.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.58
+Version: 0.3.60
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.58 → localcode-0.3.60}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.58"
+version = "0.3.60"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

{localcode-0.3.58 → localcode-0.3.60}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ from importlib.metadata import PackageNotFoundError, version as _pkg_version
 try:
     __version__ = _pkg_version("localcode")
 except PackageNotFoundError:  # not installed (e.g. raw source checkout)
-    __version__ = "0.3.58"
+    __version__ = "0.3.60"

{localcode-0.3.58 → localcode-0.3.60}/src/localcode/headless_json.py

@@ -198,6 +198,16 @@ def run_headless_json(config, args) -> int:
     _sys.stdout = devnull
 
     try:
+        # Connect user-configured MCP servers (~/.localcode/mcp.json) so headless
+        # `run --json` gets the same MCP tools (incl. LSP) as the TUI. Best-effort:
+        # a server that fails to start must never break the run, and no mcp.json
+        # is a fast no-op. Without this, MCP tools were silently absent in
+        # headless mode (CI, eval, scripting) even when configured.
+        try:
+            from .mcp import connect_all as _mcp_connect_all
+            _mcp_connect_all()
+        except Exception:
+            pass
         result_text = app.ask(args.goal, stream=True)
     except TimeoutError:
         return _emit_result("timeout", 124, f"run exceeded {args.timeout}s")
@@ -206,6 +216,11 @@ def run_headless_json(config, args) -> int:
     except Exception as e:  # noqa: BLE001 — headless: surface any failure as exit 1
         return _emit_result("error", 1, f"{type(e).__name__}: {e}")
     finally:
+        try:
+            from .mcp import shutdown_all as _mcp_shutdown_all
+            _mcp_shutdown_all()
+        except Exception:
+            pass
         if args.timeout and args.timeout > 0:
             import signal
             signal.alarm(0)

{localcode-0.3.58 → localcode-0.3.60}/src/localcode/tools/__init__.py

@@ -339,6 +339,23 @@ def dispatch_result(name: str, ctx: ToolContext, args: dict) -> ToolResult:
     raw_result = executor(ctx, args)
     result = raw_result if isinstance(raw_result, ToolResult) else _normalize_result(clean, args, str(raw_result))
 
+    # Auto-surface typecheck diagnostics after a successful CODE edit — the weak
+    # model rarely runs them itself, so we feed them back in-context. Debounced +
+    # new-errors-only (see diagnostics_after_edit), so it can't dominate the edit
+    # path or nag with the same wall of errors.
+    if clean in ("edit_file", "write_file", "multi_edit", "append_file") and result.ok:
+        _path = str((args or {}).get("path") or (args or {}).get("file_path") or "")
+        if _path.rsplit(".", 1)[-1].lower() in (
+            "ts", "tsx", "js", "jsx", "mjs", "cjs", "py", "go", "rs", "vue", "svelte"
+        ):
+            try:
+                from .project_check import diagnostics_after_edit
+                _diag = diagnostics_after_edit(str(ctx.repo))
+                if _diag:
+                    result = ToolResult(text=result.text + _diag, ok=result.ok, facts=result.facts)
+            except Exception:
+                pass
+
     return result
 
 

{localcode-0.3.58 → localcode-0.3.60}/src/localcode/tools/project_check.py

@@ -601,3 +601,40 @@ def _has_ext(root: str, ext: str) -> bool:
         if any(f.endswith(ext) for f in files):
             return True
     return False
+
+
+# ── Auto-surfaced diagnostics after an edit ──────────────────────────────────
+# A weak local model almost never runs the typecheck itself (a real Anki run
+# used the LSP/diagnostics tools ZERO times), so we surface diagnostics FOR it,
+# in-context, right after a code edit — but debounced so the typecheck never
+# dominates the edit path, and only when the error set CHANGED so we don't repeat
+# the same wall every edit. The completion gate remains the hard barrier; this is
+# early feedback that lets the model fix errors as it goes instead of at the end.
+_INCR_MIN_INTERVAL = 30.0
+_incr_state: dict = {"ts": 0.0, "sig": None}
+
+
+def diagnostics_after_edit(repo_root: str, ctx_tokens: int = 0) -> str | None:
+    """Debounced post-edit typecheck. Returns NEW diagnostics to append to the
+    edit tool's result, or None (clean / too soon / unchanged / no checker)."""
+    import time as _time
+    now = _time.monotonic()
+    if now - _incr_state["ts"] < _INCR_MIN_INTERVAL:
+        return None
+    _incr_state["ts"] = now
+    try:
+        outcome = run_project_check_result(repo_root, ctx_tokens)
+    except Exception:
+        return None
+    if not outcome.is_red:
+        _incr_state["sig"] = None
+        return None
+    import hashlib as _hashlib
+    sig = _hashlib.md5(outcome.detail.encode(errors="replace")).hexdigest()
+    if sig == _incr_state["sig"]:
+        return None  # same errors already surfaced — don't nag
+    _incr_state["sig"] = sig
+    return (
+        "\n\n--- Typecheck after your edit reported errors — fix these NOW "
+        "(don't wait until the end) ---\n" + outcome.detail
+    )

{localcode-0.3.58 → localcode-0.3.60}/src/localcode/tools/todo_write.py

@@ -134,6 +134,38 @@ def execute(ctx: ToolContext, args: dict) -> str:
         )
     cleaned = _normalize(todos)
     session = getattr(ctx.app, "session", None)
+    prev = list(getattr(session, "todos", []) or []) if session is not None else []
+
+    # CHURN GUARD. A weak model re-emits an essentially-identical plan over and
+    # over instead of executing it — a real Anki run made 43 todo_write calls,
+    # ALL the same list, completed-count never moved (37% of every action wasted).
+    # If the new list matches the stored one (same content + status, nothing newly
+    # completed), don't accept it blandly: refuse the no-op and steer the model to
+    # take a real action on the in_progress item. Escalate on repeated churn.
+    def _sig(lst: list[dict]) -> list[tuple[str, str]]:
+        return [(t.get("content", ""), t.get("status", "")) for t in lst]
+
+    if cleaned and _sig(cleaned) == _sig(prev):
+        churn = int(getattr(session, "_todo_churn", 0)) + 1 if session is not None else 1
+        if session is not None:
+            session._todo_churn = churn
+        cur = (
+            next((t for t in cleaned if t["status"] == "in_progress"), None)
+            or next((t for t in cleaned if t["status"] == "pending"), None)
+        )
+        target = cur.get("content", "the current step") if cur else "the current step"
+        lead = (
+            f"You have now re-sent the SAME plan {churn} times without doing anything — "
+            f"this is a loop."
+            if churn >= 2
+            else "Your plan is UNCHANGED from your last todo_write — rewriting it wastes the round."
+        )
+        return (
+            f"{lead} STOP calling todo_write. Take a real write_file / edit_file / bash "
+            f"action on: {target}. Only call todo_write again to mark a step COMPLETED."
+        )
+    if session is not None:
+        session._todo_churn = 0
 
     # Auto-clear once everything is done — an all-completed list means the
     # job is finished, so persist it as empty rather than a wall of [x].

{localcode-0.3.58 → localcode-0.3.60/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.58
+Version: 0.3.60
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.58 → localcode-0.3.60}/src/localcode.egg-info/SOURCES.txt

@@ -992,6 +992,7 @@ tests/test_subproc_env.py
 tests/test_syntax_check.py
 tests/test_task_statement_pinning.py
 tests/test_thermal.py
+tests/test_todo_churn_and_incremental_diag.py
 tests/test_tool_arg_validation.py
 tests/test_toolkit.py
 tests/test_tui_input.py

localcode-0.3.60/tests/test_todo_churn_and_incremental_diag.py

@@ -0,0 +1,102 @@
+"""Two fixes grounded in the Anki-run logs:
+
+1. todo_write churn guard — a real run made 43 todo_write calls, all the SAME
+   list, completed-count never moved (37% of every action wasted). Re-sending an
+   unchanged plan must be refused with a steer, not accepted.
+2. Auto-surfaced diagnostics after a code edit — the model used the LSP/diagnostic
+   tools ZERO times, so LocalCode runs the typecheck FOR it after an edit and
+   appends the errors to the tool result.
+"""
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from localcode.tools.base import ToolContext
+from localcode.tools import dispatch
+from localcode.tools import todo_write as T
+import localcode.tools.project_check as pc
+
+
+class _Out:
+    def __getattr__(self, _):
+        return lambda *a, **k: None
+
+
+class _App:
+    def __init__(self, repo_root):
+        self.repo_root = repo_root
+        self.session = SimpleNamespace(todos=[], current_task=None)
+
+
+def _ctx(tmp_path):
+    return ToolContext(app=_App(tmp_path), out=_Out())
+
+
+# ── 1. todo_write churn guard ────────────────────────────────────────────────
+
+PLAN = [
+    {"content": "Scaffold project", "status": "in_progress"},
+    {"content": "Write fsrs module", "status": "pending"},
+]
+
+
+def test_first_todo_write_is_accepted(tmp_path):
+    ctx = _ctx(tmp_path)
+    assert "updated" in T.execute(ctx, {"todos": PLAN}).lower()
+
+
+def test_identical_replan_is_refused_with_a_steer(tmp_path):
+    ctx = _ctx(tmp_path)
+    T.execute(ctx, {"todos": PLAN})
+    out = T.execute(ctx, {"todos": PLAN})
+    assert "UNCHANGED" in out and "STOP calling todo_write" in out
+    assert "Scaffold project" in out  # names the in_progress step to act on
+
+
+def test_repeated_churn_escalates(tmp_path):
+    ctx = _ctx(tmp_path)
+    T.execute(ctx, {"todos": PLAN})
+    T.execute(ctx, {"todos": PLAN})
+    out = T.execute(ctx, {"todos": PLAN})
+    assert "same plan" in out.lower() and "loop" in out.lower()
+
+
+def test_real_progress_is_accepted_and_resets_churn(tmp_path):
+    ctx = _ctx(tmp_path)
+    T.execute(ctx, {"todos": PLAN})
+    T.execute(ctx, {"todos": PLAN})  # churn
+    progressed = [
+        {"content": "Scaffold project", "status": "completed"},
+        {"content": "Write fsrs module", "status": "in_progress"},
+    ]
+    out = T.execute(ctx, {"todos": progressed})
+    assert "updated" in out.lower()
+    assert ctx.app.session._todo_churn == 0
+
+
+# ── 2. auto-surfaced diagnostics after a code edit ───────────────────────────
+
+def test_diagnostics_appended_after_editing_broken_code(tmp_path):
+    pc._incr_state["ts"] = 0.0
+    pc._incr_state["sig"] = None
+    ctx = _ctx(tmp_path)
+    # a Python syntax error is caught by ruff OR compileall (either detector)
+    out = dispatch("write_file", ctx, {"path": "bad.py", "content": "def f(:\n    pass\n"})
+    assert "reported errors" in out or "Typecheck after your edit" in out
+
+
+def test_no_diagnostics_appended_for_non_code_file(tmp_path):
+    pc._incr_state["ts"] = 0.0
+    pc._incr_state["sig"] = None
+    ctx = _ctx(tmp_path)
+    out = dispatch("write_file", ctx, {"path": "notes.md", "content": "# hi\n"})
+    assert "Typecheck after your edit" not in out
+
+
+def test_diagnostics_debounced_on_immediate_second_edit(tmp_path):
+    pc._incr_state["ts"] = 0.0
+    pc._incr_state["sig"] = None
+    ctx = _ctx(tmp_path)
+    dispatch("write_file", ctx, {"path": "a.py", "content": "def f(:\n pass\n"})
+    out2 = dispatch("write_file", ctx, {"path": "b.py", "content": "def g(:\n pass\n"})
+    assert "Typecheck after your edit" not in out2  # within debounce window