localcode 0.3.5__py3-none-any.whl → 0.3.7__py3-none-any.whl

localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.5"
+__version__ = "0.3.7"

localcode/agent/loop.py

@@ -40,6 +40,7 @@ __all__ = ["run_agent_loop"]
 
 from .constants import (
     MAX_ROUNDS,
+    CHURN_FILE_WRITE_LIMIT,
     MAX_OUTPUT_TOKENS,
     MAX_THINKING_SECONDS,
     MAX_THINKING_CHARS,
@@ -70,6 +71,7 @@ from .prompts import (
 )
 from .prompt_context import build_agent_system_prompt
 from .recovery import (
+    rewrite_hard_stop,
     StallMode,
     detect_stall,
     nudge_for,
@@ -1141,33 +1143,13 @@ def run_agent_loop(
             _ephemeral_nudge_indices.append(len(messages) - 1)
 
         # ── Stalled-round recovery ──
-        # Three failure modes end a round with the model NOT actually
-        # done, but the user watching a frozen screen:
-        #
-        # (A) Empty round — long reasoning, then server closes the
-        #     stream with NO content and NO tool_calls. Images 107/108.
-        #
-        # (B) Intent-without-action — model emits ONE sentence of
-        #     forward-looking narration ("I'll build the web app now.
-        #     Let me create this.") and stops, with no tool call. Image
-        #     112. Happens because IQ2/IQ3 sometimes exits the reasoning
-        #     channel with just a sign-off instead of an action.
-        #
-        # (C) Gave-up-after-rejection — most recent tool call returned
-        #     a "REJECTED" / "Error" string AND the round ended with no
-        #     follow-up tool call. The model hit a snag and bailed
-        #     instead of reading the rejection's actionable feedback
-        #     and retrying. This was image 123: write_file got
-        #     REJECTED for syntax error, model stopped completely.
-        #
-        # Stall detection + nudge. Logic lives in agent/recovery.py
-        # (T0.1-d split). `stall` is None for a productive round,
-        # otherwise a `StallMode` enum that drives both the telemetry
-        # label and the per-mode nudge text.
-        # Gated on Feature.AUTO_NUDGE_RECOVERY. Disabled → stalls end
-        # the turn silently (no synthetic SYSTEM: nudge), which is the
-        # pre-recovery behaviour and what eval wants when A/B-ing the
-        # nudge feature's actual contribution to task completion.
+        # Three failure modes end a round with the model NOT done: (A) empty
+        # round (long reasoning, stream closes with no content/tools); (B)
+        # intent-without-action (one narration sentence, no tool call); (C)
+        # gave-up-after-rejection (last tool returned REJECTED/Error, round
+        # ended with no retry). Detection + nudge live in agent/recovery.py;
+        # `stall` is None for a productive round else a StallMode. Gated on
+        # Feature.AUTO_NUDGE_RECOVERY (off → stalls end the turn silently).
         from ..features import Feature, is_enabled as _is_enabled
         stall = detect_stall(
             tool_calls=tool_calls,
@@ -1508,11 +1490,22 @@ def run_agent_loop(
                     "smallest targeted edit and verify it."
                 )
 
+            # HARD rewrite-stop: the churn NUDGE (limit 3) only advises — logs
+            # showed a model rewrite one file 16x while 25-34 nudges fired.
+            # Past 2x the nudge limit, REJECT further full rewrites (see
+            # recovery.rewrite_hard_stop). Key on the RAW path like the counter.
+            _rewrite_limit_stub = None
+            if tool_name in ("write_file", "append_file", "multi_edit") and isinstance(args, dict):
+                _rw_path = args.get("path") or args.get("file_path") or ""
+                _rewrite_limit_stub = rewrite_hard_stop(_rw_path, _file_write_counts)
             # Execute (timed — wall-clock added to _round_tool_exec_ms
             # so round_end can show the model what fraction of its
             # round time was spent waiting on tools vs LLM).
             _tool_started_at = time.monotonic()
-            if _edit_sequence_stub is not None:
+            if _rewrite_limit_stub is not None:
+                from ..tools import ToolResult as _ToolResult
+                _tool_result_obj = _ToolResult(text=_rewrite_limit_stub, ok=False, facts={"tool": tool_name, "ok": False, "repeated_failed_call": True, "rewrite_hard_stop": True})
+            elif _edit_sequence_stub is not None:
                 from ..tools import ToolResult as _ToolResult
                 _tool_result_obj = _ToolResult(text=_edit_sequence_stub, ok=False, facts={"tool": tool_name, "ok": False, "edit_sequence": "missing_context"})
             elif _oversize_stub is not None:

localcode/agent/recovery.py

@@ -127,25 +127,12 @@ def detect_stall(
     if not content:
         return StallMode.EMPTY
 
-    # NARRATION. Real failures showed the model
-    # emitting hundreds of chars describing the edit it was about to
-    # make, then ending the round with zero tool calls.
-    #
-    # Important: do NOT classify every short answer after a tool call as
-    # narration. A question like "weather in ny?" legitimately uses one
-    # tool, then answers in ~200 chars. The old broad `<400 chars after
-    # tools` rule deleted that answer, injected an auto-nudge, and made
-    # the model call the same API repeatedly. Only intent phrases count
-    # as narration.
-    #
-    # Two complementary detectors:
-    #   • _NARRATION_INTENT_RE — "let me X" / "I'll Y" / "going to Z"
-    #     anywhere in the content (full scan, not just tail) catches
-    #     case (1) and similar variants where the commit phrase may
-    #     be mid-content rather than at the end.
-    #   • _NARRATION_PRESENT_PARTICIPLE_RE — last sentence starts with
-    #     "Updating X / Changing Y / Now writing Z" + target. Past
-    #     tense "Updated X" / "Changed Y" deliberately excluded.
+    # NARRATION detection. Only INTENT phrases count — not every short answer
+    # after a tool call (a "weather in ny?" answer legitimately runs one tool
+    # then replies in ~200 chars; the old broad rule deleted such answers and
+    # looped). Two detectors: _NARRATION_INTENT_RE ("let me X"/"I'll Y" anywhere)
+    # and _NARRATION_PRESENT_PARTICIPLE_RE (last sentence "Updating X/Now writing
+    # Z" + target; past tense "Updated X" excluded).
     stripped = content.strip()
     if bool(tools_called_prior) and stripped:
         if _NARRATION_INTENT_RE.search(stripped):
@@ -398,3 +385,19 @@ def churn_nudge_for(signal: ChurnSignal) -> str:
         "disk that you did not create are not part of your task. If you truly "
         "lack information only the user has, ask ONE focused question."
     )
+
+
+def rewrite_hard_stop(path, file_write_counts) -> str | None:
+    """Circuit-breaker for rewrite drift: reject once a path is rewritten past
+    2x the nudge limit (the nudge only advises; logs showed 16x on one file)."""
+    if not path or not isinstance(path, str):
+        return None
+    n = file_write_counts.get(path, 0)
+    if n < CHURN_FILE_WRITE_LIMIT * 2:
+        return None
+    return (
+        f"REJECTED — HARD STOP: you have rewritten {path} {n} times this turn "
+        "and it's still not right — full rewrites are drifting. Make ONE "
+        "targeted edit_file change to the broken line, or leave this file and "
+        "move on. Do NOT call write_file on this path again."
+    )

localcode/agent/streaming.py

@@ -89,58 +89,6 @@ def _decode_streaming_content(args: str, start_pos: int) -> tuple[str, int]:
     return ("".join(out), i)
 
 
-def _maybe_incremental_write(
-    app: "LocalCodeApp",
-    result: "StreamRoundResult",
-    *,
-    tool_name: str,
-    tool_idx: int,
-    snippet: str,
-) -> None:
-    """Write the streaming `content` to disk incrementally for write_file
-    / append_file. Tracks per-tool-index state on `result.live_writes`
-    so we only write NEW bytes each tick.
-
-    Best-effort: any failure (path not yet decoded, decode error, FS
-    error) silently no-ops — the round-end atomic write_file.execute()
-    is still authoritative."""
-    if tool_name not in {"write_file", "append_file"}:
-        return
-    if not snippet:
-        return
-    state = result.live_writes.get(tool_idx)
-    if state is None:
-        # Need a path before we can write anywhere. Extract it from the
-        # leading args; tool schemas put it FIRST so it shows up in the
-        # first ~256 chars.
-        m = _PATH_FIELD_RE.search(snippet)
-        if not m:
-            return
-        path_str = m.group(1)
-        try:
-            target = Path(path_str)
-            if not target.is_absolute():
-                target = Path(app.repo_root) / target
-            target.parent.mkdir(parents=True, exist_ok=True)
-            # write_file truncates; append_file extends an existing file.
-            mode = "w" if tool_name == "write_file" else "a"
-            target.open(mode).close()  # truncate / touch
-        except Exception:
-            return
-        state = {"path": str(target), "decoded_pos": 0}
-        result.live_writes[tool_idx] = state
-    decoded, new_pos = _decode_streaming_content(snippet, state["decoded_pos"])
-    if not decoded and new_pos == state["decoded_pos"]:
-        return
-    if decoded:
-        try:
-            with open(state["path"], "a", encoding="utf-8") as f:
-                f.write(decoded)
-        except Exception:
-            return
-    state["decoded_pos"] = new_pos
-
-
 @dataclass
 class StreamRoundResult:
     content_parts: list[str] = field(default_factory=list)
@@ -253,18 +201,19 @@ def stream_model_round(
             out.stream(chunk)
             return
         if typ == "tool_preview":
+            # Live file preview is driven from THIS event (the TUI decodes
+            # args_snippet). We deliberately do NOT write to the target file
+            # incrementally: if the round was cut short (token/context cap, a
+            # mid-stream server SIGKILL, Ctrl-C), the partial bytes orphaned on
+            # disk while the loop discarded the tool call — leaving a truncated
+            # file (e.g. "autop") that the model then read back and churned on
+            # forever. The authoritative full-overwrite write_file.execute() at
+            # round-commit is the ONLY thing that touches disk.
             out.tool_preview(
                 event.get("name", ""),
                 int(event.get("args_chars", 0) or 0),
                 event.get("args_snippet", "") or "",
             )
-            _maybe_incremental_write(
-                app,
-                result,
-                tool_name=event.get("name", "") or "",
-                tool_idx=int(event.get("index", -1) or -1),
-                snippet=event.get("args_snippet", "") or "",
-            )
             return
         if typ == "tool_calls":
             result.tool_calls = event.get("tool_calls") or []

localcode/tools/edit_file.py

@@ -258,14 +258,22 @@ def execute(ctx: ToolContext, args: dict) -> str:
                 f"file may already be in the state you want."
             )
         path.write_text(new_content)
+        _sw = ""
+        try:
+            from .syntax_check import check_syntax
+            _e = check_syntax(str(path), new_content)
+            if _e:
+                _sw = f"\n\n⚠ SYNTAX ERROR after this edit — fix it now: {_e}"
+        except Exception:
+            _sw = ""
         diff = list(difflib.unified_diff(
             old_content.splitlines(keepends=True),
             new_content.splitlines(keepends=True),
             fromfile=args["path"], tofile=args["path"], lineterm="",
         ))
         if diff:
-            return "\n".join(diff[:60])
-        return f"Edited {args['path']} ({count} replacement{'s' if count != 1 else ''})"
+            return "\n".join(diff[:60]) + _sw
+        return f"Edited {args['path']} ({count} replacement{'s' if count != 1 else ''}){_sw}"
 
     # ── Tier 2: strip Read-output line-number prefixes from old_string ──
     stripped = _strip_read_prefix(old)

localcode/tools/multi_edit.py

@@ -98,6 +98,14 @@ def execute(ctx: ToolContext, args: dict) -> str:
         return f"Error: no-op multi_edit on {args['path']}; applied 0/{len(edits)}."
 
     path.write_text(content)
+    _sw = ""
+    try:
+        from .syntax_check import check_syntax
+        _e = check_syntax(str(path), content)
+        if _e:
+            _sw = f"\n\n⚠ SYNTAX ERROR after these edits — fix it now: {_e}"
+    except Exception:
+        _sw = ""
     diff = list(difflib.unified_diff(
         original.splitlines(keepends=True),
         content.splitlines(keepends=True),
@@ -105,8 +113,8 @@ def execute(ctx: ToolContext, args: dict) -> str:
     ))
     head = f"Applied {len(prepared)}/{len(edits)} edits to {args['path']}"
     if diff:
-        return head + "\n" + "\n".join(diff[:120])
-    return head
+        return head + "\n" + "\n".join(diff[:120]) + _sw
+    return head + _sw
 
 
 def _find_all(text: str, needle: str) -> list[int]:

localcode/tools/read_file.py

@@ -32,12 +32,52 @@ SCHEMA = {
 }
 
 
+def _suggest_path(missing) -> str:
+    """Suggest the real file when the model gave a typo'd/wrong-case path.
+
+    Walk up to the nearest existing ancestor dir and fuzzy-match the missing
+    filename (and its path segments) against what's actually there.
+    """
+    import difflib
+    from pathlib import Path
+    try:
+        missing = Path(missing)
+        name = missing.name
+        # Nearest existing ancestor to search in.
+        base = missing.parent
+        for _ in range(6):
+            if base.exists():
+                break
+            base = base.parent
+        if not base.exists():
+            return ""
+        candidates = []
+        for p in base.rglob("*"):
+            if p.is_file():
+                candidates.append(p)
+            if len(candidates) > 4000:
+                break
+        names = [p.name for p in candidates]
+        close = difflib.get_close_matches(name, names, n=1, cutoff=0.6)
+        if close:
+            match = next(p for p in candidates if p.name == close[0])
+            return f"Did you mean: {match} — read THAT exact path (don't guess variants)."
+    except Exception:
+        pass
+    return ""
+
+
 def execute(ctx: ToolContext, args: dict) -> str:
     if "path" not in args:
         return "Error: 'path' argument is required for read_file."
     path = ctx.repo / args["path"]
     if not path.exists():
-        return f"File not found: {args['path']}"
+        # A small model invents misspelled/wrong-case paths ("Aki" for "Anki",
+        # gitHub/github/Github) and, getting a bare "not found", retries with
+        # ANOTHER wrong variant forever (dedup can't collapse differing typos).
+        # Point it at the real nearby file so it corrects instead of guessing.
+        hint = _suggest_path(path)
+        return f"File not found: {args['path']}" + (f"\n{hint}" if hint else "")
     content = path.read_text(errors="replace")
     lines = content.splitlines()
     offset = args.get("offset", 0)

localcode/tools/syntax_check.py

@@ -0,0 +1,133 @@
+"""One-shot syntax validation for files the agent writes.
+
+Poor-man's LSP. The big agents (Claude Code, opencode) run a persistent
+language server and feed its diagnostics back after each edit; codex uses
+verified structured patches. A persistent LSP is too heavy for localcode's
+target — a 16 GB Mac already running a large local model. So instead we run a
+FAST, ONE-SHOT syntax check after each write and, if it fails, append the exact
+error to the tool result.
+
+Why this matters for a LOCAL model specifically: a small quantized model drifts
+into structural typos (`useState(0]`, an unterminated string, a missing bracket,
+`getCardsForCard`). With no verification the model has to NOTICE its own typo —
+which weak models are bad at — so it re-reads the broken file, the broken code
+enters its context, and it reproduces the error (self-conditioning loop). A
+deterministic check gives it GROUND TRUTH ("line 37: unexpected token") so it
+fixes the exact line instead of guessing.
+
+Best-effort and non-blocking: the write ALWAYS succeeds; this only appends a
+warning. Any checker failure/absence returns None (no false alarms). Disable
+with LOCALCODE_SYNTAX_CHECK=0.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+
+_TIMEOUT = 5.0
+
+
+def check_syntax(path: str, content: str) -> str | None:
+    """Return a one-line syntax-error string, or None if OK / not checkable.
+
+    In-process for JSON/Python (instant, zero deps); a fast one-shot subprocess
+    for JS (node --check) and TS/JSX (esbuild, when the project has it).
+    """
+    if os.environ.get("LOCALCODE_SYNTAX_CHECK") == "0":
+        return None
+    ext = os.path.splitext(path)[1].lower()
+    try:
+        if ext == ".json":
+            return _check_json(content)
+        if ext in (".py", ".pyi"):
+            return _check_python(content, path)
+        if ext in (".js", ".mjs", ".cjs"):
+            return _check_node(path)
+        if ext in (".ts", ".tsx", ".jsx", ".mts", ".cts"):
+            return _check_esbuild(path)
+    except Exception:
+        return None
+    return None
+
+
+def _check_json(content: str) -> str | None:
+    try:
+        json.loads(content)
+        return None
+    except json.JSONDecodeError as e:
+        return f"JSON syntax error at line {e.lineno} col {e.colno}: {e.msg}"
+
+
+def _check_python(content: str, path: str) -> str | None:
+    try:
+        compile(content, path, "exec")
+        return None
+    except SyntaxError as e:
+        loc = f"line {e.lineno}" + (f" col {e.offset}" if e.offset else "")
+        return f"Python syntax error at {loc}: {e.msg}"
+
+
+def _check_node(path: str) -> str | None:
+    import shutil
+    if not shutil.which("node"):
+        return None
+    r = subprocess.run(
+        ["node", "--check", path],
+        capture_output=True, text=True, timeout=_TIMEOUT,
+    )
+    if r.returncode != 0:
+        return _first_error_line(r.stderr)
+    return None
+
+
+def _find_bin(start: str, name: str) -> str | None:
+    """Walk up from the file's dir to find node_modules/.bin/<name>."""
+    d = os.path.dirname(os.path.abspath(start))
+    for _ in range(25):
+        cand = os.path.join(d, "node_modules", ".bin", name)
+        if os.path.exists(cand):
+            return cand
+        parent = os.path.dirname(d)
+        if parent == d:
+            break
+        d = parent
+    return None
+
+
+def _check_esbuild(path: str) -> str | None:
+    # esbuild parses TS/TSX/JSX and reports syntax errors instantly. Only used
+    # when the project has it (Vite/most JS projects do post-install); if not
+    # present we skip rather than risk a false alarm from a wrong parser.
+    esbuild = _find_bin(path, "esbuild")
+    if not esbuild:
+        return None
+    loader = "tsx" if path.endswith((".tsx", ".jsx")) else "ts"
+    r = subprocess.run(
+        [esbuild, path, f"--loader={loader}", "--log-level=error"],
+        capture_output=True, text=True, timeout=_TIMEOUT,
+    )
+    if r.returncode != 0 and r.stderr.strip():
+        return _first_error_line(r.stderr)
+    return None
+
+
+def _first_error_line(stderr: str) -> str | None:
+    """Pull the human-meaningful error out of a node/esbuild stderr dump.
+
+    Prefer the actual `SyntaxError: …` / `error: …` message, skipping node's
+    internal loader/stack frames (`node:internal/…`, `    at …`).
+    """
+    lines = [l.rstrip() for l in stderr.splitlines()]
+    # First choice: the real error message line.
+    for s in lines:
+        t = s.strip()
+        if t.startswith(("SyntaxError", "TypeError", "ReferenceError")) or " error:" in t.lower() or t.lower().startswith("error"):
+            return t[:200]
+    # Fallback: the "file:line" location node prints first (skip internals/stack).
+    for s in lines:
+        t = s.strip()
+        if not t or t.startswith(("node:internal", "at ", "^")):
+            continue
+        return t[:200]
+    return None

localcode/tools/write_file.py

@@ -199,6 +199,18 @@ def execute(ctx: ToolContext, args: dict) -> str:
     lines = content.count("\n") + 1
     verb = "Rewrote" if existed else "Created"
 
+    # Deterministic syntax check (poor-man's LSP): if the just-written file has
+    # a syntax error, surface the EXACT error so the model fixes that line next
+    # round instead of re-reading the broken file and drifting. See syntax_check.
+    _syntax_warning = ""
+    try:
+        from .syntax_check import check_syntax
+        _err = check_syntax(str(path), content)
+        if _err:
+            _syntax_warning = f"\n\n⚠ SYNTAX ERROR in this file — fix it now: {_err}"
+    except Exception:
+        _syntax_warning = ""
+
     # Emit a unified diff for rewrites of existing files so the TUI draws the
     # diff card. New files (or unchanged rewrites) keep the concise summary —
     # a full new-file dump as "+" lines is noise, and the summary reads fine.
@@ -210,5 +222,5 @@ def execute(ctx: ToolContext, args: dict) -> str:
             fromfile=args["path"], tofile=args["path"], lineterm="",
         ))
         if diff:
-            return "\n".join(diff[:120])
-    return f"{verb} {args['path']} ({lines} lines)"
+            return "\n".join(diff[:120]) + _syntax_warning
+    return f"{verb} {args['path']} ({lines} lines){_syntax_warning}"

{localcode-0.3.5.dist-info → localcode-0.3.7.dist-info}/METADATA

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

{localcode-0.3.5.dist-info → localcode-0.3.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-localcode/__init__.py,sha256=1BYETer-qr6n0hQRQuRG08uTZrtp262X5k87-OyEhp0,49
+localcode/__init__.py,sha256=7scw5ecMd3F-dCMkmY63HI0FKsdj4ANkgybevu64WuQ,49
 localcode/__main__.py,sha256=_4Tblte9F1KOpB-oGBQuTlaSN-IncLmhihqhBkpH3pU,69
 localcode/_subproc_env.py,sha256=eltq_kKvqGj22pIFivB5BZft9-s5fziBW0lsV9FhEV4,2383
 localcode/app.py,sha256=FSwpce6Jfn7zJmhL1ipaqTq0xKh0MxCMnEnMQuFV8L8,67820
@@ -71,12 +71,12 @@ localcode/agent/context.py,sha256=adV_WlFBHMDHsWdndRgrkZqRweDD9plyqMP_2X74WAw,37
 localcode/agent/goal.py,sha256=X87Q3rsdp70wOfkpbh35M4qFWSNyklX3RuRWjv-pCXs,6264
 localcode/agent/helpers.py,sha256=vutFyCtnca0UnF0wgk7LdsqVWdiqyYm4YnFOxtnCJ_A,15004
 localcode/agent/hooks.py,sha256=XadEbSM7gHtKlLrqSKnvcQFcoWoNUXdlMdIPS-EwBGA,15841
-localcode/agent/loop.py,sha256=2O2iKFsCQmr1CoQq40Ls_NeBs7tFgcDVfkU8YhqXXdM,99864
+localcode/agent/loop.py,sha256=VcD7fjkoJtx8pECsL2tp-pMSom5qOkec1fy9nDgj3EE,99760
 localcode/agent/prompt_context.py,sha256=abJPLMhTzuVcsW4AfMBIW-SEqmrU69DhI-0vGZllZVU,13707
 localcode/agent/prompts.py,sha256=LCJBM2mV_SKc1OXtH0-ih9OPQnhrTh3vTlrOgLUiVDA,14845
-localcode/agent/recovery.py,sha256=oCghDm9BdHhvl98Kx8EikNuxSk4Geh-0cgAEhTpH-sw,16738
+localcode/agent/recovery.py,sha256=-2vnYhhUGZD_reR6CaMOYNsG5XRf6YDsjTqF-1P-St4,16831
 localcode/agent/sections.py,sha256=9hnwaNritQHgn7qIGFBZ3ChZgMQXQcqtmpdbR1wafA0,8998
-localcode/agent/streaming.py,sha256=TEcKbmKfDGV1razrV-ceVrvIIxvS-GmLWGNDnF0gSTA,12872
+localcode/agent/streaming.py,sha256=tW3LxUJlUyh3vRzeUsEo8lQcbc3DBvRtWF_2VLLQ9H8,11331
 localcode/agent/tool_execution.py,sha256=yfWZwOO3f5ICd2eqw6keg8sOKOIa3vFt4peFinmu5nM,14462
 localcode/agent/tool_orchestration.py,sha256=LVKNNHg59XLBlakz8J3zCwubXoWDiaXum8AS7HXB0sE,1711
 localcode/agent/turn_finalization.py,sha256=n5h0aA_EPDS8ZY6TBvbUo7qu2IkgEwnwcO0PKBd6930,4884
@@ -101,20 +101,21 @@ localcode/tools/append_file.py,sha256=GNjPBnnV7hpD32u0Jx6YxRmsOSr4uwvJgIcInH1qhS
 localcode/tools/base.py,sha256=2QV-q1DzXWM4KL9mFKNPzlBiLOS2uKLXhlgGyeWEKCI,2064
 localcode/tools/bash.py,sha256=Yuuxo0lsX0JuFbHQX8OflmgZgq7uqBc1FUSGJRHlsB8,43380
 localcode/tools/edit_diff.py,sha256=eJ1FyK3HecAmJNiM-XdHOQ7WCkyOuD6hwAlTVgYQGGk,3017
-localcode/tools/edit_file.py,sha256=DhhQSi6wnD4_IwLEYoC-zBLUPaxhihZxBatNoerFLe4,13455
+localcode/tools/edit_file.py,sha256=YiUuw08kVw1qiClgsTmfi8W-RkH42cFqV9BvYfvzVcA,13750
 localcode/tools/facts.py,sha256=OqTLYOclKy6lpPQiU3aDrzY-Ho-jhWc8mvzLx6TFRCk,5576
 localcode/tools/glob_tool.py,sha256=8Gilud4U6lDZ_bASRbBeVndWzNImtf-jydNl3KQkpmY,1084
 localcode/tools/grep.py,sha256=OP2P_J8fRz3qIJWp3--t1avq2K4HXjVENsOVXJDhLEU,1695
 localcode/tools/launch_app.py,sha256=TVoq1ZQEIm2yQ607LGkJwbIC3TkvaLsBpTJgYIGX1gM,3357
 localcode/tools/list_files.py,sha256=wN2dXU01rrKB_HGh6i0GfM9qvBwx7Qoa3S5WZlArma0,1205
-localcode/tools/multi_edit.py,sha256=bT9OROgwTAZ1gKHE6DnpOU6_EBzLcDiisxXDnkwlyEg,4518
+localcode/tools/multi_edit.py,sha256=WkGibiGkr_J-Ld4CtxR24icdy1kGQuPEh6kKDrKe8Ss,4780
 localcode/tools/plan_mode.py,sha256=2RU6QH1IJoOTKuoAr7Ga7uTaebAS8v7OFt5v1zLEXFw,2886
-localcode/tools/read_file.py,sha256=u8ZySkvSj-ZzPVSdi1ybZ6yTgZ-yXiqAW54ZVdZWf-g,3017
+localcode/tools/read_file.py,sha256=gH852nnPiVD2Go9VcdS_EFbtnqYaGOPyAk5jo1cNbX8,4556
 localcode/tools/skill_tool.py,sha256=vTVPyRWxICtDCVYWMiAMInGnc-wGAk2L1EZn-6e79nE,1478
+localcode/tools/syntax_check.py,sha256=wojE6Ke6nMe3ptyh9T7zLp5roGKYaez3TwSpnp8nE8A,4869
 localcode/tools/todo_write.py,sha256=8A4k9MzoqOtzJ6y2Gd3lEGkINcpV3JVCd2lYBmdd6qI,5801
 localcode/tools/web_fetch.py,sha256=UPhMrLipwN5xJx5-zr634gL4p6nIRqYI2_7tbUw_8Go,2770
 localcode/tools/web_search.py,sha256=ILfBBx50p00OjA939HzdDmdao4QLL8sRuxlBoUDjmC8,1122
-localcode/tools/write_file.py,sha256=2rfbp0j_ApHuk8fUAopMl6H1BIyEMKWKXjZ__xrY6oI,9743
+localcode/tools/write_file.py,sha256=gjlNkVy9xw9q9eGWc5jY0l3iFN3zciKTztk8W25EHa0,10308
 localcode/tui/__init__.py,sha256=Yfy9bvw3l1iY4FDhRX8qZVgnZLuYiq8lc9SDYl4cWwc,61
 localcode/tui/app.py,sha256=KjQzpGKnxkgh-0kVc3zcb63Q6a5LBuGreBqTUrasiqM,17700
 localcode/tui/bridge.py,sha256=urPPCqC_nisAYawWk3juvMI8IaoJfv4g7USpGOZOqQc,2803
@@ -131,9 +132,9 @@ localcode/tui/widgets/chat_log.py,sha256=D5DUkrQXL_ilxyC8N1xIPLw4Pqeh0jSWt1mPgho
 localcode/tui/widgets/voice_visualizer.py,sha256=zOhrIxaMcg-F2Y8LvHJTddq227phmiTjtEyRbkx1XxU,4709
 localcode/tui/widgets/messages/__init__.py,sha256=952AZ1qVMGUIqPIry7mwxnYbMkgPlcY5FAwZtEa5YPg,967
 localcode/tui/widgets/messages/diff.py,sha256=khDf_MThrQz0S62-t-m7i3OU5cdNolUk1TCeKMRPDQI,10910
-localcode-0.3.5.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
-localcode-0.3.5.dist-info/METADATA,sha256=F80qNJ73o16hDwmaZzV6e9B-EGuc3ARhiHgwg_P0HDo,7813
-localcode-0.3.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-localcode-0.3.5.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
-localcode-0.3.5.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
-localcode-0.3.5.dist-info/RECORD,,
+localcode-0.3.7.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
+localcode-0.3.7.dist-info/METADATA,sha256=Qg7wa61uxkFvD8SkVHWHQ1kEzZmnlK6H8e_SFlzm-0o,7813
+localcode-0.3.7.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+localcode-0.3.7.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
+localcode-0.3.7.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
+localcode-0.3.7.dist-info/RECORD,,