localcode 0.3.4__tar.gz → 0.3.6__tar.gz

{localcode-0.3.4/src/localcode.egg-info → localcode-0.3.6}/PKG-INFO

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

{localcode-0.3.4 → localcode-0.3.6}/pyproject.toml

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

{localcode-0.3.4 → localcode-0.3.6}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"

{localcode-0.3.4 → localcode-0.3.6}/src/localcode/agent/loop.py

@@ -715,22 +715,22 @@ def run_agent_loop(
                     list(getattr(_tool_exec_state, "files_read", {}) or {}),
                     progress_ledger_budget_chars(_win_tokens),
                 )
-                if _ledger:
-                    model_messages = list(model_messages) + [
-                        {"role": "user", "content": _ledger}
-                    ]
             except Exception:
-                pass
-            # Inject the working-memory checklist (todo_write tool): the model
-            # always sees its own plan (done / in-progress / left) so it
-            # advances instead of repeating. Appended LAST, ephemeral, empty-safe.
+                _ledger = ""
+            # Working-memory checklist (todo_write): model sees its own plan.
+            _todo_note = ""
             try:
                 from ..tools.todo_write import render_todo_reminder
-                _todos = list(getattr(app.session, "todos", []) or [])
-                _todo_note = render_todo_reminder(_todos)
-                if _todo_note:
+                _todo_note = render_todo_reminder(list(getattr(app.session, "todos", []) or []))
+            except Exception:
+                _todo_note = ""
+            # Inject ledger + todo as ONE trailing SYSTEM message (not role:user
+            # — as a user turn the model re-greeted every round). Ephemeral.
+            try:
+                _ctx_block = "\n\n".join(b for b in (_ledger, _todo_note) if b)
+                if _ctx_block:
                     model_messages = list(model_messages) + [
-                        {"role": "user", "content": _todo_note}
+                        {"role": "system", "content": _ctx_block}
                     ]
             except Exception:
                 pass

{localcode-0.3.4 → localcode-0.3.6}/src/localcode/agent/prompts.py

@@ -164,9 +164,12 @@ def model_identity_line(model: str) -> str:
     # to its training priors otherwise answers "I'm Gemma by Google". So: lead
     # with LocalCode, disclose the model only on request.
     return (
-        f"You are LocalCode — that is your name and how you refer to yourself in "
-        f"conversation (say \"I'm LocalCode\", never lead with the model name). "
-        f"Do NOT volunteer the underlying model in greetings or ordinary replies. "
+        f"Your name is LocalCode (never lead with the underlying model name). "
+        f"Do NOT introduce or re-introduce yourself. Never begin a message with "
+        f"\"I'm LocalCode\", a greeting, or a restatement of what you're doing — "
+        f"the user already knows who you are and what the task is. Just continue "
+        f"the work: take the next action directly. Only state your name if the "
+        f"user explicitly asks who you are. "
         f"The model currently powering you is \"{friendly}\"; report it as EXACTLY "
         f"\"{friendly}\" — and only — when the user specifically asks which "
         f"model / version / quant you are, or asks to name something (a file, "

{localcode-0.3.4 → localcode-0.3.6}/src/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-0.3.4 → localcode-0.3.6}/src/localcode/memory_guard.py

@@ -209,3 +209,61 @@ def recommended_jetsam_limit_mb() -> int:
         total_mb = 16 * 1024
     reserve = 3500 if total_mb < 24 * 1024 else 6000
     return max(2048, total_mb - reserve)
+
+
+def should_disable_metal_residency(model_path: str, ctx_size: int) -> bool:
+    """Whether to set GGML_METAL_NO_RESIDENCY=1 for this launch.
+
+    Root cause of the recurring mid-stream SIGKILL (-9, no crash report, tens
+    of GB of system RAM still free): on Apple Silicon, llama.cpp's Metal
+    residency sets keep the model weights + KV cache + compute buffers WIRED
+    for ~3 minutes (ggml-metal-device.m). During a long generation the wired
+    total grows, and when a decode-step spike crosses the GPU's
+    `recommendedMaxWorkingSetSize` (~75% of RAM — a hard ceiling independent of
+    free system RAM), the kernel kills the process outright. This is the exact
+    bug class in ggml-org/llama.cpp#16646 on the same M4 Max / 128 GB hardware.
+
+    Setting GGML_METAL_NO_RESIDENCY=1 makes those buffers EVICTABLE instead of
+    wired, so the OS pages under pressure rather than killing — turning a hard
+    crash into (at worst) mild slowdown, and only when actually near the cap.
+
+    Gated to at-risk launches so the common small-context fast path is
+    untouched: large context (>=128K, where KV + compute-buffer growth is the
+    trigger) OR a model whose weights alone are a large fraction of the wired
+    cap. No user action, no sudo — we control the spawn env.
+    """
+    try:
+        r = subprocess.run(["sysctl", "-n", "hw.memsize"],
+                           capture_output=True, text=True, timeout=2)
+        total_mb = int(r.stdout.strip()) // (1024 * 1024)
+    except Exception:
+        return False
+    # Metal's wired ceiling is ~75% of physical RAM.
+    wired_cap_mb = int(total_mb * 0.75)
+    if ctx_size >= 131072:
+        return True
+    try:
+        import os as _os
+        model_mb = _os.path.getsize(model_path) // (1024 * 1024)
+    except Exception:
+        model_mb = 0
+    # Weights alone over ~55% of the wired cap → KV + compute will breach it.
+    return model_mb > int(wired_cap_mb * 0.55)
+
+
+def metal_residency_env(model_path: str, cmd: list) -> dict:
+    """Return {GGML_METAL_NO_RESIDENCY: '1'} when this launch is at risk of the
+    wired-cap SIGKILL, else {}. macOS-only; parses --ctx-size from the command.
+    """
+    import sys as _sys
+    if _sys.platform != "darwin":
+        return {}
+    ctx = 0
+    for i, tok in enumerate(cmd):
+        if tok == "--ctx-size" and i + 1 < len(cmd):
+            try:
+                ctx = int(cmd[i + 1])
+            except Exception:
+                ctx = 0
+            break
+    return {"GGML_METAL_NO_RESIDENCY": "1"} if should_disable_metal_residency(model_path, ctx) else {}

{localcode-0.3.4 → localcode-0.3.6}/src/localcode/server_manager.py

@@ -299,12 +299,10 @@ class ServerManager:
         self._lock = threading.Lock()
         self._last_exit_code: Optional[int] = None  # disconnect diagnostics
         self._last_death_was_pressure: bool = False
-        # Idle auto-suspend: track wall-clock of the most recent chat
-        # activity. A background watchdog thread shuts the server down
-        # after `_idle_timeout_s` seconds of inactivity to stop the GPU
-        # from cooking the laptop while the user is reading replies.
-        # The next chat call transparently respawns via _restart_server.
-        # 0 disables; default 10 min. Override with env LOCALCODE_IDLE_SUSPEND_S.
+        # Idle auto-suspend: a watchdog shuts the server down after
+        # `_idle_timeout_s` of inactivity (stops the GPU cooking the laptop
+        # while the user reads); the next chat call respawns via
+        # _restart_server. 0 disables; default 10 min. Env: LOCALCODE_IDLE_SUSPEND_S.
         import os as _os
         try:
             self._idle_timeout_s: float = float(
@@ -394,10 +392,8 @@ class ServerManager:
             _prev_model = self._model_path  # capture before shutdown clears it
             self._shutdown_locked()
             # Wait for the OLD server's memory to release before spawning the
-            # new one: the kernel takes 1-3 s to free wired Metal memory after
-            # the child reaps, and spawning into that window double-commits and
-            # trips the pressure monitor on a 16 GB Mac. Best-effort — targets
-            # ~11 GB free, times out at 8 s, proceeds anyway.
+            # new one (kernel takes 1-3 s to free wired Metal memory; spawning
+            # into that window double-commits). Best-effort: ~11 GB target, 8 s.
             if had_prior:
                 # Only a genuine model change is "model_switch"; a same-model
                 # relaunch (crash/disconnect recovery) is "server_restart".
@@ -422,6 +418,15 @@ class ServerManager:
             # AGX driver may read the env at first Metal touch — setting it in
             # the parent env before spawn is the belt-and-suspenders approach.
             env.setdefault("AGX_RELAX_CDM_CTXSTORE_TIMEOUT", "1")
+            # Disable Metal residency sets on at-risk launches → prevents the wired-cap SIGKILL.
+            try:
+                from .memory_guard import metal_residency_env
+                _renv = metal_residency_env(str(model_path), cmd)
+                if _renv:
+                    env.update(_renv)
+                    _lifecycle_log("metal_no_residency", model=str(model_path))
+            except Exception:
+                pass
             # Capture the server's OWN stdout/stderr to server.log (this runtime
             # path used to send both to /dev/null, discarding llama-server's
             # final ggml/Metal error on the recurring -9). Append per-spawn.
@@ -461,11 +466,10 @@ class ServerManager:
             except Exception:
                 pass
 
-            # Layer 2: userspace memory-pressure monitor. Polls
-            # kern.memorystatus_vm_pressure_level every 500 ms; on WARN
-            # transition, SIGTERMs our server before the kernel stalls.
-            # Complementary to the jetsam ceiling — acts on system-wide
-            # pressure (everything else swelling) not just our own RSS.
+            # Layer 2: userspace pressure monitor — polls
+            # kern.memorystatus_vm_pressure_level every 500 ms and SIGTERMs our
+            # server on WARN. Complements the jetsam ceiling (acts on system-
+            # wide pressure, not just our own RSS).
             try:
                 self._pressure_thread = start_pressure_monitor(
                     self._process,
@@ -474,10 +478,8 @@ class ServerManager:
             except Exception:
                 self._pressure_thread = None
             self._write_pid_file(self._process.pid)
-            # Log the FULL launch command so debugging can answer "what flags
-            # was the server using?" — subtle flags (e.g. --spec-type ngram-mod)
-            # cause repetition pathologies that look like model bugs. Truncated
-            # to 4000 chars (~80 args) to keep the event small.
+            # Log the FULL launch command (which flags was the server using?);
+            # truncated to 4000 chars (~80 args) to keep the event small.
             _flags_str = " ".join(str(c) for c in cmd)[:4000]
             _lifecycle_log("server_started", pid=self._process.pid, port=port,
                            model=Path(model_path).name,
@@ -698,10 +700,8 @@ class ServerManager:
         _lifecycle_log("pressure_kill", level=level, pid=killed_pid,
                        guard="memory_pressure", exit_code=self._last_exit_code,
                        free_mb=_system_free_memory_mb())
-        # Clear internal state so subsequent code paths see "no server
-        # running" rather than a phantom Popen handle. Safe to do from
-        # the pressure-monitor thread because `_process` reads/writes
-        # are atomic in CPython for the assignment.
+        # Clear internal state so callers see "no server" not a phantom Popen.
+        # Safe from the pressure-monitor thread (assignment is atomic in CPython).
         self._process = None
         self._model_path = None
 

{localcode-0.3.4 → localcode-0.3.6}/src/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-0.3.4 → localcode-0.3.6}/src/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-0.3.6/src/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-0.3.4 → localcode-0.3.6}/src/localcode/tools/write_file.py

@@ -173,6 +173,19 @@ def execute(ctx: ToolContext, args: dict) -> str:
     # catches the data.py-style "model copies in-memory stub back into
     # write_file" disaster, which was the one case where rejecting
     # was load-bearing.
+    # Log the EXACT content the model sent (post-JSON-parse) so a "the file is
+    # corrupted / write_file isn't writing what I sent" report is provable from
+    # logs in one grep, instead of a mystery. Best-effort, capped, append-only.
+    try:
+        from ..paths import global_state_dir
+        _wl = global_state_dir() / "write_content.log"
+        with open(_wl, "a", encoding="utf-8", errors="replace") as _fh:
+            _fh.write(f"\n===== write_file {args['path']} ({len(content)} chars) =====\n")
+            _fh.write(content[:20000])
+            _fh.write("\n")
+    except Exception:
+        pass
+
     existed = path.is_file()
     # Capture the prior content so an in-place rewrite renders as a diff card
     # (like edit_file/multi_edit), not a bare "Rewrote (N lines)" one-liner.
@@ -186,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.
@@ -197,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.4 → localcode-0.3.6/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.4 → localcode-0.3.6}/src/localcode.egg-info/SOURCES.txt

@@ -883,6 +883,7 @@ src/localcode/tools/multi_edit.py
 src/localcode/tools/plan_mode.py
 src/localcode/tools/read_file.py
 src/localcode/tools/skill_tool.py
+src/localcode/tools/syntax_check.py
 src/localcode/tools/todo_write.py
 src/localcode/tools/web_fetch.py
 src/localcode/tools/web_search.py