@tiens.nguyen/gonext-local-worker 1.0.180 → 1.0.181

package/gonext-repl.mjs

@@ -19,7 +19,7 @@
  * Commands: /exit  /revert [runId]  /help      Ctrl-C stops following the current run.
  */
 import { readFile, mkdir, writeFile } from "node:fs/promises";
-import { existsSync, statSync } from "node:fs";
+import { existsSync, statSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join, resolve, basename } from "node:path";
@@ -38,11 +38,26 @@ const red = (s) => `\x1b[31m${s}\x1b[0m`;
 const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
 const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 
-// The worker's playful "still thinking" heartbeat lines look like "Caffeinating… (90s)"
-// (a word/phrase, an ellipsis, then the elapsed seconds). They're ephemeral progress —
-// we render them on a single in-place status line (yellow) that the next one overwrites
-// and that gets erased once real output arrives, so they never pile up in the scrollback.
+// The worker's "still thinking" heartbeat lines look like "Caffeinating… (90s)" — we
+// SWALLOW them from the terminal (the local ticker below drives progress instead), and
+// 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() === "~~~";
+
+// 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).
+const THINKING_WORDS = (() => {
+  try {
+    return readFileSync(join(DIR, "thinking_words.txt"), "utf8")
+      .split("\n")
+      .map((l) => l.trim())
+      .filter((l) => l && !l.startsWith("#"));
+  } catch {
+    return ["Thinking", "Percolating", "Cogitating", "Noodling", "Ruminating"];
+  }
+})();
+const pickWord = () =>
+  THINKING_WORDS[Math.floor(Math.random() * THINKING_WORDS.length)] || "Thinking";
 
 // ---------- flags ----------
 const argv = process.argv.slice(2);
@@ -227,38 +242,74 @@ async function runAgentTurn(history) {
   followAborted = false;
   const startedAt = Date.now();
   let shownChars = 0;
-  let carry = ""; // trailing partial line held until its newline arrives
-  let statusShown = false; // a transient heartbeat status line is on screen
+  let carry = ""; // trailing partial content line held until its newline arrives
+  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
+
+  // --- Live "thinking…" ticker ---------------------------------------------------
+  // Between visible tokens (prompt-eval / awaiting the first token) we show ONE in-place
+  // status line that counts UP every second — "Percolating thinking… (7s)" — so the wait
+  // feels alive. When output resumes we stamp a dim "✔ completed thought (Ns)" and let the
+  // tokens stream. The worker's own 45s heartbeat lines (and ~~~ fences) are swallowed;
+  // this local 1-second ticker owns the progress display.
+  const QUIET_MS = 700; // stream idle this long ⇒ we're waiting on the model
+  let lastContentAt = Date.now();
+  let thinking = false;
+  let thinkingSince = 0;
+  let thinkWord = pickWord();
+  const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
-  // Erase the transient heartbeat status line (if any) before printing real output.
   const clearStatus = () => {
-    if (statusShown) {
-      process.stdout.write(CLEAR_LINE);
+    if (statusShown) { process.stdout.write(CLEAR_LINE); statusShown = false; }
+  };
+
+  const tick = () => {
+    if (!following || followAborted || !jobRunning) return;
+    if (Date.now() - lastContentAt < QUIET_MS) return; // tokens still flowing
+    // Count from when the stream actually went quiet, so the seconds reflect the true
+    // wait for the first token (1s, 2s, 3s…) rather than from the first tick.
+    if (!thinking) { thinking = true; thinkingSince = lastContentAt; thinkWord = pickWord(); }
+    const secs = thinkSecs();
+    if (secs % 12 === 0) thinkWord = pickWord(); // rotate the word on long waits
+    process.stdout.write(CLEAR_LINE + yellow(`${thinkWord} thinking… (${secs}s)`));
+    statusShown = true;
+  };
+  const ticker = setInterval(tick, 1000);
+
+  // Close out a "thinking…" phase right before real output prints.
+  const onContent = () => {
+    if (thinking) {
+      process.stdout.write(CLEAR_LINE + dim(`✔ completed thought (${thinkSecs()}s)`) + "\n");
+      thinking = false;
       statusShown = false;
+    } else {
+      clearStatus();
     }
+    lastContentAt = Date.now();
   };
-  // Feed newly-arrived stream text through the line splitter: heartbeat lines become an
-  // in-place status line (never committed to scrollback); everything else commits dim.
+
+  // Split newly-arrived text into lines: heartbeats + ~~~ fences are swallowed (the ticker
+  // shows progress); blank lines keep spacing; everything else commits dim to scrollback.
   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)) {
-        // Overwrite the previous heartbeat in place — no newline, so it stays transient.
-        process.stdout.write(CLEAR_LINE + yellow(line));
-        statusShown = true;
-      } else if (line.trim() === "") {
-        // Swallow the blank line the worker appends after a heartbeat; keep real spacing.
-        if (!statusShown) process.stdout.write("\n");
-      } else {
-        clearStatus();
-        process.stdout.write(dim(line) + "\n");
+      if (isHeartbeatLine(line) || isFenceLine(line)) continue; // swallow
+      if (line.trim() === "") {
+        if (!thinking && !statusShown) process.stdout.write("\n");
+        continue;
       }
+      onContent();
+      process.stdout.write(dim(line) + "\n");
     }
+    // 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.
+    if (carry.trim() !== "") lastContentAt = Date.now();
   };
+
   try {
     for (;;) {
       if (followAborted) {
@@ -273,10 +324,11 @@ async function runAgentTurn(history) {
       });
       const job = await jr.json().catch(() => ({}));
       if (!jr.ok) throw new Error(job?.error || `job poll failed (HTTP ${jr.status})`);
+      jobRunning = job.jobStatus === "running";
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
-        // Drop the transient heartbeat line and any partial reasoning tail; the bright
-        // answer prints right after via the caller.
+        // Drop the transient status line and any partial reasoning tail; the bright answer
+        // prints right after via the caller.
         clearStatus();
         return answerFrom(text);
       }
@@ -302,6 +354,7 @@ async function runAgentTurn(history) {
       await sleep(700);
     }
   } finally {
+    clearInterval(ticker);
     clearStatus();
     following = false;
   }

package/package.json

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