@tiens.nguyen/gonext-local-worker 1.0.179 → 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";
@@ -35,6 +35,29 @@ const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 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 CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
+
+// 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);
@@ -219,10 +242,78 @@ async function runAgentTurn(history) {
   followAborted = false;
   const startedAt = Date.now();
   let shownChars = 0;
+  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));
+
+  const clearStatus = () => {
+    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();
+  };
+
+  // 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) || 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) {
+        clearStatus();
         process.stdout.write(
           dim("\n(stopped following — the job keeps running on the worker)\n")
         );
@@ -233,16 +324,20 @@ 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") {
-        // Don't stream the final delta dim — the answer prints bright right after.
+        // Drop the transient status line and any partial reasoning tail; the bright answer
+        // prints right after via the caller.
+        clearStatus();
         return answerFrom(text);
       }
       if (text.length > shownChars) {
-        process.stdout.write(dim(stripThinkTags(text.slice(shownChars))));
+        consume(text.slice(shownChars));
         shownChars = text.length;
       }
       if (job.jobStatus === "failed" || job.jobStatus === "cancelled") {
+        clearStatus();
         throw new Error(job.errorMessage || `job ${job.jobStatus}`);
       }
       if (
@@ -251,6 +346,7 @@ async function runAgentTurn(history) {
         Date.now() - startedAt > 6000
       ) {
         warnedPending = true;
+        clearStatus();
         process.stdout.write(
           red("\n⚠ no worker has claimed the job — is `gonext-local-worker` running?\n")
         );
@@ -258,6 +354,8 @@ async function runAgentTurn(history) {
       await sleep(700);
     }
   } finally {
+    clearInterval(ticker);
+    clearStatus();
     following = false;
   }
 }

package/gonext_agent_chat.py

@@ -1481,10 +1481,16 @@ _WS_ACTIVE: str = ""
 def _rag_read_allowed(path: str) -> str:
     """Resolve `path` and ensure it stays within a safe root (worker cwd, temp dir,
     ~/.gonext, or a registered workspace) — so the agent's file tools can't read
-    arbitrary files like ~/.ssh."""
+    arbitrary files like ~/.ssh. Relative paths anchor to the terminal workspace (where
+    downloads/unzips land), NOT the worker's process cwd (the home dir), because the
+    model routinely passes bare names like "tools-hook" or "tools-hook/README.md"."""
     import os
     import tempfile
-    rp = os.path.realpath(path)
+    expanded = os.path.expanduser((path or "").strip())
+    if not os.path.isabs(expanded):
+        base = _WS_ACTIVE or (_WS_ROOTS[0]["path"] if _WS_ROOTS else os.getcwd())
+        expanded = os.path.join(base, expanded)
+    rp = os.path.realpath(expanded)
     roots = [
         os.path.realpath(os.getcwd()),
         os.path.realpath(tempfile.gettempdir()),

package/package.json

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