@tiens.nguyen/gonext-local-worker 1.0.322 → 1.0.325

package/gonext-repl.mjs

@@ -351,10 +351,64 @@ function slashRestoreHistory() {
 // menu was near the bottom of the screen and scrolled).
 let slashOverlayActive = false;
 
-// Redraw the input line (">> " + typed text) AND the command menu below it, fully
-// in place. On first activation we scroll N blank rows into existence below the input
-// line then return to it, so every later redraw writes into that reserved space
-// WITHOUT scrolling — which keeps the save/restore-cursor (ESC 7 / ESC 8) anchor valid.
+// Visible width of PROMPT (">> ") — used to put the caret back on the input line by
+// COLUMN, since the string itself carries color escapes that don't occupy cells.
+const PROMPT_COLS = 3;
+
+// Truncate to `max` VISIBLE columns, keeping the ANSI color escapes (which occupy no
+// cells) intact. Essential for the overlay: every row it draws must fit on ONE physical
+// terminal row — see slashOverlaySeq for why a wrapped row corrupts the redraw.
+function clipVisible(s, max) {
+  if (max <= 0) return "";
+  let out = "", seen = 0, sawEscape = false;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === "\x1b") {
+      const m = /^\x1b\[[0-9;]*m/.exec(s.slice(i));
+      if (m) { out += m[0]; i += m[0].length - 1; sawEscape = true; continue; }
+    }
+    if (seen >= max) return out + (sawEscape ? "\x1b[0m" : "");
+    out += s[i];
+    seen++;
+  }
+  return out;
+}
+
+// Build the exact bytes that draw the overlay: the input line (">> " + typed text) with
+// the command menu below it, caret left on the input line.
+//
+// Bug #109 v3 — the ↑/↓ stacking. TWO things have to hold for an in-place redraw, and the
+// old version got the first right and the second wrong:
+//
+//  1. NO ABSOLUTE ANCHOR. The old code re-anchored each redraw with DECSC/DECRC
+//     (ESC 7 / ESC 8), an absolute screen position, after pre-scrolling "reserved" rows
+//     into existence. There is one save slot per terminal and its meaning changes as soon
+//     as the screen scrolls, so it is fragile. Every move here is RELATIVE (ESC[nA) or
+//     column-absolute within the current row (ESC[nG), like drawList() (the /server
+//     picker), which has always redrawn correctly.
+//
+//  2. NO WRAPPED ROWS — this is what actually bit the user. `ESC[nA` moves up n PHYSICAL
+//     rows, but `n` here is the number of LOGICAL menu rows. On a narrow terminal a row
+//     like "  /model — switch the coding model for this session" occupies TWO physical
+//     rows, so the walk back up lands short, the next redraw's "\r ESC[2K" clears the
+//     wrong line, and a SECOND ">> /" + menu block is painted below the first — exactly
+//     the reported "it prints the item on every ↑". Verified in a terminal model: at 40
+//     columns the uncorrected version produces three prompt rows. So every row is clipped
+//     to the viewport width, which makes logical rows and physical rows the same thing.
+//     (This is also why the /server picker never showed the bug: its rows are short.)
+function slashOverlaySeq(line, cursor, menu, cols) {
+  const width = Math.max(20, cols || 80);
+  const n = menu.length;
+  let out = "\r\x1b[2K" + clipVisible(PROMPT + line, width - 1);
+  for (const r of menu) out += "\n\x1b[2K" + clipVisible(r, width - 1);
+  // Wipe anything left below (the filtered list can SHRINK as you type), then walk back
+  // up to the input line and park the caret at the typed-text offset.
+  out += "\x1b[J";
+  if (n > 0) out += `\x1b[${n}A`;
+  out += `\r\x1b[${Math.min(width, PROMPT_COLS + cursor + 1)}G`;
+  return out;
+}
+
+// Redraw the input line AND the command menu below it, fully in place.
 function renderSlashOverlay(sel) {
   const line = rl.line;
   const cmds = filteredCommands(line);
@@ -363,42 +417,45 @@ function renderSlashOverlay(sel) {
   slashSel = sel;
   slashPrefix = line;
   const menu = hintRows(cmds, sel);
-  const n = menu.length;
-
   if (!slashOverlayActive) {
     slashOverlayActive = true;
     slashNeutralizeHistory();
-    process.stdout.write("\n".repeat(n) + `\x1b[${n}A`); // reserve n rows, back to input
-    slashHintRows = n;
-  } else if (n !== slashHintRows) {
-    // The filtered list changed size: clear the old menu, re-reserve.
-    process.stdout.write("\x1b7\n\x1b[J\x1b8");
-    process.stdout.write("\n".repeat(n) + `\x1b[${n}A`);
-    slashHintRows = n;
   }
-
-  // Input line (carriage-return, clear, prompt + typed), then the menu below, anchored
-  // by ESC 7 (save at end of input) / ESC 8 (restore) so the caret ends on the input.
-  let out = "\r\x1b[2K" + PROMPT + line + "\x1b7";
-  for (const r of menu) out += "\n\x1b[2K" + r;
-  out += "\x1b8";
-  process.stdout.write(out);
+  slashHintRows = menu.length;
+  process.stdout.write(
+    slashOverlaySeq(line, rl.cursor ?? line.length, menu, process.stdout.columns)
+  );
 }
 
 // Close the overlay: erase the menu below, keep the typed input line, hand drawing back
 // to readline. Callers that changed the line to a non-slash value should refresh after.
+// Relative moves only, for the same reason as above.
 function closeSlashOverlay() {
   if (!slashOverlayActive) {
     slashRestoreHistory();
     return;
   }
-  process.stdout.write("\x1b7\n\x1b[J\x1b8"); // save, wipe below, restore to input line
+  process.stdout.write(
+    slashCloseSeq(rl.line, rl.cursor ?? rl.line.length, process.stdout.columns)
+  );
   slashOverlayActive = false;
   slashHintRows = 0;
   slashSel = -1;
   slashNames = [];
   slashRestoreHistory();
 }
+
+// Bytes that tear the menu down: repaint the input line, erase everything below it, and
+// leave the caret back on the input line at the typed-text offset.
+function slashCloseSeq(line, cursor, cols) {
+  const width = Math.max(20, cols || 80);
+  return (
+    "\r\x1b[2K" + clipVisible(PROMPT + line, width - 1) + // clean, non-wrapping input row
+    "\n\x1b[J" +                      // step below, erase the menu (and anything under it)
+    "\x1b[1A" +                       // back up to the input row (relative)
+    `\r\x1b[${Math.min(width, PROMPT_COLS + cursor + 1)}G`
+  );
+}
 if (process.stdin.isTTY) {
   process.stdin.on("keypress", (_ch, key) => {
     // An arrow-key list picker (/server) is up → ↑/↓ move the highlight, Enter chooses.
@@ -1779,9 +1836,21 @@ async function runAgentTurn(history) {
         continue;
       }
       if (line.trim() === "") {
-        // Several sources (swallowed routing lines, swallowed step summaries) each leave
-        // their own blank-line companion behind — collapse consecutive blanks into one.
-        if (!thinking && !statusShown && !lastWasBlank) {
+        // Vertical rhythm (task #115). Blank lines arrive from the worker unconditionally —
+        // every {"type":"step"} chunk is `text + "\n\n"`, and closeStreamFence() adds its
+        // own — but whether one was PRINTED used to depend on `!thinking && !statusShown`,
+        // i.e. on whether the status ticker happened to have redrawn its two-line block in
+        // the last ~120ms. Identical output rendered two different ways (reported live: the
+        // first ● bullet flush against the prompt, the next three each with a gap above).
+        // Spacing must not be a race, so neither term is consulted any more:
+        //   • ACTION stream → swallow every stream-borne blank. Bullets and edit cards form
+        //     ONE tight list (task #41); the blank line before the final answer is written
+        //     by the CALLER (`console.log(shown ? "" : "\n\n" + answer)`), not here.
+        //   • PLAIN-REPLY answer → this text IS the answer, so its blanks are real
+        //     paragraph breaks. Keep them (collapsing runs) and clear the status block
+        //     first, which is what the old `!statusShown` guard was really protecting.
+        if (plainReplyFlow && !lastWasBlank) {
+          onContent();
           process.stdout.write("\n");
           lastWasBlank = true;
         }

package/package.json

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