localcode 0.3.48__tar.gz → 0.3.50__tar.gz

{localcode-0.3.48/src/localcode.egg-info → localcode-0.3.50}/PKG-INFO

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

{localcode-0.3.48 → localcode-0.3.50}/pyproject.toml

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

{localcode-0.3.48 → localcode-0.3.50}/src/localcode/__init__.py

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

{localcode-0.3.48 → localcode-0.3.50}/src/localcode/agent/context.py

@@ -294,6 +294,43 @@ def _compact_old_tool_results(
     # Floor at 1 so we never age away the entire working set of tool output.
     keep_recent = max(1, keep_recent)
     id_to_name = _tool_names_by_call_id(messages)
+    # Protect the LATEST read_file result for the few HOTTEST (most-recently-read)
+    # files from aging. read_file is "replayable", so aging its result out is
+    # cheap in theory — but in practice the model REPLAYS it (re-reads), and real
+    # traces showed ~68% of all reads were re-reads of a handful of actively-used
+    # files (App.tsx read 40× after being written). Keeping each hot file's
+    # current content in context (like write/edit diffs, which are never aged)
+    # makes the prompt's "don't re-read, it's already above" actually true.
+    # Bounded to _PROTECT_HOT_READS distinct paths so prefill/TTFT stays capped.
+    _PROTECT_HOT_READS = 5
+    _read_paths: dict[str, str] = {}
+    for _m in messages:
+        if _m.get("role") != "assistant":
+            continue
+        for _tc in _m.get("tool_calls") or []:
+            if ((_tc.get("function") or {}).get("name") or "").strip() != "read_file":
+                continue
+            _tcid = _tc.get("id")
+            if not _tcid:
+                continue
+            try:
+                _raw = (_tc.get("function") or {}).get("arguments") or "{}"
+                _a = _raw if isinstance(_raw, dict) else json.loads(_raw)
+            except Exception:
+                continue
+            _p = _a.get("path")
+            if isinstance(_p, str) and _p:
+                _read_paths[_tcid] = _p
+    _path_latest_idx: dict[str, int] = {}
+    for i, _m in enumerate(messages):
+        if _m.get("role") == "tool":
+            _p = _read_paths.get(_m.get("tool_call_id"))
+            if _p:
+                _path_latest_idx[_p] = i  # highest index = most recent read
+    protected_read_idxs = {
+        idx for _p, idx in
+        sorted(_path_latest_idx.items(), key=lambda kv: -kv[1])[:_PROTECT_HOT_READS]
+    }
     # Only REPLAYABLE-observation results are age-eligible; keep the last
     # `keep_recent` of THOSE verbatim (counting non-replayable results toward
     # the recency window would let a burst of writes push a still-needed read
@@ -302,6 +339,7 @@ def _compact_old_tool_results(
         i for i, m in enumerate(messages)
         if m.get("role") == "tool"
         and _result_tool_name(m, id_to_name) in _REPLAYABLE_TOOLS
+        and i not in protected_read_idxs
     ]
     if len(ageable_idxs) <= keep_recent:
         return messages
@@ -312,6 +350,9 @@ def _compact_old_tool_results(
         if i >= cutoff_idx or m.get("role") != "tool":
             out.append(m)
             continue
+        if i in protected_read_idxs:
+            out.append(m)  # hot file's current content — keep so it isn't re-read
+            continue
         if _result_tool_name(m, id_to_name) not in _REPLAYABLE_TOOLS:
             out.append(m)  # non-replayable (write/edit diff, etc.) — preserve
             continue

{localcode-0.3.48 → localcode-0.3.50}/src/localcode/agent/prompts.py

@@ -49,15 +49,17 @@ FINISH THE WHOLE TASK (most important):
 
 WORK FAST AND CLEAN:
 - ACT, DON'T NARRATE. At most one short sentence before a tool call. No "Here is…" preambles, no "Let me know if…" postambles. Terse PROSE — but complete CODE.
-- Don't repeat work. Never re-read a file or re-run a command whose result is already above. Continue from where you left off.
+- Don't repeat work. You ALREADY have a file's content after you read OR wrote it — it's in the conversation above. Do NOT re-read a file to "check", "verify", or "see the current state" — trust your own writes and edits. Re-read ONLY if a command (build, codegen, install) changed the file on disk since you last saw it. Re-reading a file you just wrote is wasted work and slows the user down.
 - Write complete, runnable code — no TODOs, stubs, placeholders, or "you could add…". If a piece is too big for one call, split it across calls; never drop it.
+- Prefer ONE decisive action over many tiny ones: write_file a complete file (or multi_edit for several changes at once) instead of a long read→edit→read→edit loop on the same file. Make a batch of related changes, THEN run the build/tests ONCE to verify — don't rebuild after every single edit.
+- Explore only what the task needs. Read the specific files you'll change or whose interfaces you'll call — do NOT survey the whole codebase file-by-file. Once you've seen enough to act (usually a handful of files), START WRITING. If you've made several reads/lists in a row without a single write, you are over-exploring — commit to a change now. Use list_files for directories and read_file for files (read_file on a directory just returns its listing).
 - On a tool error, read it, fix the specific cause, and retry with a real change — don't repeat the same failing call, and don't give up after one failure.
 
 TOOLS & FILES:
 - Use read_file / write_file / edit_file / list_files for files — NOT bash (`cat`, `ls`, `>`). bash is only for running commands (npm, git, build, test).
 - edit_file on an existing file: anchor `old_string` on 2–4 adjacent lines (whitespace-tolerant; the read_file line-number prefix is stripped for you). write_file to create or fully rewrite.
 - Use real, repo-relative paths. Keep source in the language's conventional directory, not dumped in the repo root. Match the project's existing conventions and language.
-- Background long-running commands (`cmd &`) so bash returns. Non-zero exit = failure — fix it, don't move on. Bulky tool output from older turns is redacted to save context — re-read from disk if you need it again.
+- Background long-running commands (`cmd &`) so bash returns. Non-zero exit = failure — fix it, don't move on. Very old bulky command output may be summarized to save context; the files you wrote and the recent files you read are kept, so re-read only if you truly no longer have what you need.
 
 DON'T GUESS:
 - Don't invent dependencies: before importing a library, confirm it's in the project's manifest (package.json / requirements.txt / Cargo.toml / go.mod) or a neighboring file. When installing, don't pin a guessed version — let the resolver pick.

{localcode-0.3.48 → localcode-0.3.50}/src/localcode/tools/read_file.py

@@ -174,6 +174,25 @@ def execute(ctx: ToolContext, args: dict) -> str:
             "exactly from now on; do NOT guess more spellings.]\n\n"
         )
         path = real
+    if path.is_dir():
+        # The model routinely read_file's a directory (confusing it with
+        # list_files), gets IsADirectoryError, and burns a whole round before
+        # retrying with list_files. Just hand back the listing + a nudge so the
+        # round is productive instead of wasted.
+        try:
+            entries = sorted(
+                p.name + ("/" if p.is_dir() else "") for p in path.iterdir()
+            )
+        except Exception as e:
+            return f"Error: '{source_disp}' is a directory and could not be listed: {e}"
+        shown = entries[:200]
+        more = f"\n  … ({len(entries) - len(shown)} more)" if len(entries) > len(shown) else ""
+        body = "\n".join(f"  {e}" for e in shown) or "  (empty)"
+        return (
+            f"'{source_disp}' is a directory, not a file ({len(entries)} entries). "
+            f"read_file needs a FILE path; use list_files for directories. Contents:\n"
+            f"{body}{more}"
+        )
     content = path.read_text(errors="replace")
     lines = content.splitlines()
     default_limit, max_default_chars = _dynamic_read_defaults(ctx)

{localcode-0.3.48 → localcode-0.3.50/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.48 → localcode-0.3.50}/tests/test_edit_guard_and_fuzzy.py

@@ -250,28 +250,37 @@ def _tc(tc_id, name, args):
             "function": {"name": name, "arguments": json.dumps(args)}}
 
 
-def test_replayable_results_aged_write_results_preserved() -> None:
+def test_hot_reads_protected_writes_preserved_old_bash_aged() -> None:
+    """Aging preserves write diffs AND the latest read of each hot file (so the
+    model doesn't re-read files it already has), while still aging older
+    non-read replayable output (e.g. bash) to bound context."""
     from localcode.agent.context import _compact_old_tool_results
     big = "x" * 600  # > COMPACT_MIN_CONTENT_CHARS
     msgs = [
         {"role": "system", "content": "sys"},
+        {"role": "assistant", "content": "", "tool_calls": [_tc("b1", "bash", {})]},
+        {"role": "tool", "tool_call_id": "b1", "content": "BASH-OLD " + big},
         {"role": "assistant", "content": "", "tool_calls": [_tc("r1", "read_file", {"path": "a.py"})]},
-        {"role": "tool", "tool_call_id": "r1", "content": "READFILE-OLD " + big},
+        {"role": "tool", "tool_call_id": "r1", "content": "READFILE-A " + big},
         {"role": "assistant", "content": "", "tool_calls": [_tc("w1", "write_file", {"path": "b.py"})]},
         {"role": "tool", "tool_call_id": "w1", "content": "WRITE-DIFF " + big},
+        {"role": "assistant", "content": "", "tool_calls": [_tc("b2", "bash", {})]},
+        {"role": "tool", "tool_call_id": "b2", "content": "BASH-RECENT " + big},
         {"role": "assistant", "content": "", "tool_calls": [_tc("r2", "read_file", {"path": "c.py"})]},
-        {"role": "tool", "tool_call_id": "r2", "content": "READFILE-RECENT " + big},
+        {"role": "tool", "tool_call_id": "r2", "content": "READFILE-C " + big},
     ]
     out = _compact_old_tool_results(msgs, keep_recent=1)
     by_id = {m.get("tool_call_id"): m for m in out if m.get("role") == "tool"}
-    # Old replayable read result is aged (summarized + materially shrunk).
-    assert "summarized" in by_id["r1"]["content"]
-    assert ("x" * 600) not in by_id["r1"]["content"]
-    assert len(by_id["r1"]["content"]) < len("READFILE-OLD " + big)
+    # Old bash output (replayable, NOT a hot read) is aged/shrunk.
+    assert ("x" * 600) not in by_id["b1"]["content"]
+    assert len(by_id["b1"]["content"]) < len("BASH-OLD " + big)
+    # The latest read of each hot file is PROTECTED from aging (the re-read fix).
+    assert by_id["r1"]["content"] == "READFILE-A " + big
+    assert by_id["r2"]["content"] == "READFILE-C " + big
     # Write result (the diff of what the model wrote) is NEVER aged.
     assert by_id["w1"]["content"] == "WRITE-DIFF " + big
     # Most-recent replayable result kept verbatim (keep_recent=1).
-    assert by_id["r2"]["content"] == "READFILE-RECENT " + big
+    assert by_id["b2"]["content"] == "BASH-RECENT " + big
 
 
 def test_redact_old_write_args_never_strips_bodies() -> None:

{localcode-0.3.48 → localcode-0.3.50}/tests/test_not_found_recovery.py

@@ -95,6 +95,21 @@ def test_real_file_reads_unchanged(tmp_path):
     assert "instead of" not in out
 
 
+def test_read_file_on_directory_returns_listing_not_error(tmp_path):
+    # read_file on a directory should return its listing + a nudge, not error —
+    # so the model doesn't burn a round before retrying with list_files.
+    from localcode.tools.read_file import execute
+    (tmp_path / "sub").mkdir()
+    (tmp_path / "a.py").write_text("x")
+
+    out = execute(_ctx(tmp_path), {"path": "."})
+
+    assert "is a directory" in out
+    assert "a.py" in out and "sub/" in out
+    assert not out.startswith("Error")
+    assert "list_files" in out
+
+
 # ── recovery.detect_not_found_loop (layer 2) ────────────────────────