localcode 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"

localcode/agent/context.py

@@ -45,6 +45,37 @@ if TYPE_CHECKING:
 __all__: list[str] = []
 
 
+def _spill_tool_output(result: str, tool_name: str) -> str | None:
+    """Write an oversized tool result to a file and return its path.
+
+    Truncation alone makes a small model re-run the command "to see the rest".
+    Instead we keep the full output on disk and point the model at it (grep/
+    read the exact part). Best-effort: None on error → caller falls back to
+    plain truncation. Content-hashed filenames; old spills reaped after 7 days.
+    """
+    try:
+        import hashlib
+        import time as _time
+        from ..paths import global_state_dir
+        spill_dir = global_state_dir() / "tool_output"
+        spill_dir.mkdir(parents=True, exist_ok=True)
+        # Reap spills older than 7 days so this never grows unbounded.
+        try:
+            cutoff = _time.time() - 7 * 86400
+            for old in spill_dir.glob("*.txt"):
+                if old.stat().st_mtime < cutoff:
+                    old.unlink(missing_ok=True)
+        except Exception:
+            pass
+        digest = hashlib.sha1(result.encode("utf-8", "replace")).hexdigest()[:12]
+        path = spill_dir / f"{tool_name}_{digest}.txt"
+        if not path.exists():
+            path.write_text(result, encoding="utf-8", errors="replace")
+        return str(path)
+    except Exception:
+        return None
+
+
 def _truncate_result(result: str, tool_name: str) -> str:
     """Truncate a tool result to its per-tool size limit with a
     strategy tuned to what each tool's output actually looks like.
@@ -70,6 +101,15 @@ def _truncate_result(result: str, tool_name: str) -> str:
         return result
 
     dropped = len(result) - limit
+    # Spill the FULL output to disk and point the model at it, so it fetches
+    # the exact part it needs instead of re-running the command to "see the
+    # rest". Appended to every strategy's hint below.
+    _spill = _spill_tool_output(result, tool_name)
+    spill_hint = (
+        f" Full output saved to {_spill} — read_file (with offset) or grep it "
+        f"to see the rest; do NOT re-run the command."
+        if _spill else ""
+    )
 
     if tool_name == "read_file":
         # Keep the HEAD; if we can find line numbers in the content
@@ -85,7 +125,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
                 last_numbered = int(line.split("\t", 1)[0])
         hint = (
             f"\n\n[truncated — {dropped} more chars not shown. "
-            f"{'Call read_file with offset=' + str(last_numbered) + ' to continue reading from there.' if last_numbered else 'Call read_file with a larger offset to continue.'}]"
+            f"{'Call read_file with offset=' + str(last_numbered) + ' to continue reading from there.' if last_numbered else 'Call read_file with a larger offset to continue.'}{spill_hint}]"
         )
         return head + hint
 
@@ -99,7 +139,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
         dropped_lines = result[limit:].count("\n") + 1
         hint = (
             f"\n\n[truncated — {dropped_lines} more match-lines not shown. "
-            "Narrow with a more specific pattern or `include=*.py` to see them.]"
+            f"Narrow with a more specific pattern or `include=*.py` to see them.{spill_hint}]"
         )
         return head + hint
 
@@ -114,7 +154,7 @@ def _truncate_result(result: str, tool_name: str) -> str:
             first_sig = "\n".join(non_empty[:8])
             last_sig = "\n".join(non_empty[-12:]) if len(non_empty) > 12 else ""
             marker = (
-                f"\n\n[... {dropped} chars of bash output compressed ...]\n\n"
+                f"\n\n[... {dropped} chars of bash output compressed.{spill_hint} ...]\n\n"
             )
             if any(token in result for token in ("backend", "frontend", "src/", "node_modules", "package.json", "pyproject.toml")):
                 tree_hint = (
@@ -133,14 +173,14 @@ def _truncate_result(result: str, tool_name: str) -> str:
         tail_size = limit - head_size - 64  # 64 chars for the marker line
         head = result[:head_size]
         tail = result[-tail_size:]
-        marker = f"\n\n[... {dropped} chars of middle output dropped ...]\n\n"
+        marker = f"\n\n[... {dropped} chars of middle output dropped.{spill_hint} ...]\n\n"
         return head + marker + tail
 
     # Default — middle-drop.
     half = limit // 2
     return (
         result[:half]
-        + f"\n\n[...{dropped} chars truncated...]\n\n"
+        + f"\n\n[...{dropped} chars truncated.{spill_hint} ...]\n\n"
         + result[-half:]
     )
 
@@ -205,11 +245,12 @@ def _semantic_tool_summary(content: str) -> str:
         or "Traceback " in content
     )
     if is_error:
-        tail = "\n".join([ln for ln in lines[-12:] if ln.strip()])[:1200]
-        return (
-            f"[older tool error preserved: {len(content)} chars, "
-            f"{len(lines)} lines]\n{first_line}\n{tail}"
-        )
+        # Self-conditioning (arXiv:2509.09677): echoing an OLD error's text
+        # pushes the model to repeat the mistake (scale-independent). Recent
+        # errors stay intact (kept above by keep_recent) so it can fix the
+        # immediate problem; older ones drop to a neutral note. The progress
+        # ledger still records the failure fact, minus the conditioning text.
+        return "[an earlier tool call errored and was handled — details dropped]"
     if facts:
         return (
             f"[older successful tool result summarized: {len(content)} chars, "
@@ -412,7 +453,8 @@ def _redact_duplicate_reads(messages: list[dict]) -> list[dict]:
             if not tc_id:
                 continue
             try:
-                args = json.loads((tc.get("function") or {}).get("arguments") or "{}")
+                _raw = (tc.get("function") or {}).get("arguments") or "{}"
+                args = _raw if isinstance(_raw, dict) else json.loads(_raw)
             except Exception:
                 continue
             path = args.get("path")
@@ -629,7 +671,8 @@ def _compact_history_summary(messages: list[dict]) -> str:
             fn = tc.get("function") or {}
             name = str(fn.get("name") or "").strip()
             try:
-                args = json.loads(fn.get("arguments") or "{}")
+                _raw = fn.get("arguments") or "{}"
+                args = _raw if isinstance(_raw, dict) else json.loads(_raw)
             except Exception:
                 args = {}
             path = args.get("path") or args.get("file_path")
@@ -769,8 +812,13 @@ def _compact_messages(messages: list[dict], out: "OutputManager") -> list[dict]:
                 fn = tc.get("function", {})
                 name = fn.get("name", "")
                 try:
-                    args = json.loads(fn.get("arguments", "{}"))
-                except json.JSONDecodeError:
+                    # `arguments` may be a JSON string OR an already-decoded
+                    # dict (some providers/parsers do that) — json.loads on a
+                    # dict raises TypeError, which used to escape and kill the
+                    # turn with E3102 during compaction.
+                    _raw = fn.get("arguments", "{}")
+                    args = _raw if isinstance(_raw, dict) else json.loads(_raw)
+                except (json.JSONDecodeError, TypeError, ValueError):
                     args = {}
                 if name in ("write_file", "append_file", "edit_file"):
                     files_modified.add(args.get("path", "?"))

localcode/agent/loop.py

@@ -24,6 +24,7 @@ you hit them.
 from __future__ import annotations
 
 import json
+import os
 import re
 import sys
 import time
@@ -720,6 +721,19 @@ def run_agent_loop(
                     ]
             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.
+            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:
+                    model_messages = list(model_messages) + [
+                        {"role": "user", "content": _todo_note}
+                    ]
+            except Exception:
+                pass
             round_tool_schemas = schemas_for_goal(
                 _goal_state.goal_type,
                 user_text,
@@ -1205,7 +1219,11 @@ def run_agent_loop(
                 break
 
         # ── No tool calls = model is done ──
-        if not tool_calls:
+        # Also require no pending tool call: the runtime promotes pending
+        # tools into `tool_calls`, but if a future path doesn't, we keep
+        # looping instead of ending early (small models often emit a stop
+        # token with a call still pending).
+        if not tool_calls and not _round_pending_tool_count:
             # Match v0.2.12's no-tool-calls path exactly: render content,
             # render any grounded file summary, break. Nothing else.
             #
@@ -1328,8 +1346,12 @@ def run_agent_loop(
             fn = tc.get("function", {})
             tool_name = fn.get("name", "unknown")
             try:
-                args = json.loads(fn.get("arguments", "{}"))
-            except json.JSONDecodeError:
+                _raw_args = fn.get("arguments", "{}")
+                # `arguments` is normally a JSON string, but some providers/
+                # parsers hand back an already-decoded dict — json.loads on a
+                # dict raises TypeError, which used to escape and crash the loop.
+                args = _raw_args if isinstance(_raw_args, dict) else json.loads(_raw_args)
+            except (json.JSONDecodeError, TypeError, ValueError):
                 args = {}
                 out.print_info(f"Warning: malformed args for {tool_name}")
 
@@ -1337,6 +1359,16 @@ def run_agent_loop(
             stage = _tool_stage_label(tool_name, args)
             out.set_stage(stage)
             idx = out.log_tool(tool_name, _summarize_args(args))
+            # RL trace fidelity: the normal `tool_start` event carries only a
+            # summarized + 200-char-truncated arg preview. When capturing
+            # trajectories for fine-tuning we need the FULL arguments (e.g. the
+            # whole write_file body). Env-gated so normal TUI/headless runs are
+            # unaffected; dev/rl/collect sets LOCALCODE_TRACE_FULL_ARGS=1.
+            if os.environ.get("LOCALCODE_TRACE_FULL_ARGS"):
+                out._emit_event(
+                    "tool_call_full", index=str(idx),
+                    name=tool_name, arguments=args,
+                )
 
             # Safety: confirm destructive commands (honors current autonomy
             # level so /permissions toggles take effect immediately).

localcode/agent/prompts.py

@@ -42,11 +42,12 @@ _STACK_MARKERS: tuple[tuple[str, str], ...] = (
 SYSTEM_PROMPT = """\
 You are LocalCode, a coding agent on the user's machine with full filesystem access.
 
-Available tools: read_file, write_file, append_file, edit_file, bash, list_files.
+Available tools: read_file, write_file, append_file, edit_file, bash, list_files, todo_write.
 
 How to work:
 - Match scope to the request. Answer plain questions plainly. Build what was asked when asked. Don't write a script when a one-line bash command will do.
 - Cover every requirement the user named. If your chosen approach can't deliver one, change the approach — don't drop the requirement to fit the approach.
+- PLAN MULTI-STEP WORK. For any task with 3+ steps, call `todo_write` FIRST to lay out the steps, then keep it current: mark exactly ONE item in_progress before you start it, and mark it completed the instant it's done. Your task list is shown back to you every round — read it to see what's already finished and what's left, so you advance to the next step instead of redoing one you've already done. If you catch yourself about to re-read a file or re-run a command you ran before, check the list: you've likely already done it.
 - If the request is ambiguous in a way that affects your approach (stack, interface, scope), ask one short question before building, not after.
 - ACT, DON'T NARRATE. Every "let me read", "let me fix", "now I'll write" MUST be followed by the actual tool call IN THE SAME TURN. If you say "let me write the fix" and then end your turn without calling edit_file or write_file, you have failed the user. The user has explicitly complained about this. Never describe a fix without immediately performing it.
 - Forbidden patterns: "Let me read the file:" + end of turn. "I'll rewrite this:" + end of turn. "Now I'll apply the fix:" + end of turn. If the next thing out of your mouth is a verb of intent, the very next action MUST be the tool call that delivers on that intent.
@@ -57,7 +58,9 @@ How to work:
 - MATCH THE PROJECT'S LANGUAGE AND CONVENTIONS. Code MUST be valid for the file's actual language. Never write Python syntax (triple-quoted docstrings, snake_case, `import x`/`from x import y`) in a .ts/.tsx/.js/.jsx/.go/.rs or other non-Python file. Use that language's real comment, naming, and import/module syntax, and mirror the patterns already present in the project (imports, formatting, framework idioms).
 - For new projects, create a small multi-file structure by default. Keep entrypoints thin; move reusable logic, styles, data/config, templates, and assets into focused files. Use one large file only if requested.
 - Prefer edit_file for existing files. Use write_file when creating a new file or doing a deliberate full rewrite.
-- When a tool returns an error, read it, fix the specific problem, and retry. Don't give up after one failed call.
+- When a tool returns an error, read it, fix the specific problem, and retry with DIFFERENT input. Never repeat an identical failing call: if the same call fails or returns the same result twice, change the arguments or the approach, or move on — do not loop. Don't give up after one failed call, but don't spin on it either.
+- DON'T RE-READ OR RE-SEARCH what you already have. If you already read a file this turn and it hasn't changed, the content is still above — use it, don't read it again. If a search already gave you a useful result, act on it (open the match, make the edit); don't run the same search again. Repeating a read/search you've already done is the #1 way turns stall.
+- After a tool result, CONTINUE from where you left off — don't restate what you just did or re-summarize the plan. Take the next concrete action.
 - DON'T CONFABULATE. If the user names a person, song, place, term, library, command, or concept you do not recognize, your FIRST move is to say "I don't recognize that" — NOT to invent a plausible-sounding meaning by phonetic association. Phonetic fits ("Alombasi sounds Bantu so it must be a Zambian chant", "Pyfoo sounds like a Python library so it must do X") are exactly the failure mode. If a web search would help, run it BEFORE asserting facts; if results are empty, say so plainly. Never write paragraph-length cultural/etymological/technical descriptions of something you can't actually source — "I'd love to know more, what's it from?" is the correct answer. Doubling down when the user repeats the unknown term is also forbidden; repetition is not evidence.
 
 Runtime facts (true today; rely on these instead of guessing):

localcode/agent/tool_orchestration.py

@@ -31,7 +31,8 @@ def prefetch_parallel_tool_calls(
         fn = tc.get("function", {}) or {}
         name = (fn.get("name", "") or "").strip()
         try:
-            args = json.loads(fn.get("arguments", "{}"))
+            _raw = fn.get("arguments", "{}")
+            args = _raw if isinstance(_raw, dict) else json.loads(_raw)
         except Exception:
             continue
         if not is_concurrency_safe(name, args):