@tiens.nguyen/gonext-local-worker 1.0.306 → 1.0.307

package/gonext-repl.mjs

@@ -297,15 +297,14 @@ rl.on("line", (l) => {
   // command's own output doesn't print over/under a stale hint block. If a menu item was
   // highlighted (↑/↓), RUN that command instead of the raw typed line.
   let submitted = l;
-  if (slashHintRows > 0) {
+  if (slashOverlayActive) {
+    // A highlighted menu item (↑/↓) RUNS that command instead of the raw typed line.
     if (slashSel >= 0 && slashNames[slashSel]) submitted = slashNames[slashSel];
-    process.stdout.write("\x1b[J");
-    slashHintRows = 0;
-    slashSel = -1;
-    slashNames = [];
+    closeSlashOverlay(); // wipe the menu, re-enable readline, restore history
+    // readline's own newline echo was suppressed during the overlay — emit it so the
+    // command's output starts on a fresh line, not over the ">> …" input line (#109).
+    process.stdout.write("\r\n");
   }
-  // Overlay is gone — restore readline history so ↑/↓ recall past tasks again (bug #109).
-  slashRestoreHistory();
   const clean = stripAnsiEscapes(submitted);
   if (_lineWaiter) {
     const w = _lineWaiter;
@@ -324,7 +323,6 @@ rl.on("line", (l) => {
 // runs the highlighted command, and it DISAPPEARS when you clear the slash — no permanent
 // scrollback copies. Relative cursor moves so it survives terminal scrolling.
 // (slashSel / slashNames / slashPrefix are declared above, near rl.on("line").)
-const inputCol = () => 4 + rl.cursor; // ">> " is 3 cols; content starts at col 4 (1-based)
 // While the slash-hint overlay is open, EMPTY readline's history so ↑/↓ don't recall a
 // history entry and trigger readline's OWN line-refresh — that refresh fought our overlay
 // and reprinted the whole ">> /" + hint block on every arrow press (bug #109). With no
@@ -345,32 +343,62 @@ function slashRestoreHistory() {
     rl.historyIndex = -1;
   }
 }
-function clearSlashHint() {
-  if (slashHintRows === 0) {
+// While the overlay is active WE own all terminal drawing: readline's own echo +
+// line-refresh are no-op'd (see slashOverlayActive in _writeToOutput/_refreshLine
+// below), exactly like the /server + approval pickers. That's what makes the redraw
+// stable — readline can't clearScreenDown over our menu or fight our cursor (bug #109,
+// which the earlier relative-cursor overlay hit whenever readline refreshed or the
+// 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.
+function renderSlashOverlay(sel) {
+  const line = rl.line;
+  const cmds = filteredCommands(line);
+  slashNames = cmds.map((c) => c.name);
+  if (sel >= cmds.length) sel = cmds.length - 1;
+  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);
+}
+
+// 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.
+function closeSlashOverlay() {
+  if (!slashOverlayActive) {
     slashRestoreHistory();
     return;
   }
-  process.stdout.write("\n\x1b[J" + `\x1b[1A\x1b[${inputCol()}G`);
+  process.stdout.write("\x1b7\n\x1b[J\x1b8"); // save, wipe below, restore to input line
+  slashOverlayActive = false;
   slashHintRows = 0;
   slashSel = -1;
   slashNames = [];
   slashRestoreHistory();
 }
-function drawSlashHint(prefix, sel) {
-  slashNeutralizeHistory();
-  const cmds = filteredCommands(prefix);
-  slashNames = cmds.map((c) => c.name);
-  if (sel >= cmds.length) sel = cmds.length - 1;
-  slashSel = sel;
-  const rows = hintRows(cmds, sel);
-  const body = rows.map((r) => "\x1b[K" + r).join("\n");
-  let out = "";
-  if (slashHintRows > 0) out += "\n\x1b[J\x1b[1A"; // wipe previous block, back to input row
-  out += "\n" + body; // draw below the input line
-  out += `\x1b[${rows.length}A\x1b[${inputCol()}G`; // back up to input line + column
-  process.stdout.write(out);
-  slashHintRows = rows.length;
-}
 if (process.stdin.isTTY) {
   process.stdin.on("keypress", (_ch, key) => {
     // An arrow-key list picker (/server) is up → ↑/↓ move the highlight, Enter chooses.
@@ -397,24 +425,27 @@ if (process.stdin.isTTY) {
     }
     // Enter is handled by rl.on("line") — don't redraw the hint on the way out.
     if (key && (key.name === "return" || key.name === "enter")) return;
-    // ↑/↓ while the menu is up = move the highlight IN PLACE. History is neutralized
-    // (slashNeutralizeHistory), so readline's ↑/↓ did nothing — the input line is intact
-    // and we just move the selection and redraw the hint below it (bug #109).
-    if (slashHintRows > 0 && key && (key.name === "up" || key.name === "down")) {
+    // ↑/↓ while the menu is up = move the highlight IN PLACE. readline drawing is
+    // suppressed (slashOverlayActive) and history neutralized, so its own ↑/↓ do
+    // nothing — we just move the selection and re-render the overlay (bug #109).
+    if (slashOverlayActive && key && (key.name === "up" || key.name === "down")) {
       rl.historyIndex = -1;
       const n = slashNames.length;
       if (n > 0) {
         slashSel =
           key.name === "down" ? (slashSel + 1 + n) % n : (slashSel - 1 + n) % n;
       }
-      drawSlashHint(slashPrefix, slashSel);
+      renderSlashOverlay(slashSel);
       return;
     }
     if (rl.line.startsWith("/")) {
-      slashPrefix = rl.line;
-      drawSlashHint(rl.line, -1); // typing resets the selection to none
-    } else {
-      clearSlashHint();
+      // Typing narrows the list and resets the selection to none.
+      renderSlashOverlay(-1);
+    } else if (slashOverlayActive) {
+      // The line no longer starts with "/" (e.g. backspaced the slash away): tear down
+      // the overlay and let readline redraw the now-normal line.
+      closeSlashOverlay();
+      rl._refreshLine();
     }
   });
 }
@@ -1115,7 +1146,9 @@ let globalOutputTokens = 0;
 // writes to stdout directly, so it's unaffected — only readline's echo is swallowed.
 const _origWriteToOutput = rl._writeToOutput ? rl._writeToOutput.bind(rl) : null;
 rl._writeToOutput = (s) => {
-  if (following || listPickerActive) return;
+  // slashOverlayActive: the slash-command overlay owns drawing (input line + menu), so
+  // readline's own echo must be swallowed or it fights the overlay (bug #109).
+  if (following || listPickerActive || slashOverlayActive) return;
   if (_origWriteToOutput) _origWriteToOutput(s);
   else process.stdout.write(s);
 };
@@ -1125,7 +1158,9 @@ rl._writeToOutput = (s) => {
 // ZERO terminal output.
 const _origRefreshLine = rl._refreshLine ? rl._refreshLine.bind(rl) : null;
 rl._refreshLine = () => {
-  if (following || listPickerActive) return;
+  // Suppress readline's line refresh (which does clearScreenDown → would wipe our menu)
+  // while the slash overlay owns the screen. We redraw the input line ourselves (#109).
+  if (following || listPickerActive || slashOverlayActive) return;
   if (_origRefreshLine) _origRefreshLine();
 };
 
@@ -2004,6 +2039,8 @@ async function main() {
         process.stdout.write(red("\n^C "));
       }
     } else {
+      // Ctrl+C at a prompt with the slash overlay open = dismiss the overlay first (#109).
+      if (slashOverlayActive) closeSlashOverlay();
       process.stdout.write(dim("\n(/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.

package/package.json

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