@tiens.nguyen/gonext-local-worker 1.0.186 → 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,11 +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 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);
 
 // 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).
@@ -282,22 +287,44 @@ 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;
   const consume = (chunk) => {
     carry += stripThinkTags(chunk);
@@ -305,17 +332,18 @@ async function runAgentTurn(history) {
     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)) {
-        // 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");
         continue;
       }
       if (line.trim() === "") {
@@ -413,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/package.json

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