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

localcode/__init__.py

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

localcode/agent/loop.py

@@ -1240,24 +1240,44 @@ def run_agent_loop(
                 and not ran_build_or_test(bash_history)
             ):
                 _build_verify_nudges += 1
+                # TIER-2 VERIFICATION: don't just NUDGE the model to typecheck
+                # (a small model skips it or mishandles output) — RUN the
+                # project's real typecheck/lint ourselves and feed the concrete
+                # errors back. Catches semantic errors (wrong names, missing
+                # imports) the per-write syntax check can't. Light: once per
+                # turn, at completion. See tools.project_check.
+                _proj_errors = None
+                try:
+                    from ..tools.project_check import run_project_check
+                    out.print_info("Verifying — running the project's typecheck…")
+                    _proj_errors = run_project_check(str(app.repo_root))
+                except Exception:
+                    _proj_errors = None
                 try:
                     from ..events import emit as _emit_bg
-                    _emit_bg("auto_nudge", signal="build_unverified", round_idx=round_num)
+                    _emit_bg("auto_nudge", signal="build_unverified",
+                             round_idx=round_num, had_errors=bool(_proj_errors))
                 except Exception:
                     pass
-                out.print_info(
-                    "Changed code but never built/ran it — nudging it to build "
-                    "and fix before finishing."
-                )
-                messages.append({"role": "user", "content": (
-                    "SYSTEM: You changed code but never built, type-checked, or ran "
-                    "it this turn. Run the project's build/typecheck now (e.g. "
-                    "`npm run build` or `npx tsc --noEmit` for TypeScript; the test "
-                    "command or an import smoke-check for Python), FIX every error it "
-                    "reports, then finish. Do not claim it works without building it."
-                )})
+                if _proj_errors:
+                    out.print_info("Typecheck found errors — sending them back to fix.")
+                    messages.append({"role": "user", "content": (
+                        "SYSTEM: the project's typecheck/build was run for you and "
+                        "reported errors. FIX each one (targeted edit_file changes), "
+                        "then finish. Do not claim it works until these are gone:\n\n"
+                        + _proj_errors
+                    )})
+                else:
+                    # No checker available, or it passed — fall back to advising.
+                    out.print_info("Changed code but never built/ran it — nudging to verify.")
+                    messages.append({"role": "user", "content": (
+                        "SYSTEM: You changed code but never built, type-checked, or ran "
+                        "it. Run the project's build/typecheck (npm run build / npx tsc "
+                        "--noEmit for TS; tests or an import smoke-check for Python), fix "
+                        "every error, then finish. Don't claim it works without building."
+                    )})
                 _ephemeral_nudge_indices.append(len(messages) - 1)
-                continue  # don't accept completion — let it build + fix first
+                continue  # don't accept completion — let it fix first
             if _goal_state.goal_type == "run_or_launch":
                 _task_port = int(getattr(_task_state, "active_port", 0) or 0)
                 content = ground_run_or_launch_text(content, _task_port)

localcode/tools/project_check.py

@@ -0,0 +1,118 @@
+"""Tier-2 verification: run the project's OWN typecheck/lint once, return errors.
+
+The big agents catch semantic errors with a persistent language server (LSP).
+opencode's own docs say that for many projects it's better to run the project's
+diagnostic CLI directly — LSPs "get out of sync, use significant memory … and
+slow down agent workflows." That's decisive for localcode: a 16 GB Mac already
+running a large local model can't spare an always-on tsserver/pyright.
+
+So instead we run the project's real typecheck ONCE, when the model is about to
+finish an unverified build, and feed the concrete errors back deterministically
+(the model can't skip it, and gets ground truth like "line 37: 'getCardsForCard'
+does not exist" — the semantic errors a per-write syntax check can't catch).
+
+Light: one bounded subprocess at completion, not per-edit. Returns None when the
+project is clean or no checker is available.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+
+_TIMEOUT = 60.0
+_MAX_ERR_CHARS = 2500
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def run_project_check(repo_root: str) -> str | None:
+    """Run the first available typecheck/lint for the project; return a bounded
+    error summary, or None if clean / nothing to run."""
+    env = {**os.environ, "NO_COLOR": "1", "FORCE_COLOR": "0"}
+    for label, argv, cwd in _detect_commands(repo_root):
+        try:
+            r = subprocess.run(
+                argv, cwd=cwd, capture_output=True, text=True,
+                timeout=_TIMEOUT, env=env,
+            )
+        except Exception:
+            continue
+        if r.returncode != 0:
+            out = _ANSI.sub("", ((r.stdout or "") + "\n" + (r.stderr or "")).strip())
+            # Keep only the most useful lines, capped, so we don't flood a
+            # small model's context with a wall of output.
+            lines = [l for l in out.splitlines() if l.strip()][:40]
+            if lines:
+                return f"[{label}] reported errors:\n" + "\n".join(lines)[:_MAX_ERR_CHARS]
+    return None
+
+
+def _detect_commands(repo_root: str) -> list[tuple[str, list[str], str]]:
+    """Ordered (label, argv, cwd) checkers to try. First that runs wins."""
+    cmds: list[tuple[str, list[str], str]] = []
+
+    # ── JS / TS ── prefer a project "typecheck" script, else tsc --noEmit.
+    pj_dir = _nearest_with(repo_root, "package.json")
+    if pj_dir:
+        node_modules = os.path.join(pj_dir, "node_modules")
+        binp = os.path.join(node_modules, ".bin")
+        scripts = {}
+        try:
+            scripts = (json.load(open(os.path.join(pj_dir, "package.json"))) or {}).get("scripts", {})
+        except Exception:
+            scripts = {}
+        # Only run node-based checks once deps are installed (else every import
+        # is a false "cannot find module" error that would derail the model).
+        if os.path.isdir(node_modules):
+            if "typecheck" in scripts:
+                cmds.append(("npm run typecheck", ["npm", "run", "--silent", "typecheck"], pj_dir))
+            elif os.path.exists(os.path.join(pj_dir, "tsconfig.json")) and os.path.exists(os.path.join(binp, "tsc")):
+                cmds.append(("tsc --noEmit", [os.path.join(binp, "tsc"), "--noEmit", "--pretty", "false"], pj_dir))
+            elif "lint" in scripts:
+                cmds.append(("npm run lint", ["npm", "run", "--silent", "lint"], pj_dir))
+
+    # ── Python ── ruff for REAL errors only (E9 syntax + F pyflakes: undefined
+    # names, bad imports) — not style noise. Falls back to compileall (syntax).
+    if _has_ext(repo_root, ".py"):
+        if shutil.which("ruff"):
+            cmds.append(("ruff", ["ruff", "check", "--select", "E9,F",
+                                  "--no-cache", "--output-format", "concise", "."], repo_root))
+        elif shutil.which("python3") or shutil.which("python"):
+            py = shutil.which("python3") or shutil.which("python")
+            cmds.append(("python -m compileall", [py, "-m", "compileall", "-q", "."], repo_root))
+
+    # ── Go ── the compiler catches type/undefined errors (like tsc). go.mod.
+    go_dir = _nearest_with(repo_root, "go.mod")
+    if go_dir and shutil.which("go"):
+        cmds.append(("go build", ["go", "build", "./..."], go_dir))
+
+    # ── Rust ── cargo check is the type-checker (fast, no codegen). Cargo.toml.
+    rust_dir = _nearest_with(repo_root, "Cargo.toml")
+    if rust_dir and shutil.which("cargo"):
+        cmds.append(("cargo check", ["cargo", "check", "--message-format", "short"], rust_dir))
+
+    # (Interpreted langs — Ruby/PHP/shell — have no whole-project type-check;
+    # their per-file syntax linters run in the Tier-1 syntax_check on each write.)
+    return cmds
+
+
+def _nearest_with(root: str, filename: str) -> str | None:
+    """The shallowest directory under root that contains `filename`."""
+    root = os.path.abspath(root)
+    if os.path.exists(os.path.join(root, filename)):
+        return root
+    for base, dirs, files in os.walk(root):
+        dirs[:] = [d for d in dirs if d not in (".git", "node_modules", "dist", "build", ".venv")]
+        if filename in files:
+            return base
+    return None
+
+
+def _has_ext(root: str, ext: str) -> bool:
+    for base, dirs, files in os.walk(os.path.abspath(root)):
+        dirs[:] = [d for d in dirs if d not in (".git", "node_modules", "dist", "build", ".venv")]
+        if any(f.endswith(ext) for f in files):
+            return True
+    return False

localcode/tools/syntax_check.py

@@ -1,23 +1,22 @@
-"""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.
+"""One-shot syntax validation for files the agent writes — in-process, offline.
+
+Tier-1 verification. The big agents use a persistent language server (LSP);
+opencode's own docs say that's often worse than running diagnostics directly
+(LSPs "get out of sync, use significant memory, slow down agent workflows") —
+decisive for a 16 GB Mac already running a large local model.
+
+Crucially this must work with NO tools the user has to install and NO network:
+it's bundled. We parse with tree-sitter (grammars compiled into the wheel — one
+~4.5 MB native extension covering 100+ languages) and flag any syntax error
+in-process. So when a small quantized model drifts into a structural typo
+(`useState(0]`, an unterminated string, a missing bracket), the write tool
+appends the exact error and line, and the model fixes THAT line instead of
+re-reading the broken file and reproducing the error (the self-conditioning
+loop). Python/JSON keep their native checkers for sharper messages.
+
+Semantic/type errors (wrong names, missing imports) are caught separately by
+project_check at completion (tsc/ruff/go/cargo). Disable with
+LOCALCODE_SYNTAX_CHECK=0.
 """
 from __future__ import annotations
 
@@ -27,25 +26,34 @@ import subprocess
 
 _TIMEOUT = 5.0
 
+# File extension → tree-sitter language name (all bundled in the language pack).
+_TS_LANG = {
+    ".js": "javascript", ".mjs": "javascript", ".cjs": "javascript",
+    ".jsx": "tsx", ".ts": "typescript", ".mts": "typescript", ".cts": "typescript",
+    ".tsx": "tsx", ".go": "go", ".rs": "rust", ".rb": "ruby", ".php": "php",
+    ".sh": "bash", ".bash": "bash", ".zsh": "bash", ".lua": "lua",
+    ".c": "c", ".h": "c", ".cpp": "cpp", ".cc": "cpp", ".cxx": "cpp",
+    ".hpp": "cpp", ".hh": "cpp", ".java": "java", ".kt": "kotlin",
+    ".swift": "swift", ".cs": "csharp", ".scala": "scala",
+    ".css": "css", ".scss": "scss", ".html": "html", ".xml": "xml",
+    ".yaml": "yaml", ".yml": "yaml", ".toml": "toml", ".sql": "sql",
+}
 
-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).
-    """
+def check_syntax(path: str, content: str) -> str | None:
+    """Return a one-line syntax-error string, or None if OK / not checkable."""
     if os.environ.get("LOCALCODE_SYNTAX_CHECK") == "0":
         return None
     ext = os.path.splitext(path)[1].lower()
     try:
+        # Native checkers give the sharpest messages; use them where free.
         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)
+        lang = _TS_LANG.get(ext)
+        if lang:
+            return _check_treesitter(content, lang)
     except Exception:
         return None
     return None
@@ -68,66 +76,47 @@ def _check_python(content: str, path: str) -> str | None:
         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 _check_treesitter(content: str, lang: str) -> str | None:
+    """Parse with a bundled tree-sitter grammar; report the first syntax error.
 
-
-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 …`).
+    No external tools, no network — the grammars are compiled into the wheel.
+    Returns None if tree-sitter isn't available (graceful) or the file parses.
     """
-    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]
+    try:
+        from tree_sitter_language_pack import get_language
+        from tree_sitter import Parser
+    except Exception:
+        return None
+    try:
+        parser = Parser(get_language(lang))
+        tree = parser.parse(content.encode("utf-8"))
+    except Exception:
+        return None
+    root = tree.root_node
+    if not root.has_error:
+        return None
+    node = _first_error_node(root)
+    if node is None:
+        return f"syntax error detected in this {lang} file (unbalanced brackets/quotes or a stray token)"
+    line = node.start_point[0] + 1
+    col = node.start_point[1] + 1
+    snippet = ""
+    try:
+        src_line = content.splitlines()[node.start_point[0]].strip()
+        snippet = f" — near: {src_line[:80]}"
+    except Exception:
+        snippet = ""
+    kind = "missing token" if node.is_missing else "unexpected token"
+    return f"syntax error (line {line} col {col}): {kind}{snippet}"
+
+
+def _first_error_node(root):
+    """DFS for the first ERROR or MISSING node (the actual syntax fault)."""
+    stack = [root]
+    while stack:
+        n = stack.pop()
+        if n.is_error or n.is_missing:
+            return n
+        # push children in order so we return the earliest error
+        stack.extend(reversed(n.children))
     return None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.7
+Version: 0.3.9
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -35,6 +35,8 @@ Requires-Dist: prompt_toolkit>=3.0.52
 Requires-Dist: rich>=13.7.1
 Requires-Dist: scikit-learn>=1.3.0
 Requires-Dist: textual>=8.2.4
+Requires-Dist: tree-sitter>=0.23.0
+Requires-Dist: tree-sitter-language-pack>=1.0.0
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Provides-Extra: voice
 Requires-Dist: pywhispercpp>=1.2.0; extra == "voice"

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

@@ -1,4 +1,4 @@
-localcode/__init__.py,sha256=7scw5ecMd3F-dCMkmY63HI0FKsdj4ANkgybevu64WuQ,49
+localcode/__init__.py,sha256=dv_OdIY5KS_HiRjBMSmtKnar5Axf3OVYIDjhWUodlAY,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,7 +71,7 @@ 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=VcD7fjkoJtx8pECsL2tp-pMSom5qOkec1fy9nDgj3EE,99760
+localcode/agent/loop.py,sha256=Gp4Zt0fRpQkE1YLZjrF9xtzM4qlJodyFeGGupx_U16k,101105
 localcode/agent/prompt_context.py,sha256=abJPLMhTzuVcsW4AfMBIW-SEqmrU69DhI-0vGZllZVU,13707
 localcode/agent/prompts.py,sha256=LCJBM2mV_SKc1OXtH0-ih9OPQnhrTh3vTlrOgLUiVDA,14845
 localcode/agent/recovery.py,sha256=-2vnYhhUGZD_reR6CaMOYNsG5XRf6YDsjTqF-1P-St4,16831
@@ -109,9 +109,10 @@ localcode/tools/launch_app.py,sha256=TVoq1ZQEIm2yQ607LGkJwbIC3TkvaLsBpTJgYIGX1gM
 localcode/tools/list_files.py,sha256=wN2dXU01rrKB_HGh6i0GfM9qvBwx7Qoa3S5WZlArma0,1205
 localcode/tools/multi_edit.py,sha256=WkGibiGkr_J-Ld4CtxR24icdy1kGQuPEh6kKDrKe8Ss,4780
 localcode/tools/plan_mode.py,sha256=2RU6QH1IJoOTKuoAr7Ga7uTaebAS8v7OFt5v1zLEXFw,2886
+localcode/tools/project_check.py,sha256=B3Q6IB2XfllW3Nlxwz2pCCQwF_b0VSUBnrpCHS4eOE8,5508
 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/syntax_check.py,sha256=tpymYFeXs7LYU5qmfHGJeVX0WUdFYBineI9GN3jONYU,4726
 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
@@ -132,9 +133,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.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,,
+localcode-0.3.9.dist-info/licenses/LICENSE,sha256=Ahg0cteZ-6bIRB7KC15WEtdqWnzy8HY_yzsZBoVRql0,11294
+localcode-0.3.9.dist-info/METADATA,sha256=iT5SYY0r4-zju8UthKU8MTPF4w_3HRk0H11CIB_8dQ0,7896
+localcode-0.3.9.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+localcode-0.3.9.dist-info/entry_points.txt,sha256=rE7elTGUvMsBd-Quy22cuTVJ-zGVOmx0nEuC6ni9Tg4,87
+localcode-0.3.9.dist-info/top_level.txt,sha256=58eL3Rw8v0OGmYNxjx8uS4ERWatrzUbyCL5inlukkTo,10
+localcode-0.3.9.dist-info/RECORD,,