localcode 0.3.18__tar.gz → 0.3.19__tar.gz

{localcode-0.3.18/src/localcode.egg-info → localcode-0.3.19}/PKG-INFO

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

{localcode-0.3.18 → localcode-0.3.19}/pyproject.toml

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

{localcode-0.3.18 → localcode-0.3.19}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.18"
+__version__ = "0.3.19"

{localcode-0.3.18 → localcode-0.3.19}/src/localcode/agent/prompts.py

@@ -54,7 +54,10 @@ Plan & tools:
 - For files and dirs use list_files/read_file/write_file/edit_file — NOT bash (`ls`, `cat`, `cat >`, `>`). bash is only for running commands (npm, git, build, test).
 - edit_file for existing files: anchor `old_string` on 2–4 adjacent lines (matching is whitespace-tolerant; the leading `<n>\\t` from read_file is stripped for you). write_file to create or fully rewrite.
 - On a tool error, read it, fix the specific cause, and retry — don't give up after one failure, and don't repeat the same failing call.
-- New project → prefer a small multi-file layout with a thin entrypoint. Write code valid for the file's real language and match the project's existing conventions.
+- New project → prefer a small multi-file layout with a thin entrypoint. Write code valid for the file's real language and match the project's existing conventions. Put source under `src/`, config at the repo root.
+- Define the shared types / data model FIRST, then write everything against them. Don't write pages/UI before their types exist — naming mismatches force a full rewrite later.
+- Don't invent dependencies: before importing a library confirm it's in package.json (or requirements.txt/Cargo.toml) or a neighboring file; when installing, don't pin a guessed version — `npm install <pkg>` lets the resolver pick a real one.
+- Never assume a library's API. Before using a package's exports, types, or signatures, verify them — read its files in node_modules, check how neighboring files use it, or web_fetch its docs. Don't guess names. Port known algorithms from the real reference (web_fetch), not from memory.
 
 Runtime facts:
 - bash returns an exit code; non-zero = failure. Background long-running commands (`cmd &`) so bash returns.

{localcode-0.3.18 → localcode-0.3.19}/src/localcode/telemetry.py

@@ -122,18 +122,20 @@ class TurnTrace:
         self._active_tool = ToolEvent(name=name, args=args or "",
                                       start_ts=time.monotonic())
 
-    def tool_finished(self, result_chars: int, error: bool) -> None:
-        """Close out the most recent tool call. If no tool is active (e.g.
-        tool_start event was lost), we silently drop — the loss is more
-        useful than a noisy assertion."""
+    def tool_finished(self, result_chars: int, error: bool) -> int:
+        """Close out the most recent tool call and return its duration in ms
+        (0 if no tool is active — e.g. a lost tool_start event). If no tool is
+        active we silently drop; the loss is more useful than a noisy assertion.
+        The returned duration lets the UI render a per-tool time on the done row."""
         if self._active_tool is None:
-            return
+            return 0
         t = self._active_tool
         t.duration_ms = int((time.monotonic() - t.start_ts) * 1000)
         t.result_chars = result_chars
         t.error = bool(error)
         self.tools.append(t)
         self._active_tool = None
+        return t.duration_ms
 
     # ── Finalization ──
 

{localcode-0.3.18 → localcode-0.3.19}/src/localcode/tools/bash.py

@@ -762,6 +762,38 @@ def _quoting_error_hint(output: str) -> str:
     )
 
 
+# Package/version-not-found signatures across npm / pnpm / yarn / pip. A small
+# local model routinely invents package names or versions (e.g. `@types/dexie`,
+# a `^9.9.9` that doesn't exist) → the installer 404s and, with only raw stderr,
+# the model retries the SAME bad name in a loop. None of the reference harnesses
+# handle this deterministically (they rely on a "verify the library exists"
+# prompt line, which isn't enough for a small model), so we catch it here.
+_DEP_NOT_FOUND_MARKERS = (
+    "e404", "etarget", "no matching version found", "notarget",
+    "404 not found - get", "is not in this registry",
+    "could not find a version that satisfies",  # pip
+    "no matching distribution found",           # pip
+    "err_pnpm_no_matching_version",             # pnpm
+)
+
+
+def _dependency_error_hint(output: str) -> str:
+    """Actionable guidance when an install fails because a package/version does
+    not exist — so the model corrects the name instead of retrying it."""
+    low = output.lower()
+    if not any(m in low for m in _DEP_NOT_FOUND_MARKERS):
+        return ""
+    return (
+        "HINT: that package or version does not exist in the registry. Do NOT "
+        "retry the same name/version — it will 404 again. Instead: (1) read "
+        "package.json (or requirements.txt / Cargo.toml) and use a name that is "
+        "actually there; (2) install WITHOUT a pinned version so the resolver "
+        "picks a real latest (e.g. `npm install <pkg>` not `<pkg>@^9.9.9`); or "
+        "(3) if you invented the package, drop it. Never guess package names or "
+        "version numbers."
+    )
+
+
 def _redirect_shell_dir_listing(cmd: str) -> str:
     """Route `ls <path>` to list_files, which can't break on spaces/parens.
 
@@ -1052,6 +1084,11 @@ def execute(ctx: ToolContext, args: dict) -> str:
             _qh = _quoting_error_hint(output)
             if _qh:
                 output = _qh + "\n\n" + output
+            # Package/version-not-found (npm E404 / pip / etc.) → tell the model
+            # the name is wrong so it fixes it instead of retrying the same 404.
+            _dh = _dependency_error_hint(output)
+            if _dh:
+                output = _dh + "\n\n" + output
         # AirPlay-collision detector: if the model curls localhost:5000
         # or :7000, those are squatted by macOS AirPlay Receiver /
         # AirTunes — bare `curl -s` sees a 200 with empty body and

{localcode-0.3.18 → localcode-0.3.19}/src/localcode/tui/screens/chat.py

@@ -758,6 +758,16 @@ def _spinner_label_for_elapsed(elapsed: float) -> str:
     idx = int(max(0.0, elapsed) / _SPINNER_WORD_PERIOD)
     return _SPINNER_GERUNDS[idx % len(_SPINNER_GERUNDS)]
 
+
+def _fmt_tool_duration(ms: int) -> str:
+    """Compact per-tool duration for the done row: `3s`, `1m04s` (matches the
+    turn-summary formatter). Only shown when ≥1s so quick calls stay quiet."""
+    secs = ms / 1000
+    if secs < 60:
+        return f"{secs:.0f}s"
+    m, s = divmod(int(secs), 60)
+    return f"{m}m{s:02d}s"
+
 _TOOL_CALL_RE = re.compile(
     r'<\|?tool_call\|?>.*?<\|?/?tool_call\|?>', re.DOTALL
 )
@@ -4126,13 +4136,18 @@ class ChatScreen(Screen):
             # Use name from event payload (reliable) instead of _active_tool_name (can go stale)
             name = p.get("name", "") or self._active_tool_name
             args = p.get("args", "") or self._active_tool_args
+            # Close telemetry FIRST so we have the per-tool elapsed to render on
+            # the done row (like codex `• {duration}` / claude-code `(49s)`).
+            _dur_ms = 0
+            if self._telemetry_turn is not None:
+                _dur_ms = self._telemetry_turn.tool_finished(len(str(result)), is_error) or 0
+            _dur = f"  · {_fmt_tool_duration(_dur_ms)}" if _dur_ms >= 1000 else ""
             # Always render ✓ green for success, ● + error for failure
             if is_error:
                 log.append_tool(name, args)
                 log.append_tool_result(result, error=True)
             else:
                 lines = result.strip().splitlines()
-                summary = lines[0][:80] if lines else ""
                 is_diff = len(lines) > 1 and _is_diff_result(result)
                 if is_diff:
                     # For diffs, extract file path from --- line as summary
@@ -4141,13 +4156,18 @@ class ChatScreen(Screen):
                         if l.startswith("--- ") or l.startswith("+++ "):
                             file_path = l.split("\t")[0][4:]  # strip --- /+++ prefix
                             break
-                    log.append_tool_done(name, args, f"--- {file_path}" if file_path else "")
+                    _s = f"--- {file_path}" if file_path else ""
+                    log.append_tool_done(name, args, f"{_s}{_dur}")
                     log.append_tool_result(result)
                 else:
-                    log.append_tool_done(name, args, summary)
-            # Telemetry: close out the most recent tool-started event.
-            if self._telemetry_turn is not None:
-                self._telemetry_turn.tool_finished(len(str(result)), is_error)
+                    # Summarize by MAGNITUDE (N lines / N matches / N files), not
+                    # the first line of output — matching claude-code/codex/opencode
+                    # which show the result's shape. `_brief_result` is the same
+                    # summarizer the CLI uses, so both surfaces agree, and it also
+                    # cleans internal markers ([exit code], REJECTED, etc.).
+                    from ...agent.helpers import _brief_result
+                    summary = _brief_result(name, result)
+                    log.append_tool_done(name, args, f"{summary}{_dur}")
             self._thinking_phase = ""
             # Show thinking indicator immediately after tool completion
             # to cover the gap while the model processes the result

{localcode-0.3.18 → localcode-0.3.19}/src/localcode/tui/widgets/chat_log.py

@@ -8,10 +8,15 @@ Messages displayed with clear visual hierarchy:
 """
 from __future__ import annotations
 
+import re
 import time
 
 from ...theme import C
 
+# Leading internal error code (`[E3102] `) — stripped from user-facing error
+# lines; no peer harness shows an internal code. See append_error.
+_CODE_PREFIX_RE = re.compile(r"^\[E\d+\]\s*")
+
 
 
 from rich.markdown import Markdown
@@ -776,6 +781,13 @@ class ChatLog(RichLog):
         self._render_info(text)
 
     def append_error(self, text: str) -> None:
+        # Strip the internal [Eccc] code from the user-facing error line. No peer
+        # harness (claude-code/codex/opencode/pi) shows an internal error code —
+        # it reads as machine noise. The code is still persisted to
+        # ~/.localcode/last_error.log and kept in the CLI/headless path
+        # (out.set_error) so the e2e error sentinels and bug reports still have
+        # it; only the interactive screen is cleaned.
+        text = _CODE_PREFIX_RE.sub("", text)
         self._dispatch_gap("error")
         self._history.append(("error", text))
         self._render_error(text)
@@ -1446,20 +1458,15 @@ class ChatLog(RichLog):
         body = self._truncate_oneline(body, self._visible_width())
         line = Text(no_wrap=True)
         split_name = len(prefix)
-        line.append(body[:split_name], style=f"bold {C.success}")
-        # Split the args+summary region: args in bright green, summary
-        # in dim green. We find the args closing ')' to split cleanly.
-        tail = body[split_name:]
-        if args_one and tail.startswith("("):
-            end = tail.find(")")
-            if end == -1:
-                line.append(tail, style=f"{C.success}")
-            else:
-                line.append(tail[: end + 1], style=f"{C.success}")
-                if len(tail) > end + 1:
-                    line.append(tail[end + 1 :], style=f"dim {C.success}")
-        else:
-            line.append(tail, style=f"dim {C.success}")
+        # Muted tool line: ONLY the "✓" glyph carries the success colour; the
+        # tool name is plain bold and the args/summary are dim grey. A long run
+        # of routine reads/writes then reads as calm structure instead of a wall
+        # of green — colour is reserved for real signal (errors, diffs). Matches
+        # codex / claude-code / opencode / pi, which render tool lines muted.
+        line.append(body[:4], style=C.success)          # "  ✓ " check glyph
+        line.append(body[4:split_name], style="bold")   # tool name — no colour
+        # args + summary both dim (grey), so nothing shouts for attention.
+        line.append(body[split_name:], style="dim")
         self.write(line)
         self._track_lines()
 
@@ -1491,11 +1498,25 @@ class ChatLog(RichLog):
 
     def _render_tool_result(self, result: str, error: bool) -> None:
         if error:
-            err_one = result.replace("\n", " ").strip()
-            line = Text(no_wrap=True, overflow="ellipsis")
-            line.append("    ⎿ ", style="dim")
-            line.append(err_one, style="bold red")
-            self.write(line)
+            # Show the first several error lines (not collapse to one) — peers
+            # render multi-line errors so the user can actually read what failed
+            # (claude-code caps ~10, codex renders the err lines). Strip the
+            # internal "[exit code N]" marker; the done row already conveys it.
+            text = re.sub(r"^\[exit code \d+\]\n?", "", result.strip())
+            err_lines = [l for l in text.splitlines() if l.strip()] or [text.strip()]
+            shown = err_lines[:6]
+            for i, l in enumerate(shown):
+                prefix = "    ⎿ " if i == 0 else "    │ "
+                line = Text(no_wrap=True, overflow="ellipsis")
+                line.append(prefix, style="dim")
+                line.append(l[:200], style="bold red" if i == 0 else "red")
+                self.write(line)
+            if len(err_lines) > len(shown):
+                tail = Text(no_wrap=True)
+                tail.append("    │ ", style="dim")
+                tail.append(f"… +{len(err_lines) - len(shown)} more lines",
+                            style="dim italic")
+                self.write(tail)
             self._track_lines()
             return
 

{localcode-0.3.18 → localcode-0.3.19/src/localcode.egg-info}/PKG-INFO

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