localcode 0.2.12.1a1__tar.gz → 0.2.13__tar.gz

{localcode-0.2.12.1a1/src/localcode.egg-info → localcode-0.2.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.2.12.1a1
+Version: 0.2.13
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -15,19 +15,21 @@ Classifier: Intended Audience :: Developers
 Classifier: Operating System :: MacOS
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Code Generators
-Requires-Python: >=3.11
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: certifi>=2024.0.0
 Requires-Dist: ddgs>=9.0.0
-Requires-Dist: hf_transfer>=0.1.9
+Requires-Dist: hf_xet>=1.1.0
 Requires-Dist: httpx>=0.27.0
-Requires-Dist: huggingface_hub>=0.25.0
+Requires-Dist: huggingface_hub>=1.0.0
 Requires-Dist: jedi>=0.19.0
 Requires-Dist: prompt_toolkit>=3.0.52
 Requires-Dist: rich>=13.7.1

{localcode-0.2.12.1a1 → localcode-0.2.13}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.2.12.1a1"
+version = "0.2.13"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.9"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
 authors = [
@@ -21,6 +21,8 @@ classifiers = [
   "Operating System :: MacOS",
   "Operating System :: POSIX :: Linux",
   "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
@@ -30,9 +32,9 @@ classifiers = [
 dependencies = [
   "certifi>=2024.0.0",
   "ddgs>=9.0.0",
-  "hf_transfer>=0.1.9",       # Rust-backed fast downloader for HuggingFace
+  "hf_xet>=1.1.0",            # Rust download backend for huggingface_hub ≥1.x (replaced hf_transfer)
   "httpx>=0.27.0",
-  "huggingface_hub>=0.25.0",  # used as the fast path for GGUF downloads
+  "huggingface_hub>=1.0.0",   # used as the fast path for GGUF downloads
   "jedi>=0.19.0",
   "prompt_toolkit>=3.0.52",
   "rich>=13.7.1",
@@ -72,13 +74,17 @@ where = ["src"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
-addopts = "-q"
+# Exclude the real-inference tier from the default run; opt in with
+# `pytest -m real_models` (a command-line -m overrides this). CI runs the
+# CI-safe glob `tests/test_comprehensive_*.py`, which doesn't include it.
+addopts = "-q -m 'not real_models'"
 # Put repo root + src on sys.path so `from tests.e2e...` and `from
 # localcode...` resolve under a bare `pytest` invocation (CI), not just
 # `python -m pytest` (which adds CWD itself).
 pythonpath = [".", "src"]
 markers = [
   "slow: heavyweight tests (real venv install, network) — opt-in, skipped by default",
+  "real_models: load a downloaded GGUF and run a real inference turn — opt-in (`-m real_models`), auto-skipped when the model file is absent (so CI skips).",
 ]
 
 [tool.ruff]

{localcode-0.2.12.1a1 → localcode-0.2.13}/setup.py

@@ -37,11 +37,6 @@ if os.environ.get("LOCALCODE_WITH_CYTHON"):
         pass
 
 
-class StripSourceBuildWheel:
-    """Remove .py and .c source files from the wheel, keeping only .so"""
-    pass
-
-
 from setuptools.command.build_py import build_py
 
 class CustomBuildPy(build_py):

{localcode-0.2.12.1a1 → localcode-0.2.13}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.2.0"
+__version__ = "0.2.13"

{localcode-0.2.12.1a1 → localcode-0.2.13}/src/localcode/agent/__init__.py

@@ -6,7 +6,7 @@ re-exported here so external callers can continue to import from
 `localcode.agent` without caring about the internal split.
 
   loop.py       — `run_agent_loop`, the main entry point
-  prompts.py    — SYSTEM_PROMPT, REASONING_RULES, NOTEBOOK_RULES_TEMPLATE,
+  prompts.py    — SYSTEM_PROMPT, REASONING_RULES,
                   _load_project_instructions
   constants.py  — policy knobs, safety caps, tables
   context.py    — message aging / redaction / compaction pipeline
@@ -39,7 +39,6 @@ __all__ = [
     # Prompts
     "SYSTEM_PROMPT",
     "REASONING_RULES",
-    "NOTEBOOK_RULES_TEMPLATE",
     # Constants (policy knobs external code may want to read)
     "MAX_ROUNDS",
     "MAX_OUTPUT_TOKENS",
@@ -149,7 +148,6 @@ from .helpers import (  # noqa: F401
 
 from .prompts import (  # noqa: F401 — re-exports for back-compat
     SYSTEM_PROMPT,
-    NOTEBOOK_RULES_TEMPLATE,
     REASONING_RULES,
     _load_project_instructions,
 )

{localcode-0.2.12.1a1 → localcode-0.2.13}/src/localcode/agent/app_tasks.py

@@ -18,6 +18,17 @@ PARTIAL_HANDOFF_RE = re.compile(
 )
 BLOCKING_QUESTION_RE = re.compile(r"^(?:[^?]{0,320}\?)$", re.DOTALL)
 PORT_RE = re.compile(r"(?:--port\s+|-p\s+|localhost:|127\.0\.0\.1:)(\d{2,5})")
+__all__ = [
+    "is_app_build_request",
+    "looks_like_partial_handoff",
+    "is_focused_blocking_question",
+    "extract_port",
+    "has_runtime_verification_signal",
+    "app_source_line_stats",
+    "has_launch_signal",
+    "ground_run_or_launch_text",
+    "format_run_or_launch_summary",
+]
 
 
 def is_app_build_request(user_text: str) -> bool:

{localcode-0.2.12.1a1 → localcode-0.2.13}/src/localcode/agent/constants.py

@@ -29,6 +29,11 @@ __all__ = [
     "REDACT_MIN_CONTENT_CHARS",
     "PROJECT_FILES",
     "READ_UNCHANGED_STUB_PREFIX",
+    "CHURN_FILE_WRITE_LIMIT",
+    "CHURN_COMMAND_FAIL_LIMIT",
+    "CHURN_READONLY_STREAK_LIMIT",
+    "CHURN_PLANNING_STREAK_LIMIT",
+    "CROSS_ROUND_REPEAT_LIMIT",
 ]
 
 
@@ -184,3 +189,73 @@ READ_UNCHANGED_STUB_PREFIX = (
 """Replacement text for older duplicate read_file results, so the
 model sees "the content exists further down" rather than the raw
 bytes twice. `_redact_duplicate_reads` inserts this prefix."""
+
+
+# ── Semantic-churn thresholds ───────────────────────────────────────
+#
+# These catch the "thrashing without converging" pattern that the
+# byte-identical-call breakers miss: the model keeps WRITING a file
+# (different content each time) or keeps RE-RUNNING a failing command,
+# never reading the actual error and making a targeted fix. Distinct
+# from the exact-repeat guards (`recent_tool_sigs`, `success_counts`)
+# which only trip on identical args. Tuned conservatively so normal
+# multi-step flows (a couple of edits to one file, running a build
+# command twice while iterating) do NOT trip — only sustained churn.
+
+CHURN_FILE_WRITE_LIMIT = 3
+"""How many times the SAME path may be written/edited in one turn
+before we nudge "stop rewriting it, read the error and make a
+targeted fix." Counts every write/edit/append to the path regardless
+of whether content differs — semantic churn, not byte-identical
+repeats. 3 chosen because a legit flow is typically write-once then
+one corrective edit (2); a 3rd full rewrite of the same file in a
+turn is the churn signal (the real incident rewrote package.json ~5×)."""
+
+CHURN_COMMAND_FAIL_LIMIT = 3
+"""How many times the SAME command (keyed by its first token, e.g.
+`npm`) may FAIL in one turn before we nudge "read its error output
+and fix the root cause before re-running." 3 (not 2) so running a
+build/install command, fixing, and one more failure while iterating
+is tolerated; the 3rd failure of the same command family means the
+model is re-running without absorbing the error."""
+
+CHURN_READONLY_STREAK_LIMIT = 6
+"""Consecutive rounds of PURE read-only investigation (read_file /
+grep / glob / list_files / web_*) with no mutating or server action
+before we nudge "take a concrete action now." Tighter than the prior
+generic streak of 10: a 10-round read-only run is already 5+ minutes
+of the user staring at a frozen screen. 6 still allows reading the
+handful of files needed to understand a redesign before committing,
+but interrupts a genuine investigation spin sooner."""
+
+CHURN_PLANNING_STREAK_LIMIT = 4
+"""Consecutive rounds of PLANNING-WITHOUT-PROGRESS before we nudge
+"you've planned enough; take a concrete action now."
+
+A round counts toward this streak when ALL of:
+  • it changed NO new file this turn (changed_files count didn't grow),
+  • it ran NO build/test/verify command, and
+  • it produced thinking or narration content (i.e. the model was
+    reasoning/planning, not idle).
+
+This catches the model that re-derives the SAME plan across many rounds
+— lots of thinking, no concrete action — which the read-only-spin
+signal misses because that streak resets on any round with zero tool
+calls (a pure think-then-read-then-think alternation never accumulates
+a pure read-only streak). Set to 4 (one higher than the read-only
+limit's effective reach) so legitimate "read two files, think, read a
+third, then edit" flows do NOT trip: as soon as a round changes a file
+or runs a build, the streak resets to 0."""
+
+CROSS_ROUND_REPEAT_LIMIT = 4
+"""How many times the SAME (tool, canonical-args) call may run ACROSS the
+turn before we nudge "you already have this result — stop repeating it."
+
+The in-round breaker catches identical calls within ONE round; this catches
+the cross-ROUND spin the logs show — read_file on the same path 53x over many
+rounds, or a pkill->curl->read loop where each command succeeds (so the
+command-FAILURE breaker never trips). Crucially this only NUDGES — it never
+withholds the tool result (the 2026-04-29 read-dedup STUB starved legitimate
+debug re-reads and hung a turn 17 min; we do not repeat that). A write/edit to
+a path resets that path's read counts, so a legitimate read-after-edit isn't
+counted. 4 tolerates a couple of genuine re-looks before flagging a true loop."""

{localcode-0.2.12.1a1 → localcode-0.2.13}/src/localcode/agent/context.py

@@ -149,28 +149,33 @@ def _truncate_result(result: str, tool_name: str) -> str:
 # to constants.py during the T0.1 split; re-exported at the top of
 # this module for back-compat.
 
-def _compact_old_tool_results(messages: list[dict]) -> list[dict]:
+def _compact_old_tool_results(
+    messages: list[dict], keep_recent: int = COMPACT_KEEP_RECENT_TOOL_RESULTS
+) -> list[dict]:
     """Return a copy of `messages` with older tool-role results summarized.
 
     Gated on `Feature.TOOL_RESULT_AGING` — when disabled the caller gets
     the input list back unchanged, which is what eval uses to A/B
     "how much does aging actually save per turn?"
 
-    We keep the last `COMPACT_KEEP_RECENT_TOOL_RESULTS` tool results
-    verbatim (the model usually only needs the recent ones to decide the
-    next step) and replace earlier ones with a compact "[summarized ...]"
-    placeholder. User, assistant, and system messages pass through
-    unchanged, and `tool_call_id` is preserved so the chat protocol still
-    reconciles ids correctly.
+    We keep the last `keep_recent` tool results verbatim (the model usually
+    only needs the recent ones to decide the next step) and replace earlier
+    ones with a compact "[summarized ...]" placeholder. `keep_recent` scales
+    with the context window (more on a big machine — see
+    `_prepare_model_messages`), so a 128K-window session preserves far more
+    raw tool output than a 16K one instead of crushing both to the same 4.
+    User/assistant/system messages pass through unchanged, and `tool_call_id`
+    is preserved so the chat protocol still reconciles ids correctly.
     """
     from ..features import Feature, is_enabled
     if not is_enabled(Feature.TOOL_RESULT_AGING):
         return messages
+    keep_recent = max(1, keep_recent)
     tool_idxs = [i for i, m in enumerate(messages) if m.get("role") == "tool"]
-    if len(tool_idxs) <= COMPACT_KEEP_RECENT_TOOL_RESULTS:
+    if len(tool_idxs) <= keep_recent:
         return messages
 
-    cutoff_idx = tool_idxs[-COMPACT_KEEP_RECENT_TOOL_RESULTS]
+    cutoff_idx = tool_idxs[-keep_recent]
     out: list[dict] = []
     for i, m in enumerate(messages):
         if i >= cutoff_idx or m.get("role") != "tool":
@@ -463,9 +468,34 @@ def _msg_bytes(messages: list[dict]) -> int:
     except Exception:
         return 0
 
-def _prepare_model_messages(messages: list[dict]) -> list[dict]:
+def _window_aware_compaction(ctx_window_chars: int | None) -> tuple[int, int]:
+    """(history_budget_bytes, keep_recent_tool_results) scaled to the context
+    window. The whole point: compaction must be DYNAMIC per machine. A 16 GB
+    Mac with a ~16K window has no room, so aggressive lossy compaction (the
+    old fixed 36 KB / keep-4) is correct. A 128 GB Mac with a 128K window has
+    ~8x the room — crushing its history to 36 KB threw away the data model the
+    model needs and made it lose track / re-read / drift. So budget ~55% of
+    the window to history and keep proportionally more recent tool output.
+
+    `ctx_window_chars` ≈ num_ctx tokens × ~3.5 chars/token. None/unknown →
+    the legacy fixed behaviour (back-compat, safe on tiny windows).
+    """
+    if not ctx_window_chars or ctx_window_chars <= 0:
+        return 36_000, COMPACT_KEEP_RECENT_TOOL_RESULTS
+    budget = max(36_000, int(ctx_window_chars * 0.55))
+    keep = max(COMPACT_KEEP_RECENT_TOOL_RESULTS, min(24, ctx_window_chars // 20_000))
+    return budget, keep
+
+
+def _prepare_model_messages(
+    messages: list[dict], ctx_window_chars: int | None = None
+) -> list[dict]:
     """One-stop context-shrink pass before sending to the model.
 
+    `ctx_window_chars` (the model's context window in chars, RAM-derived) makes
+    compaction window-aware: big machines keep far more history, small ones
+    stay aggressive. None preserves the legacy fixed budget.
+
     Composes the three reduction passes in a fixed order:
       1. `_redact_old_write_args` — strip bulky content from old
          write_file / edit_file / multi_edit tool_call arguments.
@@ -484,13 +514,23 @@ def _prepare_model_messages(messages: list[dict]) -> list[dict]:
     practice?" without instrumenting the agent loop. Silent on no-op
     so the log doesn't fill up with empty events.
     """
+    budget_bytes, keep_recent = _window_aware_compaction(ctx_window_chars)
     before = _msg_bytes(messages)
     after_writes = _redact_old_write_args(messages)
     bytes_writes = before - _msg_bytes(after_writes)
-    after_reads = _redact_duplicate_reads(after_writes)
+    # RAM-tier the duplicate-read stubbing: on a big window (≥128K chars ≈
+    # 36K tokens, i.e. 48 GB+) there's room to KEEP prior reads so the model
+    # retains what it saw (less "re-read because it scrolled away"). Only stub
+    # duplicate reads on smaller windows where the space is actually needed.
+    # The progress ledger covers the small-window case where reads must be
+    # dropped. Codex similarly re-hydrates rather than aggressively stubbing.
+    if ctx_window_chars and ctx_window_chars >= 128_000:
+        after_reads = after_writes
+    else:
+        after_reads = _redact_duplicate_reads(after_writes)
     bytes_reads = _msg_bytes(after_writes) - _msg_bytes(after_reads)
-    after_tools = _compact_old_tool_results(after_reads)
-    after_budget = _microcompact_for_prompt_budget(after_tools)
+    after_tools = _compact_old_tool_results(after_reads, keep_recent=keep_recent)
+    after_budget = _microcompact_for_prompt_budget(after_tools, target_bytes=budget_bytes)
     bytes_tools = _msg_bytes(after_reads) - _msg_bytes(after_tools)
     bytes_budget = _msg_bytes(after_tools) - _msg_bytes(after_budget)
     total_saved = bytes_writes + bytes_reads + bytes_tools + bytes_budget
@@ -616,6 +656,61 @@ def _compact_history_summary(messages: list[dict]) -> str:
     lines.append("If exact file content is needed, call read_file on the relevant path.")
     return "\n".join(lines)
 
+def build_progress_ledger(
+    changed_files: list[str],
+    bash_history: list[tuple[str, str]],
+    files_read: list[str],
+    budget_chars: int,
+) -> str:
+    """A compact, always-current 'what I've already done this task' ledger.
+
+    Ported from Codex's design (handoff summary + tool-state awareness + an
+    explicit 'build on this, don't duplicate work' instruction). Built from the
+    loop's DURABLE state (changed_files / bash_history / files_read) — NOT the
+    message history — so it survives compaction: on a small-RAM machine the raw
+    tool results get compacted to placeholders, but this ledger persists, which
+    is exactly what stops the model re-reading files and "starting from scratch."
+
+    `budget_chars` is window-scaled (see model_config.progress_ledger_budget_chars):
+    compact on a 16 GB Mac, richer on a 128 GB Mac. Returns "" when nothing has
+    happened yet (keeps the prompt prefix stable on the first round).
+    """
+    if not (changed_files or bash_history or files_read):
+        return ""
+
+    def _uniq(seq: list[str]) -> list[str]:
+        return list(dict.fromkeys(s for s in seq if s))
+
+    lines = [
+        "## Work already done this task — build on it. Do NOT re-read a file or "
+        "re-run a command listed below unless you have CHANGED it since; you "
+        "already have the result.",
+    ]
+    rd = _uniq(files_read)
+    if rd:
+        lines.append("Files read: " + ", ".join(rd[-12:]))
+    cf = _uniq(changed_files)
+    if cf:
+        lines.append("Files created/edited: " + ", ".join(cf[-12:]))
+    if bash_history:
+        cmds: list[str] = []
+        for cmd, res in bash_history[-8:]:
+            r = str(res)
+            bad = (
+                r.startswith("[exit code ") or r.startswith("Error:")
+                or r.startswith("REJECTED:") or "Traceback " in r
+            )
+            cmds.append(f"{'x' if bad else 'ok'} {str(cmd).strip().splitlines()[0][:70]}"
+                        if str(cmd).strip() else "")
+        cmds = [c for c in cmds if c]
+        if cmds:
+            lines.append("Commands run: " + " | ".join(cmds))
+    text = "\n".join(lines)
+    if budget_chars and len(text) > budget_chars:
+        text = text[: max(0, budget_chars - 2)].rstrip() + " …"
+    return text
+
+
 def _estimate_tokens(messages: list[dict]) -> int:
     """Rough token estimate: chars / 4."""
     total = 0

{localcode-0.2.12.1a1 → localcode-0.2.13}/src/localcode/agent/hooks.py

@@ -9,9 +9,21 @@ from dataclasses import dataclass, field
 from pathlib import Path
 import re
 from typing import Any
-
-
-@dataclass(slots=True)
+__all__ = [
+    "TurnState",
+    "EvidenceLedger",
+    "QualityVerdict",
+    "before_turn",
+    "before_model",
+    "after_tool",
+    "quality_monitor",
+    "completion_gate",
+    "ran_build_or_test",
+    "_changed_code_files",
+]
+
+
+@dataclass
 class TurnState:
     user_text: str
     goal_state: Any
@@ -22,7 +34,7 @@ class TurnState:
     evidence: "EvidenceLedger" = field(default_factory=lambda: EvidenceLedger())
 
 
-@dataclass(slots=True)
+@dataclass
 class EvidenceLedger:
     """Structured proof gathered during a turn.
 
@@ -66,7 +78,7 @@ class EvidenceLedger:
             items.append(value)
 
 
-@dataclass(slots=True)
+@dataclass
 class QualityVerdict:
     ok: bool
     reason: str = ""
@@ -241,6 +253,25 @@ def _recent_unresolved_verification_signals(state: TurnState) -> list[str]:
     return list(dict.fromkeys(unresolved))
 
 
+_BUILD_TEST_TOKENS = (
+    "tsc", "vitest", "jest", "pytest", "mypy", "ruff", "eslint", "cargo",
+    "go build", "go test", "make ", "make\t", "gradle", "mvn", "compile",
+    "npm run build", "yarn build", "pnpm build", "npm test", "npm run test",
+    "vite build", "next build", "ng build", "go vet", "rustc", "javac",
+)
+
+
+def ran_build_or_test(bash_history: list[tuple[str, str]]) -> bool:
+    """True if any command this turn was a build / typecheck / test / lint —
+    evidence the model actually compiled its code (vs just writing files).
+    Deliberately narrow: a dev-server launch (`npm run dev`) is NOT a build."""
+    for command, _ in bash_history:
+        c = str(command).lower()
+        if any(tok in c for tok in _BUILD_TEST_TOKENS):
+            return True
+    return False
+
+
 def _changed_code_files(paths: list[str]) -> bool:
     code_suffixes = {
         ".py", ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",