@tiens.nguyen/gonext-local-worker 1.0.261 → 1.0.263

package/gonext-repl.mjs

@@ -48,6 +48,9 @@ const white = (s) => `\x1b[37m${s}\x1b[0m`;
 // code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
 const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+// Hover highlight for the clickable thinking line (task #96): bold + underline + bright
+// green so it reads as an interactive "link" the moment the mouse is over it.
+const hoverThought = (s) => `\x1b[1;4;92m${s}\x1b[0m`;
 
 // 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
@@ -383,6 +386,33 @@ rl.on("close", () => {
     w(null);
   }
 });
+// Mouse hover+click on the thinking line (task #96): while a turn runs we turn ON xterm
+// ANY-MOTION tracking so we can both HIGHLIGHT the line as the mouse hovers it AND expand it
+// on click (see runAgentTurn). Trade-off the user accepted: with tracking on, the terminal's
+// own drag-to-select/copy is captured by us — the user holds Option/Shift to select text
+// meanwhile. ?1003 = report every button press/release AND all mouse MOTION (needed for hover
+// with no button held); ?1006 = SGR extended coords (no 223-col cap). We disable ?1000/?1002
+// too on teardown in case a terminal had them latched.
+const MOUSE_ON = "\x1b[?1003h\x1b[?1006h";
+const MOUSE_OFF = "\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1006l";
+let _mouseEnabled = false;
+const enableMouse = () => {
+  if (_mouseEnabled || !process.stdin.isTTY) return;
+  process.stdout.write(MOUSE_ON);
+  _mouseEnabled = true;
+};
+const disableMouse = () => {
+  if (!_mouseEnabled) return;
+  process.stdout.write(MOUSE_OFF);
+  _mouseEnabled = false;
+};
+// Safety net: never leave the user's terminal in mouse-reporting mode (would break their
+// shell's selection) if we exit ungracefully.
+process.on("exit", disableMouse);
+// SGR mouse report: ESC [ < btn ; col ; row (M=press, m=release). btn bit 32 = MOTION
+// (hover/drag), bit 64 = wheel; low 2 bits = which button (0=left). A left CLICK is a press
+// (M) with motion+wheel bits clear and low bits 0; a HOVER is any event with the motion bit.
+const MOUSE_RE = /\x1b\[<(\d+);(\d+);(\d+)([Mm])/g;
 const nextLine = () =>
   _lineQueue.length > 0
     ? Promise.resolve(_lineQueue.shift())
@@ -1047,6 +1077,52 @@ const normalizeThought = (buf) => {
   return "";
 };
 
+// The FULLER thought (task #96): the same Thought prose normalizeThought summarizes, but
+// NOT clipped to one clause/100 chars — collapsed to a single spaced string and capped so
+// the expanded (mouse-click) view has a few lines to show. Returns "" when the live line is
+// only a tool label (nothing extra to expand). Bounded by fenceThought's own 400-char cap.
+const thoughtFull = (buf) => {
+  const t = String(buf || "");
+  const ci = t.search(/<code[\s>]/i);
+  const head = (ci >= 0 ? t.slice(0, ci) : t)
+    .replace(/^\s*Thought:\s*/i, "")
+    .replace(/\s+/g, " ")
+    .trim();
+  // Only worth expanding when there's a genuine prose clause (same gate as normalizeThought
+  // path 1) — a bare fragment or pure code has nothing meaningful to unfold.
+  const first = head.split(/\s+/).length;
+  if (head.length < 6 || first < 2 || _thoughtLooksCodey(head)) return "";
+  return head.slice(0, 400);
+};
+
+// Word-wrap a plain (ANSI-free) string into at most `maxLines` lines of width ≤ `width`,
+// appending an ellipsis to the last line when text was dropped (task #96 expand view).
+const wrapThought = (s, width, maxLines) => {
+  const words = String(s || "").split(/\s+/).filter(Boolean);
+  const lines = [];
+  let cur = "";
+  let truncated = false;
+  for (let i = 0; i < words.length; i++) {
+    const w = words[i];
+    const next = cur ? cur + " " + w : w;
+    if (next.length <= width) {
+      cur = next;
+    } else {
+      if (cur) lines.push(cur);
+      cur = w;
+      if (lines.length >= maxLines) { truncated = true; cur = ""; break; }
+    }
+  }
+  if (cur && lines.length < maxLines) lines.push(cur);
+  else if (cur) truncated = true;
+  if (truncated && lines.length) {
+    const last = lines[maxLines - 1] ?? lines[lines.length - 1];
+    const room = Math.max(1, width - 1);
+    lines[lines.length - 1] = (last.length > room ? last.slice(0, room) : last).replace(/\s+$/, "") + "…";
+  }
+  return lines;
+};
+
 async function runAgentTurn(history) {
   const res = await fetch(`${apiBase}/api/worker/agent-ask`, {
     method: "POST",
@@ -1090,6 +1166,7 @@ async function runAgentTurn(history) {
   let lastApprovalId = null; // the last command-approval request we've already answered
   let carry = ""; // trailing partial content line held until its newline arrives
   let statusShown = false; // a transient status line is currently on screen
+  let statusLines = 2; // how many rows the status block currently occupies (grows when expanded)
   let warnedPending = false;
   // Transient poll failures (a network blip or a 5xx like the API's momentary "Worker
   // key lookup failed." — a cold Mongo connection, NOT a bad key) must NOT kill a
@@ -1138,14 +1215,22 @@ async function runAgentTurn(history) {
   // random word. `fenceThought` accumulates the raw in-fence text for the current step.
   let liveThought = "";
   let fenceThought = "";
+  // Task #96: the FULLER version of the current thought (for the click-to-expand view) and
+  // whether the user has clicked to expand it. Both reset when the step's Thought changes.
+  let fullLiveThought = "";
+  let thoughtExpanded = false;
+  let hoverRow = -1; // last mouse viewport row (from motion events) → highlight when it's on the thought line
   const thinkSecs = () => Math.max(1, Math.round((Date.now() - thinkingSince) / 1000));
 
-  // The status is TWO in-place lines — the in-progress action, then the playful word
-  // under it. Cursor sits at the end of line 2, so clearing = wipe line 2, move up, wipe
-  // line 1, leaving the cursor back at the status's origin for a redraw or real content.
+  // The status is normally TWO in-place lines — the in-progress action, then the playful
+  // word under it — but grows by a few grey lines when the thought is expanded (task #96).
+  // Cursor sits at the end of the LAST line, so clearing = wipe it, then move-up-and-wipe
+  // for each line above, leaving the cursor back at the status's origin for a redraw.
   const clearStatus = () => {
     if (!statusShown) return;
-    process.stdout.write("\r\x1b[K\x1b[1A\r\x1b[K");
+    let seq = "\r\x1b[K";
+    for (let i = 1; i < statusLines; i++) seq += "\x1b[1A\r\x1b[K";
+    process.stdout.write(seq);
     statusShown = false;
   };
 
@@ -1166,7 +1251,9 @@ async function runAgentTurn(history) {
     // while (e.g. a 150s+ silent prompt-eval on a huge context), the last clause is no longer
     // "what it's doing now" — drop it so the line falls back to the playful word / "Thinking…"
     // instead of freezing on an old thought while the timer climbs ("string… (777s)", #95 A).
-    if (liveThought && now - lastContentAt > STALE_THOUGHT_MS) liveThought = "";
+    if (liveThought && now - lastContentAt > STALE_THOUGHT_MS) {
+      liveThought = ""; fullLiveThought = ""; thoughtExpanded = false; // #96: nothing to expand once stale
+    }
     const secs = thinkSecs();
     // Rotate the playful word once per 12s window (guarded so the fast ticker doesn't
     // re-roll it many times within the same second).
@@ -1187,27 +1274,73 @@ async function runAgentTurn(history) {
       : liveThought || (almostDone ? "Almost done" : "Thinking");
     const max = Math.max(24, (process.stdout.columns || 80) - 14);
     const fit = (s) => (s.length > max ? s.slice(0, max - 1) + "…" : s);
-    clearStatus();
-    // Line 1: green ● + green phase/seconds (matches the web's green streaming label).
-    // Line 2 (indented): the SPINNER + the playful word together, both in the cycling
-    // color — the spinner belongs with the word (dot on the label line, spinner leading
-    // the flavor line).
-    // Task #83/#84: after the playful word, show the running agent-code-model token
-    // count (dim) plus the per-workspace PEAK single-request count (orange), e.g.
-    // "  ⠙ Caffeinating… · 12.3k tok · 8.1k max". Both start at 0 and climb.
     const tokLabel =
       dim(` · ${fmtTokens(latestCodeTokens)} tok`) +
       orange(` · ${fmtTokens(sessionMaxCodeTokens)} max`);
-    process.stdout.write(
-      `${green(BULLET)} ${green(`${fit(primary)}… (${secs}s)`)}` +
-        "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`
-    );
+    // Task #96: the thought line is "clickable" only when there's a fuller thought to reveal
+    // (a live command / bare "Thinking" has nothing to expand). When clicked, unfold it below
+    // as up to 4 wrapped GREY lines (dim). The whole status block rides the viewport bottom as
+    // output scrolls, so line 1 (the thought) sits at row `rows - drawn + 1` — if the mouse is
+    // hovering THAT row, render the label as an underlined bright-green "link".
+    const clickable = !!(fullLiveThought && !runningCmd);
+    const expLines = thoughtExpanded && clickable ? wrapThought(fullLiveThought, max, 4) : [];
+    const drawn = 2 + expLines.length;
+    const rows = process.stdout.rows || 24;
+    const hovering = clickable && hoverRow === rows - drawn + 1;
+    const label = `${fit(primary)}… (${secs}s)`;
+    clearStatus();
+    // Line 1: green ● + green phase/seconds (matches the web's green streaming label), or the
+    // underlined bright-green hover style when the mouse is over a clickable thought.
+    // Line 2 (indented): the SPINNER + the playful word together, both in the cycling color.
+    // Task #83/#84: after the word, the running agent-code token count (dim) + per-workspace
+    // PEAK single-request count (orange), e.g. "  ⠙ Caffeinating… · 12.3k tok · 8.1k max".
+    let out =
+      `${green(BULLET)} ${hovering ? hoverThought(label) : green(label)}` +
+      "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`;
+    for (const wl of expLines) out += "\n  " + dim(wl);
+    process.stdout.write(out);
+    statusLines = drawn;
     statusShown = true;
   };
   // 120ms so the spinner animates smoothly (the frame math above uses the wall clock, so
   // seconds still tick once/sec). Only redraws when the model has gone quiet >QUIET_MS.
   const ticker = setInterval(tick, 120);
 
+  // --- Hover + click on the thinking line (task #96) -------------------------------------
+  // HOVER: motion events keep `hoverRow`; the tick highlights the thought line (underlined
+  // bright-green "link") whenever the mouse is on its row. CLICK: a left-click on the status
+  // block toggles the fuller thought (3-4 grey lines). The block sits at the bottom of the
+  // viewport (new output keeps scrolling it there), so we hit-test rows against the bottom
+  // `statusLines` rows. Mouse reporting is on only for the turn and always turned back off in
+  // the finally + on process exit, so the user's shell is never left in mouse-capture mode.
+  const onStatusClick = (row) => {
+    if (!statusShown) return;
+    const rows = process.stdout.rows || 24;
+    const top = rows - statusLines + 1; // 1-based viewport row of the first status line
+    if (row < top || row > rows) return; // click landed outside the status block
+    // Only meaningful when there IS a fuller thought to reveal; otherwise ignore the click
+    // so we don't flicker an empty expand.
+    if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
+    thoughtExpanded = !thoughtExpanded;
+    clearStatus(); // next tick (≤120ms) redraws at the new size; keeps cursor math correct
+  };
+  const onMouseData = (chunk) => {
+    if (!following) return;
+    const s = chunk.toString("latin1");
+    if (s.indexOf("\x1b[<") === -1) return; // fast reject: no SGR mouse report in this chunk
+    MOUSE_RE.lastIndex = 0;
+    let m;
+    while ((m = MOUSE_RE.exec(s))) {
+      const btn = parseInt(m[1], 10);
+      const row = parseInt(m[3], 10);
+      const isPress = m[4] === "M";
+      if (btn & 32) { hoverRow = row; continue; } // MOTION (hover/drag) → track for the highlight
+      if (isPress && (btn & 0b11) === 0 && (btn & 64) === 0) onStatusClick(row); // left click → expand
+    }
+  };
+  if (process.stdin.isTTY) process.stdin.on("data", onMouseData);
+  enableMouse();
+
   // Called right before any real (bullet/edit-card/answer) content prints: drop the
   // status lines so content lands cleanly, and end the current phase (so the next phase's
   // seconds count fresh, and any running command is considered finished).
@@ -1219,6 +1352,8 @@ async function runAgentTurn(history) {
     // next step's blinking line starts from "Thinking", not last step's stale clause.
     liveThought = "";
     fenceThought = "";
+    fullLiveThought = "";       // #96: the fuller thought is spent too…
+    thoughtExpanded = false;    // …and each new thinking phase starts collapsed.
     lastContentAt = Date.now();
   };
 
@@ -1277,6 +1412,7 @@ async function runAgentTurn(history) {
           fenceThought += line + "\n";
           const th = normalizeThought(fenceThought);
           if (th) liveThought = th;
+          fullLiveThought = thoughtFull(fenceThought); // #96: keep the fuller thought for expand
         }
         continue;
       }
@@ -1416,6 +1552,7 @@ async function runAgentTurn(history) {
     if (inStreamFence && fenceThought.length < 400) {
       const th = normalizeThought(fenceThought + carry);
       if (th) liveThought = th;
+      fullLiveThought = thoughtFull(fenceThought + carry); // #96: fuller thought for expand
     }
     // 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.
@@ -1574,6 +1711,11 @@ async function runAgentTurn(history) {
   } finally {
     clearInterval(ticker);
     clearStatus();
+    // Task #96: stop mouse-reporting the moment the turn ends (also on cancel/error — this
+    // finally always runs), and detach the click parser, so the user's shell selection is
+    // never captured between turns.
+    disableMouse();
+    if (process.stdin.isTTY) process.stdin.removeListener("data", onMouseData);
     following = false;
     currentJobId = null;
     // Drop anything typed (but not submitted) during the turn — echo was muted, so it's

package/package.json

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