@tiens.nguyen/gonext-local-worker 1.0.177 → 1.0.179

package/gonext-local-worker.mjs

@@ -1799,6 +1799,9 @@ async function runAgentChatJob(job) {
           return Array.isArray(parsed?.workspaces) ? parsed.workspaces : [];
         })
         .catch(() => []),
+      // The `gonext` terminal REPL's launch folder — download_file/unzip_file output
+      // lands here (must be a registered workspace; the python side re-validates).
+      activeWorkspace: payload?.activeWorkspace ?? "",
     });
     // 30 min max for an agent run: multi-step ReAct on a 14B/31B with a cold prompt
     // cache — or a remote Ollama box on slow GPU cold-loading a big model — can run

package/gonext-repl.mjs

@@ -199,7 +199,9 @@ async function runAgentTurn(history) {
   const res = await fetch(`${apiBase}/api/worker/agent-ask`, {
     method: "POST",
     headers: { "Content-Type": "application/json", "X-Worker-Key": workerKey },
-    body: JSON.stringify({ messages: history }),
+    // cwd = this terminal's folder → agent puts download/unzip output here (when it's
+    // a registered workspace).
+    body: JSON.stringify({ messages: history, cwd: resolve(process.cwd()) }),
   });
   const data = await res.json().catch(() => ({}));
   if (!res.ok) {

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
@@ -1158,6 +1185,17 @@ def _rag_workdir(source_key: str) -> str:
     return base
 
 
+def _rag_base_dir(source_key: str) -> str:
+    """Where a URL's downloaded/unzipped files should live. Prefer the active terminal
+    workspace (the folder the `gonext` REPL was opened from) so files land in the
+    user's project; otherwise fall back to the per-URL cache dir under ~/.gonext."""
+    import os
+    if _WS_ACTIVE:
+        os.makedirs(_WS_ACTIVE, exist_ok=True)
+        return _WS_ACTIVE
+    return _rag_workdir(source_key)
+
+
 def _rag_download(url: str, dest_path: str = "") -> tuple:
     """Download a public URL with SSRF + size guards — IDEMPOTENT per URL. Every URL
     maps to a deterministic work dir (~/.gonext/rag-work/<urlHash>/); relative
@@ -1168,7 +1206,7 @@ def _rag_download(url: str, dest_path: str = "") -> tuple:
     src = _rag_gdrive_direct((url or "").strip())
     _rag_assert_safe_url(src)
     key = _rag_source_key(url)
-    workdir = _rag_workdir(key)
+    workdir = _rag_base_dir(key)
     dest_path = os.path.expanduser((dest_path or "").strip())
     if not dest_path:
         name = os.path.basename(src.split("?")[0]) or "download.bin"
@@ -1176,21 +1214,23 @@ def _rag_download(url: str, dest_path: str = "") -> tuple:
             name += ".zip"
         dest_path = os.path.join(workdir, name)
     elif not os.path.isabs(dest_path):
-        # Contain relative paths in the per-URL work dir — models pass bare names like
+        # Contain relative paths in the work dir — models pass bare names like
         # "project.zip" which would otherwise land in the worker's cwd (the home dir).
         dest_path = os.path.join(workdir, dest_path)
     # Cache hit 1: the exact target already exists.
     if os.path.isfile(dest_path) and os.path.getsize(dest_path) > 0:
         return dest_path, True
-    # Cache hit 2: this URL was downloaded before under a different name — the work dir
-    # is per-URL, so any archive already in it IS this URL's file.
-    try:
-        for fn in sorted(os.listdir(workdir)):
-            p = os.path.join(workdir, fn)
-            if os.path.isfile(p) and fn.lower().endswith(".zip") and os.path.getsize(p) > 0:
-                return p, True
-    except OSError:
-        pass
+    # Cache hit 2: this URL was downloaded before under a different name — ONLY safe in
+    # the per-URL cache dir (one URL per dir). In an active workspace the folder holds
+    # many unrelated files, so a bare "any zip = this URL" match would be wrong.
+    if not _WS_ACTIVE:
+        try:
+            for fn in sorted(os.listdir(workdir)):
+                p = os.path.join(workdir, fn)
+                if os.path.isfile(p) and fn.lower().endswith(".zip") and os.path.getsize(p) > 0:
+                    return p, True
+        except OSError:
+            pass
     os.makedirs(os.path.dirname(dest_path) or ".", exist_ok=True)
     req = urllib.request.Request(src, headers={"User-Agent": "gonext-rag/1.0"})
     total = 0
@@ -1220,8 +1260,15 @@ def _rag_resolve_zip(zip_path: str) -> str:
     if os.path.isfile(zp):
         return zp
     if not os.path.isabs(zp):
+        base = os.path.basename(zp)
+        # Look in the active terminal workspace first (that's where downloads land now),
+        # then fall back to the per-URL cache dirs.
+        if _WS_ACTIVE:
+            cand = os.path.join(_WS_ACTIVE, base)
+            if os.path.isfile(cand):
+                return cand
         hits = _glob.glob(os.path.join(
-            os.path.expanduser("~"), ".gonext", "rag-work", "*", os.path.basename(zp)))
+            os.path.expanduser("~"), ".gonext", "rag-work", "*", base))
         if hits:
             return hits[0]
     return zp
@@ -1424,6 +1471,12 @@ def _rag_parse_location(loc: str):
 # require _ws_write_allowed (workspace root + not inside .git/).
 _WS_ROOTS: list = []  # [{"name": str, "path": realpath str, "allowRun": bool}]
 
+# The active terminal workspace: the folder the `gonext` REPL was launched from
+# (passed through as payload.activeWorkspace). When set, download_file/unzip_file put
+# their output HERE instead of the shared ~/.gonext/rag-work cache, so files land in
+# the user's actual project folder. Only honoured if it's a registered workspace root.
+_WS_ACTIVE: str = ""
+
 
 def _rag_read_allowed(path: str) -> str:
     """Resolve `path` and ensure it stays within a safe root (worker cwd, temp dir,
@@ -1437,6 +1490,10 @@ def _rag_read_allowed(path: str) -> str:
         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(
@@ -1741,7 +1798,7 @@ def run_agent_chat(cfg):
     # Registered on the Mac via `gonext-local-worker workspace add <path>`; the worker
     # passes the registry through cfg. Only these roots are writable — the security
     # boundary for the coding tools.
-    global _WS_ROOTS
+    global _WS_ROOTS, _WS_ACTIVE
     _WS_ROOTS = []
     for w in (cfg.get("workspaces") or []):
         try:
@@ -1756,6 +1813,31 @@ def run_agent_chat(cfg):
         except Exception:  # noqa: BLE001
             continue
     _WS_AVAILABLE = bool(_WS_ROOTS)
+    # 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 = ""
+    _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
@@ -2726,9 +2808,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.177",
+  "version": "1.0.179",
   "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