@tiens.nguyen/gonext-local-worker 1.0.186 → 1.0.188

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,11 +44,20 @@ 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 own raw Python code blob, delimited by <code>/</code> lines in its
-// Thought+Code output. It's redundant with the step summary that follows it (e.g.
-// "Downloading → url"), so we don't print it — only the "Thought:" prose survives.
+// 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);
+// The router's internal play-by-play ("Routing your request…", "→ Agent mode (needs
+// tools)", "→ Chat reply", "Choosing a tool…") is implementation detail, not something a
+// user needs — also visible in the daemon's own terminal. Swallowed; see routingAnnounced.
+const isRoutingLine = (line) =>
+  /^(Routing your request…|Choosing a tool…|→ Agent mode.*|→ Chat reply)$/.test(line.trim());
 
 // 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).
@@ -101,7 +111,17 @@ if (!workerKey || !apiBase) {
 // awaits (workspace prompt fetch, payload probe) are queued instead of lost — vital
 // for piped/scripted input, harmless for interactive TTYs. Both ask() and the main
 // loop consume from this queue (never rl.question, to avoid double-capture).
-const rl = createInterface({ input: process.stdin, output: process.stdout });
+//
+// terminal: false — we draw our OWN prompt (cyan ">> ") and colorize output ourselves;
+// readline's default terminal:true (auto-enabled whenever output is a TTY) makes it ALSO
+// track cursor position and redraw the input line on every keystroke using ITS OWN
+// (empty, since we never call rl.setPrompt/rl.prompt) prompt — that tracking goes stale
+// the moment we write anything readline doesn't know about (which is everything we print
+// between prompts), and its next redraw emits a stray leading "[" (a malformed/partial
+// cursor-position escape) right before typed input, e.g. "[>> hi". With terminal:false,
+// 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 });
 const _lineQueue = [];
 let _lineWaiter = null;
 let _stdinClosed = false;
@@ -251,6 +271,7 @@ async function runAgentTurn(history) {
   let statusShown = false; // a transient status line is currently on screen
   let warnedPending = false;
   let jobRunning = false; // only tick "thinking…" once the worker has claimed the job
+  let routingAnnounced = false; // one friendly line replaces the whole routing play-by-play
 
   // --- Live "thinking…" ticker ---------------------------------------------------
   // Between visible tokens (prompt-eval / awaiting the first token) we show ONE in-place
@@ -282,48 +303,92 @@ 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); the model's raw <code>…</code> blob is swallowed too (redundant with
-  // the step summary that follows it, e.g. "Downloading → url"); blank lines keep spacing;
-  // everything else (the "Thought:" prose) 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;
+  let lastWasBlank = true; // suppresses a leading blank line and collapses repeats
   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 (isRoutingLine(line)) {
+        // Replace the whole routing play-by-play with ONE friendly line, shown once
+        // per turn — the raw labels are implementation detail (visible in the daemon's
+        // own terminal if you need them).
+        if (!routingAnnounced) {
+          routingAnnounced = true;
+          onContent();
+          process.stdout.write(dim(`${pickWord()}…`) + "\n");
+          lastWasBlank = false;
+        }
+        lastContentAt = Date.now();
+        continue;
+      }
       if (!inCode && isCodeOpenLine(line)) {
-        // Reasoning just ended and code is about to run — stamp the thought complete,
-        // then suppress the code body itself.
-        onContent();
+        stampIfThinking(); // hold/refresh the stamp; the code body commits it below
         inCode = true;
         continue;
       }
       if (inCode) {
-        lastContentAt = Date.now(); // content IS arriving, just not printed
-        if (isCodeCloseLine(line)) inCode = false;
+        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");
+        lastWasBlank = false;
         continue;
       }
       if (line.trim() === "") {
-        if (!thinking && !statusShown) process.stdout.write("\n");
+        // Several sources (swallowed routing lines, swallowed step summaries) each leave
+        // their own blank-line companion behind — collapse consecutive blanks into one.
+        if (!thinking && !statusShown && !lastWasBlank) {
+          process.stdout.write("\n");
+          lastWasBlank = true;
+        }
         continue;
       }
       onContent();
       process.stdout.write(dim(line) + "\n");
+      lastWasBlank = false;
     }
     // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
     // a newline), so tokens are actively flowing — keep the ticker asleep.
@@ -402,7 +467,10 @@ async function main() {
   console.log(dim("Ask about this repo, or /help. Ctrl-C aborts a running turn.\n"));
 
   const history = [];
-  rl.on("SIGINT", () => {
+  // With terminal:false, Ctrl-C is no longer intercepted by readline's raw-mode byte
+  // scanning (rl.on("SIGINT", …) would never fire) — it now delivers a real OS SIGINT to
+  // the process instead, which we catch directly here. Same behavior as before.
+  process.on("SIGINT", () => {
     if (following) {
       followAborted = true;
       process.stdout.write(red("\n^C "));
@@ -413,10 +481,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/package.json

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