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

package/gonext-repl.mjs

@@ -35,6 +35,14 @@ 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 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.
+const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
 
 // ---------- flags ----------
 const argv = process.argv.slice(2);
@@ -219,10 +227,42 @@ 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 warnedPending = false;
+
+  // Erase the transient heartbeat status line (if any) before printing real output.
+  const clearStatus = () => {
+    if (statusShown) {
+      process.stdout.write(CLEAR_LINE);
+      statusShown = false;
+    }
+  };
+  // 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.
+  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");
+      }
+    }
+  };
   try {
     for (;;) {
       if (followAborted) {
+        clearStatus();
         process.stdout.write(
           dim("\n(stopped following — the job keeps running on the worker)\n")
         );
@@ -235,14 +275,17 @@ async function runAgentTurn(history) {
       if (!jr.ok) throw new Error(job?.error || `job poll failed (HTTP ${jr.status})`);
       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 heartbeat 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 +294,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 +302,7 @@ async function runAgentTurn(history) {
       await sleep(700);
     }
   } finally {
+    clearStatus();
     following = false;
   }
 }

package/gonext_agent_chat.py

@@ -37,6 +37,33 @@ import urllib.error
 _REAL_STDOUT = sys.stdout
 
 
+# Playful "still thinking" status words shown on the heartbeat while a model call is
+# in flight (see _heartbeat). Loaded once from thinking_words.txt next to this file;
+# a random one is picked per tick so the wait feels alive instead of a fixed string.
+_THINKING_WORDS: list = []
+
+
+def _thinking_word() -> str:
+    """A random playful status word (e.g. 'Caffeinating'). Falls back to a small
+    built-in list if thinking_words.txt is missing or empty."""
+    import os
+    import random
+    global _THINKING_WORDS
+    if not _THINKING_WORDS:
+        try:
+            path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "thinking_words.txt")
+            with open(path, "r", encoding="utf-8") as fh:
+                _THINKING_WORDS = [
+                    line.strip() for line in fh
+                    if line.strip() and not line.lstrip().startswith("#")
+                ]
+        except OSError:
+            _THINKING_WORDS = []
+        if not _THINKING_WORDS:
+            _THINKING_WORDS = ["Thinking", "Percolating", "Caffeinating", "Cogitating"]
+    return random.choice(_THINKING_WORDS)
+
+
 def _ssl_context():
     import ssl
     # Disable cert verification — this agent runs locally against dev tunnels
@@ -1454,15 +1481,25 @@ _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()),
         os.path.realpath(os.path.join(os.path.expanduser("~"), ".gonext")),
     ] + [w["path"] for w in _WS_ROOTS]
+    # The active terminal folder (download/unzip target) — allow reading what we just
+    # extracted there, even when it isn't a registered workspace.
+    if _WS_ACTIVE:
+        roots.append(_WS_ACTIVE)
     if any(rp == r or rp.startswith(r + os.sep) for r in roots):
         return rp
     raise ValueError(
@@ -1782,20 +1819,31 @@ def run_agent_chat(cfg):
         except Exception:  # noqa: BLE001
             continue
     _WS_AVAILABLE = bool(_WS_ROOTS)
-    # Active terminal workspace (the `gonext` REPL's launch folder) — download_file /
-    # unzip_file put their output here. Only honoured if it's a registered workspace
-    # root, so it can't redirect writes to an arbitrary folder.
+    # Active terminal workspace: the folder the `gonext` REPL was launched from (sent as
+    # payload.activeWorkspace = the terminal's cwd). download_file / unzip_file put their
+    # output HERE instead of the shared ~/.gonext/rag-work cache, so files land where the
+    # user opened the terminal. Honoured for any real directory the user explicitly opened
+    # the terminal in — these tools already write outside registered workspaces (to
+    # ~/.gonext), so this is not a new write boundary; the code-EDIT tools stay gated on
+    # _WS_ROOTS (registered workspaces) via _ws_write_allowed, unchanged.
     _WS_ACTIVE = ""
-    try:
-        import os as _os
-        aw = _os.path.realpath(_os.path.expanduser(str(cfg.get("activeWorkspace") or "")))
-        if aw and _os.path.isdir(aw) and any(
-            aw == w["path"] or aw.startswith(w["path"] + _os.sep) for w in _WS_ROOTS
-        ):
-            _WS_ACTIVE = aw
-            _log(f"active workspace: {aw} (download/unzip output → here)")
-    except Exception:  # noqa: BLE001
-        _WS_ACTIVE = ""
+    _aw_raw = str(cfg.get("activeWorkspace") or "").strip()
+    if _aw_raw:
+        try:
+            import os as _os
+            aw = _os.path.realpath(_os.path.expanduser(_aw_raw))
+            if _os.path.isdir(aw):
+                _WS_ACTIVE = aw
+                registered = any(
+                    aw == w["path"] or aw.startswith(w["path"] + _os.sep) for w in _WS_ROOTS
+                )
+                _log(f"active workspace: {aw} (download/unzip output → here"
+                     f"{'' if registered else '; not a registered workspace — reads/writes here limited to download/unzip'})")
+            else:
+                _log(f"active workspace ignored (not a directory): {aw}")
+        except Exception as _e:  # noqa: BLE001
+            _WS_ACTIVE = ""
+            _log(f"active workspace ignored (error resolving '{_aw_raw}'): {_e}")
     if _WS_AVAILABLE:
         _log(f"workspaces: {[(w['name'], w['path'], w['allowRun']) for w in _WS_ROOTS]}")
         # Coding tasks are edit→test→fix loops — 5 steps is too tight. Bump the default
@@ -2766,9 +2814,11 @@ def run_agent_chat(cfg):
                 waited = 0
                 while not hb_stop.wait(45):
                     waited += 45
+                    # A random playful word each tick (e.g. "Caffeinating… (90s)") instead
+                    # of a fixed "still working" line — a large or cold-loading model can
+                    # legitimately take a few minutes on prompt-eval.
                     _emit({"type": "step",
-                           "text": f"Model is still working… ({waited}s — a large or "
-                                   "cold-loading model can take a few minutes)"})
+                           "text": f"{_thinking_word()}… ({waited}s)"})
                     _log(f"heartbeat: model call in flight {waited}s")
 
             hb = threading.Thread(target=_heartbeat, daemon=True)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-local-worker",
-  "version": "1.0.178",
+  "version": "1.0.180",
   "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",
@@ -28,6 +28,7 @@
     "gonext_agent_chat.py",
     "gonext_transcribe.py",
     "gonext_mlx_embed.py",
+    "thinking_words.txt",
     "README.md",
     "launchd/"
   ],

package/thinking_words.txt

@@ -0,0 +1,106 @@
+# Playful "still thinking / still working" status words for the agent heartbeat.
+# One word/phrase per line; blank lines and lines starting with # are ignored.
+# The worker appends "…" and the elapsed seconds, e.g. "Caffeinating… (90s)".
+Collating
+Caffeinating
+Percolating
+Marinating
+Ruminating
+Cogitating
+Noodling
+Pondering
+Contemplating
+Mulling
+Brewing
+Simmering
+Steeping
+Distilling
+Fermenting
+Incubating
+Marshalling
+Wrangling
+Herding electrons
+Untangling
+Unknotting
+Defragmenting
+Reticulating splines
+Compiling thoughts
+Buffering brilliance
+Warming up the neurons
+Spinning up
+Booting the big brain
+Consulting the oracle
+Summoning tokens
+Conjuring
+Divining
+Calibrating
+Recalibrating
+Triangulating
+Extrapolating
+Interpolating
+Synthesizing
+Crystallizing
+Coalescing
+Assembling
+Stitching
+Weaving
+Knitting
+Threading the needle
+Connecting the dots
+Chasing the thread
+Following the breadcrumbs
+Sifting
+Sieving
+Panning for gold
+Mining
+Excavating
+Spelunking
+Deep-diving
+Surfacing insights
+Percolating harder
+Steeping the tea
+Kneading the dough
+Proofing the loaf
+Letting it rise
+Whisking
+Folding in the facts
+Reducing the sauce
+Plating up
+Garnishing
+Sharpening the pencils
+Oiling the gears
+Greasing the cogs
+Winding the springs
+Charging the flux capacitor
+Aligning the stars
+Consulting the tea leaves
+Reading the room
+Gathering wool
+Chewing it over
+Sleeping on it
+Doing the math
+Carrying the one
+Crunching numbers
+Tallying
+Counting sheep
+Herding cats
+Nudging pixels
+Polishing
+Buffing
+Tuning the antenna
+Finding the signal
+Clearing the static
+Untwisting
+Loosening the knot
+Priming the pump
+Stoking the furnace
+Kindling
+Fanning the embers
+Gathering steam
+Building momentum
+Hatching a plan
+Plotting a course
+Charting the map
+Threading the maze
+Almost there
+Nearly cooked