@tiens.nguyen/gonext-local-worker 1.0.194 → 1.0.196

package/gonext-repl.mjs

@@ -36,7 +36,9 @@ const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
 const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
-const blue = (s) => `\x1b[34m${s}\x1b[0m`;
+// ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
+// code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
+const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
 const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
 // The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
@@ -45,7 +47,7 @@ const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
 const isFenceLine = (line) => line.trim() === "~~~";
 // The model's raw Python code blob is delimited by <code>/</code> lines. We don't print
-// the tag lines themselves, but the code IN BETWEEN prints in a distinct color (blue)
+// the tag lines themselves, but the code IN BETWEEN prints in a distinct grey (codeColor)
 // instead of dim prose, so it visually separates from the "Thought:" reasoning.
 const isCodeOpenLine = (line) => line.trim() === "<code>";
 const isCodeCloseLine = (line) => line.trim() === "</code>";
@@ -127,16 +129,26 @@ if (!workerKey || !apiBase) {
 // readline stops managing the line/cursor itself; the OS's own canonical-mode terminal
 // still echoes keystrokes normally, and 'line' events fire exactly the same.
 const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+// Side effect of terminal:false above: readline no longer intercepts arrow keys for
+// command-history recall, so pressing ↑/↓/→/← (or Home/End/Delete) sends the RAW escape
+// bytes straight through as literal input — the OS's own canonical line discipline
+// doesn't understand them either, so they get echoed and end up IN the submitted line
+// once Enter is pressed (seen live: a task sent to the model started with a literal
+// "\x1b[A" from an accidental up-arrow press). Strip CSI escape sequences (ESC '[' …
+// final-byte) from every submitted line so stray arrow-key presses can't corrupt task
+// text sent to the model.
+const stripAnsiEscapes = (s) => String(s ?? "").replace(/\x1b\[[0-9;]*[A-Za-z~]/g, "");
 const _lineQueue = [];
 let _lineWaiter = null;
 let _stdinClosed = false;
 rl.on("line", (l) => {
+  const clean = stripAnsiEscapes(l);
   if (_lineWaiter) {
     const w = _lineWaiter;
     _lineWaiter = null;
-    w(l);
+    w(clean);
   } else {
-    _lineQueue.push(l);
+    _lineQueue.push(clean);
   }
 });
 rl.on("close", () => {
@@ -359,8 +371,8 @@ async function runAgentTurn(history) {
   // Split newly-arrived text into lines: heartbeats + ~~~ fences + the post-tool-call step
   // summary ("tool(...) | → result", redundant with the daemon's own terminal) are
   // swallowed; the model's <code>/</code> TAG lines are hidden but the code body between
-  // them prints in blue (not dim, so it stands out from "Thought:" prose); blank lines
-  // keep spacing; everything else commits dim to scrollback.
+  // them prints in a distinct grey (not dim, so it stands out from "Thought:" prose);
+  // blank lines keep spacing; everything else commits dim to scrollback.
   let inCode = false;
   let lastWasBlank = true; // suppresses a leading blank line and collapses repeats
   // Chars of the CURRENT trailing (newline-less) `carry` line already flushed live — lets
@@ -400,7 +412,7 @@ async function runAgentTurn(history) {
         if (isCodeCloseLine(line)) { inCode = false; lastContentAt = Date.now(); continue; }
         if (line.trim() === "") { lastContentAt = Date.now(); continue; } // skip blank lines in code
         onContent();
-        process.stdout.write(blue(line) + "\n");
+        process.stdout.write(codeColor(line) + "\n");
         lastWasBlank = false;
         continue;
       }

package/gonext_agent_chat.py

@@ -297,6 +297,15 @@ _EMAIL_CONFIRM = re.compile(
     re.IGNORECASE,
 )
 
+# A bare "continue"-style nudge — matched WHOLE-MESSAGE (anchored) so it only fires on a
+# short, unambiguous continuation cue, never a longer sentence that happens to contain
+# one of these words. See _continuation_pending().
+_CONTINUE_CUE = re.compile(
+    r"^(please\s+)?(continue|keep\s+going|go\s+on|resume|carry\s+on|try\s+again)"
+    r"[\s.!?]*$",
+    re.IGNORECASE,
+)
+
 
 def _email_allowed(addr, allow):
     """True if addr matches an allow-list entry — an exact address or a bare domain."""
@@ -1800,6 +1809,41 @@ def _ws_for_path(path: str):
     return None
 
 
+def _workspace_overview(roots, max_entries: int = 40) -> str:
+    """Cheap, LOCAL top-level listing of each registered workspace root — a plain
+    os.listdir(), no recursion, no network call, no model call. Used two ways: (1)
+    injected into the task prompt so the agent has upfront grounding that the workspace
+    is non-empty WITHOUT spending its first (possibly failing) tool-call round-trip just
+    discovering that; (2) appended to the degrade-to-plain-reply message so even a TOTAL
+    coding-model outage still shows the user their files are actually there — this is
+    the one piece of workspace context that stays available no matter how badly the
+    model-calling side of the agent is failing, since it never touches a model at all."""
+    import os
+    parts = []
+    for w in roots:
+        root = w["path"]
+        try:
+            entries = sorted(
+                e for e in os.listdir(root) if e not in _RAG_SKIP_DIRS
+            )
+        except OSError as e:
+            parts.append(f"{w['name']} ({root}): could not list ({e})")
+            continue
+        if not entries:
+            parts.append(f"{w['name']} ({root}): EMPTY — no files or folders found.")
+            continue
+        shown = entries[:max_entries]
+        labeled = [
+            f"{e}/" if os.path.isdir(os.path.join(root, e)) else e for e in shown
+        ]
+        more = f" …(+{len(entries) - max_entries} more)" if len(entries) > max_entries else ""
+        parts.append(
+            f"{w['name']} ({root}) — {len(entries)} top-level item(s): "
+            + ", ".join(labeled) + more
+        )
+    return "\n".join(parts)
+
+
 def _ws_write_allowed(path: str) -> str:
     """Resolve `path` for WRITING: must be inside a registered workspace and never
     inside its .git/ internals (agents must not corrupt version control)."""
@@ -2185,6 +2229,29 @@ def run_agent_chat(cfg):
         return bool(_EMAIL_AVAILABLE and _EMAIL_CONFIRM.search(latest_user_text or "")
                     and _prior_email_preview())
 
+    def _prior_turn_was_interrupted() -> bool:
+        """True if the immediately preceding assistant turn is one of OUR OWN
+        interrupted-investigation markers (the honest degrade-fallback note, or the
+        max-steps 'ran out of steps' note) — i.e. a genuine tool-use attempt started but
+        didn't finish, as opposed to a normal completed answer."""
+        for m in reversed(messages[:last_user_idx]):
+            if m.get("role") == "assistant":
+                c = m.get("content") or ""
+                return ("ran out of steps before finishing" in c
+                        or "couldn't finish the full investigation" in c)
+        return False
+
+    def _continuation_pending() -> bool:
+        """A bare 'continue'/'keep going' after an interrupted investigation must reach
+        the AGENT, not plain chat — plain chat has zero tool access and can never
+        actually continue a stalled grep_repo/read_file_lines investigation, which is
+        exactly the reported bug: 'continue' silently degraded to a tool-less reply that
+        could only apologize, never resume. Gated tightly (short continuation phrase +
+        genuinely-interrupted prior turn) so it doesn't misfire on an unrelated 'continue'
+        after a normal, already-complete answer."""
+        return bool(_CONTINUE_CUE.match((latest_user_text or "").strip())
+                    and _prior_turn_was_interrupted())
+
     # Route: does this task need HTTP tool use? A trivial greeting/thank-you/"who are you"
     # is caught LOCALLY (no model classifier call, no tool preamble) → straight to a fast
     # small-prompt reply. Otherwise ask the model classifier.
@@ -2201,6 +2268,13 @@ def run_agent_chat(cfg):
         _log("router → YES (email confirm pending)")
         _emit({"type": "step", "text": "→ Agent mode (email confirm)"})
         needs_agent = True
+    # A bare "continue" after WE reported an interrupted investigation must reach the
+    # agent too — plain chat has zero tool access, so it can only apologize again, never
+    # actually resume the grep_repo/read_file_lines work (the reported bug).
+    if not needs_agent and _continuation_pending():
+        _log("router → YES (continuation of an interrupted investigation)")
+        _emit({"type": "step", "text": "→ Agent mode (continuing)"})
+        needs_agent = True
 
     if not needs_agent:
         _log("router: plain chat (no HTTP needed)")
@@ -2347,8 +2421,15 @@ def run_agent_chat(cfg):
         "If the user adds information, rag_add(source_url=url, text=...).\n"
     ) if _RAG_AVAILABLE else ""
     _ws_names = ", ".join(f"{w['name']} = {w['path']}" for w in _WS_ROOTS)
+    # Upfront, ZERO-COST (no tool call, no model round-trip) top-level listing — so the
+    # agent already knows the workspace is non-empty and roughly what's in it before its
+    # first step, instead of having to spend (and risk losing to a timeout) a whole
+    # round-trip just calling list_dir to discover that.
+    _ws_overview = _workspace_overview(_WS_ROOTS) if _WS_AVAILABLE else ""
     _ws_tool_block = (
         f"  WORKSPACES (local code folders you may READ and EDIT): {_ws_names}\n"
+        f"  Current contents:\n"
+        + "\n".join(f"    {line}" for line in _ws_overview.splitlines()) + "\n"
         "    - list_dir(path) / read_text_file(path) — browse and read files.\n"
         "    - grep_repo(pattern, path='', glob='') — search code, returns file:line hits. "
         "Use this to find the EXACT lines to change.\n"
@@ -3938,10 +4019,15 @@ def run_agent_chat(cfg):
         # "the real attempt never got to run" (seen live: workspace summarize request →
         # coding model timed out 3x on a slow/unreachable remote Ollama box → silent
         # fallback claimed "no access to your workspace").
-        _emit({"type": "final", "text": (
-            f"⚠️ I couldn't finish the full investigation ({_clip(str(e), 120)}) — here's "
-            f"what I can say without it:\n\n{fallback}"
-        )})
+        note = f"⚠️ I couldn't finish the full investigation ({_clip(str(e), 120)}) — here's what I can say without it:\n\n{fallback}"
+        # Append the workspace's ACTUAL top-level contents (computed locally, no model
+        # call — see _workspace_overview) so the user sees their files are really there
+        # even during a total coding-model outage, instead of trusting a plain-chat
+        # model's guess that "there's no code or project" (seen live — false: the
+        # workspace had real content the whole time, the model just never reached it).
+        if _WS_AVAILABLE:
+            note += f"\n\n(Your registered workspace:\n{_workspace_overview(_WS_ROOTS)})"
+        _emit({"type": "final", "text": note})
 
 
 def _log(text: str):

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.194",
+  "version": "1.0.196",
   "description": "Polls GoNext cloud API for async local LLM jobs and runs them against Ollama/OpenAI-compatible servers on this Mac",
   "type": "module",
   "license": "MIT",