@tiens.nguyen/gonext-local-worker 1.0.185 → 1.0.187

package/gonext-repl.mjs

@@ -36,6 +36,7 @@ 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`;
 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
@@ -43,6 +44,15 @@ const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 // also drop the worker's ~~~ stream fences (they only matter to the web renderer).
 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)
+// instead of dim prose, so it visually separates from the "Thought:" reasoning.
+const isCodeOpenLine = (line) => line.trim() === "<code>";
+const isCodeCloseLine = (line) => line.trim() === "</code>";
+// The step summary the worker emits right after a tool call finishes (e.g.
+// "unzip_file(...) | → Unzipped 256 files…") duplicates what's already visible in the
+// gonext-local-worker daemon's own terminal — swallow it here to keep the REPL terse.
+const isToolStepSummary = (line) => / \| → /.test(line);
 
 // Playful words for the local "thinking…" ticker, reused verbatim from the worker's
 // thinking_words.txt sibling (falls back to a tiny built-in list if it's missing).
@@ -277,27 +287,65 @@ async function runAgentTurn(history) {
   };
   const ticker = setInterval(tick, 1000);
 
-  // Close out a "thinking…" phase right before real output prints.
+  // Close out a "thinking…" phase right before real output prints. A model streams in
+  // small bursts with natural micro-pauses between them (token batching, network jitter);
+  // each pause >700ms would otherwise stamp its OWN "✔ completed thought" line, stacking
+  // many near-duplicates through a single Thought/code generation. `stampIfThinking()` —
+  // called ONLY at the <code> tag transition, where nothing prints right after it — HOLDS
+  // the stamp as the current status line (like the ticker): a later completion overwrites
+  // it in place instead of stacking a new line. `onContent()` — called immediately before
+  // any real content prints — always COMMITS whatever is pending (a fresh stamp or a held
+  // one) with a trailing newline first, so content never lands on the same line as a stamp.
+  let pendingStamp = false;
+  const stampIfThinking = () => {
+    if (thinking) {
+      process.stdout.write(CLEAR_LINE + dim(`✔ completed thought (${thinkSecs()}s)`));
+      thinking = false;
+      statusShown = true;
+      pendingStamp = true;
+    }
+    lastContentAt = Date.now();
+  };
   const onContent = () => {
     if (thinking) {
       process.stdout.write(CLEAR_LINE + dim(`✔ completed thought (${thinkSecs()}s)`) + "\n");
       thinking = false;
-      statusShown = false;
+    } else if (pendingStamp) {
+      process.stdout.write("\n"); // commit the held stamp; content prints right after
     } else {
       clearStatus();
     }
+    pendingStamp = false;
+    statusShown = false;
     lastContentAt = Date.now();
   };
 
-  // Split newly-arrived text into lines: heartbeats + ~~~ fences are swallowed (the ticker
-  // shows progress); blank lines keep spacing; everything else commits dim to scrollback.
+  // 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.
+  let inCode = false;
   const consume = (chunk) => {
     carry += stripThinkTags(chunk);
     let nl;
     while ((nl = carry.indexOf("\n")) >= 0) {
       const line = carry.slice(0, nl);
       carry = carry.slice(nl + 1);
-      if (isHeartbeatLine(line) || isFenceLine(line)) continue; // swallow
+      if (isHeartbeatLine(line) || isFenceLine(line)) continue; // swallow, no trace
+      if (isToolStepSummary(line)) { lastContentAt = Date.now(); continue; } // swallow
+      if (!inCode && isCodeOpenLine(line)) {
+        stampIfThinking(); // hold/refresh the stamp; the code body commits it below
+        inCode = true;
+        continue;
+      }
+      if (inCode) {
+        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");
+        continue;
+      }
       if (line.trim() === "") {
         if (!thinking && !statusShown) process.stdout.write("\n");
         continue;
@@ -393,10 +441,17 @@ async function main() {
 
   for (;;) {
     process.stdout.write(cyan(">> "));
-    const lineRaw = await nextLine();
+    // Absorb blank Enter-presses SILENTLY under the same prompt — without this, lines
+    // typed while the agent was busy on a long turn (queued, not yet read) all drain at
+    // once the moment the turn ends, each re-printing ">> " with no newline between them
+    // (e.g. ">> >> >> "). Only re-print the prompt for a genuine stdin close or input.
+    let lineRaw;
+    for (;;) {
+      lineRaw = await nextLine();
+      if (lineRaw === null || lineRaw.trim()) break;
+    }
     if (lineRaw === null) break; // stdin closed
     const line = lineRaw.trim();
-    if (!line) continue;
     if (line === "/exit" || line === "/quit") break;
     if (line === "/help") {
       console.log(dim("  /exit — quit · /revert [runId] — undo the agent's file edits (latest run)"));

package/gonext_agent_chat.py

@@ -488,8 +488,14 @@ def _summarise_step(step_log):
         name = getattr(tc, "name", "")
         args = getattr(tc, "arguments", None)
 
-        if name == "python_interpreter" and isinstance(args, dict):
-            code = args.get("code", "")
+        if name == "python_interpreter":
+            # smolagents' CodeAgent passes the raw code STRING as `arguments` (NOT a
+            # dict — only ToolCallingAgent's structured calls use {"code": ...}). Handle
+            # both shapes, else this always fell through to the useless "python_interpreter"
+            # label below and never showed what was actually called.
+            code = args if isinstance(args, str) else (
+                args.get("code", "") if isinstance(args, dict) else ""
+            )
             # Show the http_request call if present, else first meaningful line
             m = re.search(r'http_request\s*\(\s*(?:method\s*=\s*)?[\'"]?(\w+)[\'"]?\s*,\s*(?:url\s*=\s*)?[\'"]([^\'"]+)', code)
             if m:
@@ -514,9 +520,13 @@ def _summarise_step(step_log):
 
     if observations:
         obs = str(observations).strip()
-        # smolagents prefixes output with "Execution logs:" — skip that header line
-        # and show the first line of actual content.
-        lines = [l for l in obs.splitlines() if l.strip() and l.strip() != "Execution logs:"]
+        # smolagents wraps observations as "Execution logs:\n<print output>\nLast output
+        # from code snippet:\n<return value>" — both header lines are pure boilerplate.
+        # Without filtering "Last output from code snippet:" too, a call with no print()
+        # output (most of our @tool functions just `return`, not print) surfaced that
+        # HEADER as the shown text instead of the actual return value on the next line.
+        _OBS_BOILERPLATE = ("Execution logs:", "Last output from code snippet:")
+        lines = [l for l in obs.splitlines() if l.strip() and l.strip() not in _OBS_BOILERPLATE]
         if lines:
             parts.append(f"→ {_clip(lines[0])}")
 
@@ -3277,8 +3287,10 @@ def run_agent_chat(cfg):
                 for dirpath, dirnames, filenames in os.walk(root):
                     dirnames[:] = [d for d in dirnames if d not in _RAG_SKIP_DIRS]
                     for fn in filenames:
-                        rel = os.path.relpath(os.path.join(dirpath, fn), root)
-                        entries.append(rel)
+                        # ABSOLUTE path — read_file_lines/read_text_file resolve relative
+                        # paths against the WORKSPACE root, not whatever subfolder was
+                        # listed here, so a name relative to `root` could resolve wrong.
+                        entries.append(os.path.join(dirpath, fn))
                         if len(entries) >= 300:
                             break
                     if len(entries) >= 300:
@@ -3447,7 +3459,11 @@ def run_agent_chat(cfg):
                         with open(abs_path, "r", encoding="utf-8", errors="replace") as fh:
                             for i, line in enumerate(fh, 1):
                                 if rx.search(line):
-                                    hits.append(f"{rel}:{i}: {line.rstrip()[:200]}")
+                                    # ABSOLUTE path — read_file_lines/read_text_file resolve
+                                    # relative paths against the WORKSPACE root, not this
+                                    # search root, so a path relative to `root` (e.g. when
+                                    # searching a subfolder) would be silently wrong there.
+                                    hits.append(f"{abs_path}:{i}: {line.rstrip()[:200]}")
                                     if len(hits) >= 100:
                                         break
                     except OSError:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.185",
+  "version": "1.0.187",
   "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",