@tiens.nguyen/gonext-cli 1.0.371 → 1.0.373

package/gonext-repl.mjs

@@ -362,6 +362,7 @@ const COMMANDS = [
   { name: "/server", desc: "pick a deployment server (host/user) for this session" },
   { name: "/manual-edit", aliases: ["/revert"], usage: "/manual-edit [runId]", desc: "undo the agent's file edits so you can edit them yourself (latest run)" },
   { name: "/reset", aliases: ["/new"], desc: "forget this folder's saved conversation and start fresh" },
+  { name: "/hover", desc: "toggle mouse hover/click on the thinking line (costs scrolling while it runs)" },
   { name: "/output-token", desc: "show the agent code-model OUTPUT-token total for this workspace" },
   { name: "/reset-output-token-global", desc: "reset the GLOBAL (you + coding server) output-token total to 0" },
   { name: "/help", desc: "list these commands" },
@@ -673,6 +674,18 @@ const tokenLineText = () => {
   );
 };
 const FOOTER_ROWS = 3; // the rule row + the token row + the mode row
+// The bar's rows as plain printable strings, one PHYSICAL terminal row each. Both text rows
+// can exceed the width (the mode line is ~44 columns, the token row carries a model name) and
+// would then WRAP onto an extra row — every consumer here counts rows with ESC[nA / ESC[nB, so
+// a wrapped row corrupts the redraw (the #109 failure mode). Hence clipVisible on both.
+const footerRows = () => {
+  const width = Math.max(20, process.stdout.columns || 80);
+  return [
+    dim("─".repeat(width)),
+    clipVisible(GUTTER + tokenLineText(), width - 1),
+    clipVisible(GUTTER + modeLineText(), width - 1),
+  ];
+};
 // True only while the MAIN loop's ">> " prompt is waiting for input. The bar belongs to that
 // prompt, so it must never appear under an ask()/askSecret() question or during a turn.
 let footerActive = false;
@@ -690,18 +703,11 @@ const cursorPos = () =>
 // matching up-move still lands on it.
 function drawFooter() {
   if (!footerActive || !process.stdout.isTTY || slashOverlayActive) return;
-  const width = Math.max(20, process.stdout.columns || 80);
   const pos = cursorPos();
   const down = Math.max(0, inputRows() - 1 - pos.rows); // caret row → last input row
   process.stdout.write(
     (down ? `\x1b[${down}B` : "") +
-      "\r\n\x1b[2K" + dim("─".repeat(width)) +
-      // CLIPPED: both rows can exceed the width (the mode line is ~44 columns, the token row
-      // carries a model name) and would then WRAP onto an extra row — ESC[nA counts PHYSICAL
-      // rows, so the caret would come back short and the next keystroke would type over the
-      // bar (the #109 failure mode).
-      "\r\n\x1b[2K" + clipVisible(GUTTER + tokenLineText(), width - 1) +
-      "\r\n\x1b[2K" + clipVisible(GUTTER + modeLineText(), width - 1) +
+      footerRows().map((r) => "\r\n\x1b[2K" + r).join("") +
       "\x1b[J" +                                  // nothing stale below the bar
       `\x1b[${FOOTER_ROWS + down}A\r` +           // back to the caret's row
       (pos.cols > 0 ? `\x1b[${pos.cols}C` : "")
@@ -757,6 +763,10 @@ if (process.stdin.isTTY) {
       return;
     }
     if (following) {
+      // Ctrl+T expands/collapses the model's current Thought — the keyboard equivalent of the
+      // hover-click, so the fuller thought stays reachable with the mouse capture off (the
+      // capture is what would eat the scroll wheel; see hoverMouse).
+      if (key && key.ctrl && key.name === "t" && toggleActiveThought) toggleActiveThought();
       rl.line = "";
       rl.cursor = 0;
       rl.historyIndex = -1;
@@ -805,18 +815,24 @@ 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.
+// Mouse hover+click on the thinking line (task #96): turns ON xterm ANY-MOTION tracking for
+// the duration of a turn so we can HIGHLIGHT the line as the mouse hovers it AND expand it on
+// click. ?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.
+//
+// OFF BY DEFAULT, and it has to be: with ANY mouse reporting enabled the terminal hands us the
+// WHEEL events (SGR button 64/65) instead of scrolling its own scrollback, so the user cannot
+// scroll while a turn runs — and no tracking mode reports motion without also grabbing the
+// wheel, so hover and scrolling are mutually exclusive. Scrolling wins by default (it also
+// gives back native drag-to-select); `/hover` opts back into the mouse for a session, and
+// Ctrl+T expands the thought from the keyboard either way.
+let hoverMouse = false;
 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;
+  if (!hoverMouse || _mouseEnabled || !process.stdin.isTTY) return;
   process.stdout.write(MOUSE_ON);
   _mouseEnabled = true;
 };
@@ -1394,6 +1410,10 @@ let approvalResolve = null;
 // first — otherwise the 120ms ticker keeps redrawing that block on top of the picker and
 // its relative-cursor math lands on the wrong rows (duplicated/interleaved options).
 let clearActiveStatus = null;
+// The active turn's thought expand/collapse (its local toggle), or null between turns — lets
+// Ctrl+T reveal the full Thought from the KEYBOARD, so the feature doesn't depend on the mouse
+// capture that would block scrolling (see hoverMouse).
+let toggleActiveThought = null;
 function drawApprovalOptions(redraw) {
   // Two option lines, redrawn in place. On redraw the cursor sits one row below "No";
   // step up 2 rows, clear+rewrite both, landing back where we started.
@@ -1872,7 +1892,9 @@ 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 statusLines = 2; // TOTAL rows the status block occupies, bottom bar included (clearStatus)
+  // …of which these are the thought/word rows — the only ones hover + click hit-test against.
+  let statusContentLines = 2;
   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
@@ -1899,6 +1921,10 @@ async function runAgentTurn(history) {
   // the lifetime per-workspace + global counters once the turn completes.
   let latestOutputTokens = 0;
   let outputTokensPosted = false; // guard: increment the lifetime counters once per turn
+  // A new turn starts from zero on the bar's token row too — otherwise the previous turn's
+  // in/out figures would sit there, looking live, until the first poll reports real numbers.
+  lastTurnInputTokens = 0;
+  lastTurnOutputTokens = 0;
   // First few KB of the raw stream as consumed — a cheap fingerprint to verify the
   // completed resultText really EXTENDS what we streamed (an old worker replaces it
   // with the shorter bare answer, which must not be sliced by shownChars).
@@ -2020,16 +2046,23 @@ async function runAgentTurn(history) {
     // the playful-word line.
     const expLines = thoughtExpanded && rest ? wrapThought(rest, max, 4) : [];
     const drawn = 2 + expLines.length;
+    // The bottom bar rides along UNDER the live status while a turn runs, so it stays on screen
+    // the whole time the agent is thinking instead of only at the prompt. It's part of the same
+    // in-place block: the ticker redraws it every 120ms and clearStatus wipes it with the rest,
+    // so content still lands on clean rows.
+    const bar = process.stdout.isTTY ? footerRows() : [];
     const rows = process.stdout.rows || 24;
     // Hover-highlight only the THOUGHT line (line 1) — its exact viewport row comes from the
     // \x1b[6n probe below (`thoughtRow`); fall back to the viewport-bottom assumption only when
-    // the terminal never answered the probe.
-    const tRow = thoughtRow >= 1 ? thoughtRow : rows - drawn + 1;
+    // the terminal never answered the probe (the block's top = bottom minus ALL its rows).
+    const tRow = thoughtRow >= 1 ? thoughtRow : rows - (drawn + bar.length) + 1;
     const hovering = clickable && hoverRow === tRow;
     clearStatus();
     // Right after clearing, the cursor sits at the status block's TOP-LEFT = the thought line's
     // row. Probe for it (throttled) so hover/click hit-testing is exact wherever the block is.
-    if (process.stdin.isTTY && now - lastDsrAt > 400) { lastDsrAt = now; process.stdout.write("\x1b[6n"); }
+    // Only worth probing when the mouse is captured — thoughtRow exists for hover/click
+    // hit-testing, and with `/hover` off nothing reads it (and nothing would consume the reply).
+    if (hoverMouse && process.stdin.isTTY && now - lastDsrAt > 400) { lastDsrAt = now; process.stdout.write("\x1b[6n"); }
     // 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. Then the
     // GREY expanded lines (if any), then LAST the SPINNER + playful word + token labels
@@ -2042,8 +2075,10 @@ async function runAgentTurn(history) {
     let out = `${markLine(green(BULLET))}${hovering ? hoverThought(label) : green(label)}`;
     for (const wl of expLines) out += "\n" + GUTTER + dim(wl);
     out += "\n" + `${markLine(color256(wc, glyph))}${color256(wc, `${thinkWord}…`)}${tokLabel}`;
+    for (const br of bar) out += "\n" + br;
     process.stdout.write(out);
-    statusLines = drawn;
+    statusContentLines = drawn;
+    statusLines = drawn + bar.length;
     statusShown = true;
   };
   // 120ms so the spinner animates smoothly (the frame math above uses the wall clock, so
@@ -2061,15 +2096,24 @@ async function runAgentTurn(history) {
     if (!statusShown) return;
     const rows = process.stdout.rows || 24;
     const top = thoughtRow >= 1 ? thoughtRow : rows - statusLines + 1; // thought line row
-    // Toggle only on the thought line + its grey expansion — NOT the last row (the playful
-    // word / token line), so a click there doesn't expand what it isn't part of.
-    if (row < top || row > top + statusLines - 2) return;
+    // Toggle only on the thought line + its grey expansion — NOT the playful-word/token row,
+    // and NOT the bottom bar below it (statusContentLines excludes the bar), so a click there
+    // doesn't expand what it isn't part of.
+    if (row < top || row > top + statusContentLines - 2) return;
     // 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;
+    toggleThought();
+  };
+  // Same expand/collapse, reachable without the mouse: Ctrl+T while a turn runs (see
+  // toggleActiveThought). Ignored when there's nothing more to reveal, so it never flickers an
+  // empty expansion.
+  const toggleThought = () => {
     if (!thoughtExpanded && !(fullLiveThought && !runningCmd)) return;
     thoughtExpanded = !thoughtExpanded;
     clearStatus(); // next tick (≤120ms) redraws at the new size; keeps cursor math correct
   };
+  toggleActiveThought = toggleThought;
   const onMouseData = (chunk) => {
     if (!following) return;
     const s = chunk.toString("latin1");
@@ -2088,7 +2132,9 @@ async function runAgentTurn(history) {
       if (isPress && (btn & 0b11) === 0 && (btn & 64) === 0) onStatusClick(row); // left click → expand
     }
   };
-  if (process.stdin.isTTY) process.stdin.on("data", onMouseData);
+  // Only listen for reports when we're actually capturing the mouse — with `/hover` off there
+  // are none, and no \x1b[6n probe reply to consume either.
+  if (hoverMouse && process.stdin.isTTY) process.stdin.on("data", onMouseData);
   enableMouse();
 
   // Called right before any real (bullet/edit-card/answer) content prints: drop the
@@ -2412,6 +2458,12 @@ async function runAgentTurn(history) {
       if (Number.isFinite(job.agentOutputTokens) && job.agentOutputTokens > latestOutputTokens) {
         latestOutputTokens = job.agentOutputTokens;
       }
+      // Mirror both into the bottom bar's token row so it counts UP live while the turn runs
+      // (the bar rides under the status block now), instead of sitting on the last turn's
+      // figures until this one finishes. The turn-end assignment writes the same numbers again.
+      lastTurnInputTokens = latestCodeTokens;
+      lastTurnOutputTokens = latestOutputTokens;
+      lastTurnTotalOutput = globalOutputTokens + latestOutputTokens;
       const text = typeof job.resultText === "string" ? job.resultText : "";
       if (job.jobStatus === "completed") {
         // Task #104: fold this turn's output-token total into the lifetime per-workspace +
@@ -2561,6 +2613,7 @@ async function runAgentTurn(history) {
     clearInterval(ticker);
     clearStatus();
     clearActiveStatus = null; // no turn owns the status wiper between turns
+    toggleActiveThought = null; // …nor the Ctrl+T thought toggle
     // 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.
@@ -2806,6 +2859,21 @@ async function main() {
       printCommands();
       continue;
     }
+    if (line === "/hover") {
+      // Mouse hover/click on the thinking line (#96) vs. scrolling during a turn: the terminal
+      // only reports wheel events to US when mouse tracking is on, so they're exclusive. Off by
+      // default; this opts in for the session. Ctrl+T expands the thought either way.
+      hoverMouse = !hoverMouse;
+      console.log(
+        (hoverMouse ? green("hover: ON") : dim("hover: OFF")) +
+          dim(
+            hoverMouse
+              ? " — mouse hover/click expands the thinking line; scrolling and drag-select are captured while a turn runs.\n"
+              : " — scrolling and drag-select work during a turn; use Ctrl+T to expand the thinking line.\n"
+          )
+      );
+      continue;
+    }
     if (line === "/model") {
       await chooseModel();
       continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-cli",
-  "version": "1.0.371",
+  "version": "1.0.373",
   "description": "GoNext CLI — the gonext terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",