@tiens.nguyen/gonext-cli 1.0.368 → 1.0.370

package/gonext-repl.mjs

@@ -642,25 +642,94 @@ if (process.stdout.isTTY) {
   });
 }
 // ---------- edit-mode bottom bar (display-only + Shift+Tab to cycle) ----------
-// A split line + a mode indicator shown just above the prompt each turn: "accept edits on"
-// (the agent applies file edits — today's behaviour) vs "manually edit". DISPLAY-ONLY for now
-// — it tracks the mode so the bar reflects it and Shift+Tab cycles it; wiring it to actually
-// gate the agent's edits is a deliberate follow-up.
+// A split rule + a mode indicator pinned BELOW the ">> " input line — the bar is the last
+// thing on screen and the user types ABOVE it: "accept edits on" (the agent applies file
+// edits — today's behaviour) vs "manually edit". DISPLAY-ONLY for now — it tracks the mode
+// so the bar reflects it and Shift+Tab cycles it; wiring it to actually gate the agent's
+// edits is a deliberate follow-up.
 let editMode = "accept"; // "accept" | "manual"
 const modeLineText = () =>
   white("✎ " + (editMode === "accept" ? "accept edits on" : "manually edit")) +
   dim("   (shift+tab to switch)");
-// The bar: a full-width dim rule (turn separator), then the gutter-inset mode line. Printed
-// above the prompt in the main loop.
-const modeBar = () =>
-  dim("─".repeat(process.stdout.columns || 80)) + "\n" + GUTTER + modeLineText();
-// Shift+Tab redraw: the mode line sits ONE physical row above the ">> " input line. Move up,
-// rewrite it, drop back, and let readline restore the input row + caret (cursor-relative, like
-// the status ticker / pickers, so it survives scrolling).
-const redrawModeLine = () => {
-  process.stdout.write("\x1b[1A\r\x1b[2K" + GUTTER + modeLineText() + "\x1b[1B\r");
-  rl._refreshLine();
+// Token usage for the bar's middle row (task #104): the LAST turn's code-model input +
+// output, then the coder's lifetime output total. Unlike the old per-turn print, this row is
+// ALWAYS on screen — a turn that did no code-model work honestly reads "0", and the lifetime
+// total is loaded at startup so the row is populated before the first turn.
+let lastTurnInputTokens = 0;
+let lastTurnOutputTokens = 0;
+// This turn's lifetime total. `globalOutputTokens` is updated by an async POST that can lag a
+// turn behind, so the bar takes whichever of the two is fresher (both are zeroed by a reset).
+let lastTurnTotalOutput = 0;
+const tokenLineText = () => {
+  const coder = sessionCodingLabel || defaultCodingModel;
+  return (
+    dim("tokens · ↑ in ") +
+    fmtTokens(lastTurnInputTokens) +
+    dim(" · ") +
+    cyan(`↓ out ${fmtTokens(lastTurnOutputTokens)}`) +
+    dim(" · ") +
+    dim(`${coder ? coder + " " : ""}total `) +
+    cyan(`↓ ${fmtTokens(Math.max(globalOutputTokens, lastTurnTotalOutput))}`)
+  );
 };
+const FOOTER_ROWS = 3; // the rule row + the token row + the mode row
+// 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;
+// Physical rows the prompt + typed line occupies (it wraps once past the terminal width) —
+// the bar goes under the LAST of them, not under the caret's row.
+const inputRows = () => {
+  const width = Math.max(20, process.stdout.columns || 80);
+  return Math.floor((PROMPT_COLS + rl.line.length) / width) + 1;
+};
+const cursorPos = () =>
+  (rl.getCursorPos ? rl.getCursorPos() : null) ?? { rows: 0, cols: PROMPT_COLS };
+// Draw the bar below the input line and put the caret back exactly where readline left it.
+// Relative moves only (same reason as the slash overlay): the block must survive the terminal
+// scrolling — and writing past the last screen row scrolls the input line up TOO, so the
+// 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) +
+      "\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` : "")
+  );
+}
+// Wipe the bar (and anything under it) WITHOUT touching the input line — called the instant
+// Enter is pressed so the command's output starts on clean rows instead of printing over the
+// rule and orphaning the mode line.
+function eraseFooter() {
+  const was = footerActive;
+  footerActive = false;
+  if (!was || !process.stdout.isTTY || slashOverlayActive) return;
+  const pos = cursorPos();
+  const down = Math.max(0, inputRows() - 1 - pos.rows) + 1; // first footer row
+  process.stdout.write(
+    `\x1b[${down}B\r\x1b[J\x1b[${down}A\r` + (pos.cols > 0 ? `\x1b[${pos.cols}C` : "")
+  );
+}
+// Shift+Tab redraw: the bar is below the caret, so a plain redraw in place is enough.
+const redrawModeLine = () => drawFooter();
+// Enter must tear the bar down BEFORE readline echoes its newline (which would land the
+// cursor on the rule row and leave the mode line orphaned below the output). Our normal
+// keypress listener runs AFTER readline's, so this one is prepended to run first.
+if (process.stdin.isTTY) {
+  process.stdin.prependListener("keypress", (_ch, key) => {
+    if (key && (key.name === "return" || key.name === "enter")) eraseFooter();
+  });
+}
 if (process.stdin.isTTY) {
   process.stdin.on("keypress", (_ch, key) => {
     // An arrow-key list picker (/server) is up → ↑/↓ move the highlight, Enter chooses.
@@ -1620,6 +1689,10 @@ rl._refreshLine = () => {
   if (following || listPickerActive || slashOverlayActive) return;
   if (secretInput) return; // don't redraw the typed key (task #127)
   if (_origRefreshLine) _origRefreshLine();
+  // That refresh ends with clearScreenDown — i.e. it just ERASED the bottom bar sitting
+  // under the input line. Redraw it here so every readline redraw (typing, backspace,
+  // history recall, rl.prompt(), a resize) repaints the bar as one atomic step.
+  drawFooter();
 };
 
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -2666,11 +2739,16 @@ async function main() {
     } else {
       // Ctrl+C at a prompt with the slash overlay open = dismiss the overlay first (#109).
       if (slashOverlayActive) closeSlashOverlay();
+      // Wipe the bottom bar before printing below the input line, or the note would land on
+      // the rule row and strand the mode line under it.
+      eraseFooter();
       process.stdout.write("\n" + GUTTER + dim("(/exit to quit)") + "\n");
       // Discard anything half-typed (Ctrl-C at a prompt means "never mind") and
-      // redraw through readline so its cursor tracking stays right.
+      // redraw through readline so its cursor tracking stays right — the refresh repaints
+      // the bar under the fresh prompt.
       rl.line = "";
       rl.cursor = 0;
+      footerActive = process.stdout.isTTY;
       rl.prompt();
     }
   };
@@ -2683,19 +2761,30 @@ async function main() {
   let lastCancelledTask = "";
 
   for (;;) {
-    // The bottom bar (split line + edit-mode indicator) sits just above the prompt each turn;
-    // the mode line is exactly ONE row above ">> " so Shift+Tab can redraw it in place.
-    if (process.stdout.isTTY) process.stdout.write(modeBar() + "\n");
+    // The bottom bar (split rule + edit-mode indicator) is pinned BELOW the input line, at
+    // the very bottom of the screen. Arming it here is all it takes: rl.prompt() refreshes
+    // the line, and our _refreshLine hook paints the bar underneath (and repaints it on
+    // every keystroke that erases it). Enter tears it down again.
+    footerActive = process.stdout.isTTY;
     rl.prompt();
-    // Absorb blank Enter-presses SILENTLY under the same prompt — without this, lines
-    // typed while the agent was busy on a long turn (queued, not yet read) all drain at
-    // once the moment the turn ends, each re-printing ">> " with no newline between them
-    // (e.g. ">> >> >> "). Only re-print the prompt for a genuine stdin close or input.
+    // Absorb blank Enter-presses SILENTLY — they never reach the agent. Lines typed while
+    // it was busy on a long turn (queued, not yet read) drain here all at once the moment
+    // the turn ends; a queued line carries no Enter keypress, so its re-prompt overwrites
+    // in place (\r + refresh) rather than stacking ">> >> >> " on one row.
     let lineRaw;
     for (;;) {
       lineRaw = await nextLine();
       if (lineRaw === null || lineRaw.trim()) break;
+      // A bare Enter: its keypress already tore the bar down, and readline left the caret on
+      // a fresh row with no prompt on it. Re-print the prompt so that row isn't blank — the
+      // refresh repaints the bar under it. (Queued lines drain with no keypress at all, so
+      // this re-prompt just overwrites in place and can't stack ">> " on one row.)
+      if (process.stdout.isTTY) {
+        footerActive = true;
+        rl.prompt();
+      }
     }
+    footerActive = false; // a line arrived from the queue (no Enter keypress) → disarm
     if (lineRaw === null) break; // stdin closed
     const line = lineRaw.trim();
     if (line === "/exit" || line === "/quit") break;
@@ -2776,6 +2865,9 @@ async function main() {
       const done = await resetGlobalOutputTokens();
       if (done) {
         globalOutputTokens = 0;
+        // The bar takes the FRESHER of the two totals, so the last turn's copy has to be
+        // zeroed too or the reset wouldn't show up in it.
+        lastTurnTotalOutput = 0;
         console.log(GUTTER + green("✓ global + workspace output-token totals reset to 0.\n"));
       } else {
         console.log(GUTTER + dim("Could not reset the output-token totals (API error).\n"));
@@ -2821,6 +2913,14 @@ async function main() {
     try {
       const { text: answer, shown, cancelled, inputTokens, outputTokens, turnOutputTokens } =
         await runAgentTurn(history);
+      // Feed the bottom bar's token row (task #104). Assigned for EVERY turn — including one
+      // that ended without an answer — so the row never shows a stale count from an older
+      // turn. It replaces the print-once-per-turn footer that used to live here: the bar is
+      // always on screen, so printing the same three figures into the scrollback right above
+      // it just read as a duplicate.
+      lastTurnInputTokens = inputTokens ?? 0;
+      lastTurnOutputTokens = turnOutputTokens ?? 0;
+      lastTurnTotalOutput = outputTokens ?? 0;
       if (answer) {
         history.push({ role: "assistant", content: answer });
         // Persist after every successful turn (not just on clean exit) — an ungraceful
@@ -2836,24 +2936,6 @@ async function main() {
         // renderAnswer also WRAPS long lines and re-indents each continuation row, so a wrapped
         // paragraph keeps the same left margin instead of soft-wrapping back to column 0.
         console.log(shown ? "" : `${LINE_SPACING}${renderAnswer(answer)}\n`);
-        // Task #104: persistent token footer at the bottom of the screen — this turn's
-        // code-model INPUT + this turn's OUTPUT (↓ out), then the model's GLOBAL lifetime
-        // output total (all turns for this user + coding server), labelled with the model
-        // name so it's clear which coder that running total belongs to. Guard on THIS turn's
-        // activity so a plain-reply greeting that did no code-model work shows nothing (#112).
-        if ((inputTokens ?? 0) > 0 || (turnOutputTokens ?? 0) > 0) {
-          const coder = sessionCodingLabel || defaultCodingModel;
-          console.log(
-            GUTTER +
-              dim("tokens · ↑ in ") +
-              fmtTokens(inputTokens ?? 0) +
-              dim(" · ") +
-              cyan(`↓ out ${fmtTokens(turnOutputTokens ?? 0)}`) +
-              dim(" · ") +
-              dim(`${coder ? coder + " " : ""}total `) +
-              cyan(`↓ ${fmtTokens(outputTokens ?? 0)}`)
-          );
-        }
       } else {
         history.pop(); // aborted/failed/cancelled turn — don't poison the next request
         // A turn that ended WITHOUT an answer (Ctrl+C cancel, or an abort/failure) must not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-cli",
-  "version": "1.0.368",
+  "version": "1.0.370",
   "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",