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

package/gonext-repl.mjs

@@ -297,12 +297,13 @@ 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");
   }
   const clean = stripAnsiEscapes(submitted);
   if (_lineWaiter) {
@@ -322,27 +323,81 @@ 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)
-function clearSlashHint() {
-  if (slashHintRows === 0) return;
-  process.stdout.write("\n\x1b[J" + `\x1b[1A\x1b[${inputCol()}G`);
-  slashHintRows = 0;
-  slashSel = -1;
-  slashNames = [];
+// 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
+// history to recall, readline's ↑/↓ are inert and our keypress handler owns the highlight.
+// Restored the instant the overlay closes, so normal task-history recall still works.
+let _slashSavedHistory = null;
+function slashNeutralizeHistory() {
+  if (_slashSavedHistory === null && Array.isArray(rl.history)) {
+    _slashSavedHistory = rl.history;
+    rl.history = [];
+    rl.historyIndex = -1;
+  }
+}
+function slashRestoreHistory() {
+  if (_slashSavedHistory !== null) {
+    rl.history = _slashSavedHistory;
+    _slashSavedHistory = null;
+    rl.historyIndex = -1;
+  }
 }
-function drawSlashHint(prefix, sel) {
-  const cmds = filteredCommands(prefix);
+// 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;
-  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
+  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 = rows.length;
+}
+
+// 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("\x1b7\n\x1b[J\x1b8"); // save, wipe below, restore to input line
+  slashOverlayActive = false;
+  slashHintRows = 0;
+  slashSel = -1;
+  slashNames = [];
+  slashRestoreHistory();
 }
 if (process.stdin.isTTY) {
   process.stdin.on("keypress", (_ch, key) => {
@@ -370,26 +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, NOT recall shell history. readline
-    // already ran history-nav (may have changed the line); restore the typed "/…" prefix
-    // and redraw with the new selection.
-    if (slashHintRows > 0 && key && (key.name === "up" || key.name === "down")) {
-      rl.line = slashPrefix;
-      rl.cursor = slashPrefix.length;
+    // ↑/↓ 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;
       }
-      rl._refreshLine();
-      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();
     }
   });
 }
@@ -1090,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);
 };
@@ -1100,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();
 };
 
@@ -1979,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.305",
+  "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",