@tiens.nguyen/gonext-local-worker 1.0.198 → 1.0.199

package/gonext-repl.mjs

@@ -54,11 +54,16 @@ const CLEAR_LINE = "\r\x1b[K"; // carriage-return + erase-to-end-of-line
 // also drop the worker's ~~~ stream fences (they only matter to the web renderer).
 const isHeartbeatLine = (line) => /…\s?\(\d+s\)\s*$/.test(line);
 const isFenceLine = (line) => line.trim() === "~~~";
-// The model's raw Python code blob is delimited by <code>/</code> lines. We don't print
-// the tag lines themselves, but the code IN BETWEEN prints in a distinct grey (codeColor)
+// The model's raw Python code blob is delimited by <code>/</code> tags. We don't print
+// the tags themselves, but the code IN BETWEEN prints in a distinct grey (codeColor)
 // instead of dim prose, so it visually separates from the "Thought:" reasoning.
-const isCodeOpenLine = (line) => line.trim() === "<code>";
-const isCodeCloseLine = (line) => line.trim() === "</code>";
+// Tolerant matching, NOT exact-line: the raw token stream often mangles the tags —
+// glued to content ("<codecreate_folder(...)"), missing the ">", duplicated, or the
+// close tag stuck on the code's last line — and exact matching printed those
+// fragments literally in mixed colors (user-reported).
+const CODE_OPEN_RE = /^<code(?:\s*>)?/; // applied to line.trim()
+const CODE_CLOSE_RE = /<\/code>?\s*$/;
+const isBareCloseTag = (t) => /^<\/code>?$/.test(t);
 // The step summary the worker emits right after a tool call finishes (e.g.
 // "unzip_file(...) | → Unzipped 256 files…") duplicates what's already visible in the
 // gonext-local-worker daemon's own terminal — swallow it here to keep the REPL terse.
@@ -142,16 +147,19 @@ if (!workerKey || !apiBase) {
 // for piped/scripted input, harmless for interactive TTYs. Both ask() and the main
 // loop consume from this queue (never rl.question, to avoid double-capture).
 //
-// terminal: false — we draw our OWN prompt (cyan ">> ") and colorize output ourselves;
-// readline's default terminal:true (auto-enabled whenever output is a TTY) makes it ALSO
-// track cursor position and redraw the input line on every keystroke using ITS OWN
-// (empty, since we never call rl.setPrompt/rl.prompt) prompt — that tracking goes stale
-// the moment we write anything readline doesn't know about (which is everything we print
-// between prompts), and its next redraw emits a stray leading "[" (a malformed/partial
-// cursor-position escape) right before typed input, e.g. "[>> hi". With terminal:false,
-// readline stops managing the line/cursor itself; the OS's own canonical-mode terminal
-// still echoes keystrokes normally, and 'line' events fire exactly the same.
-const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+// terminal: true (on real TTYs) with readline OWNING the prompt via setPrompt/prompt().
+// History of this setting: plain terminal:true with a MANUALLY-written ">> " once caused
+// a stray "[" artifact — readline redrew the input line using its own (empty, never-set)
+// prompt and cursor tracking that our un-announced writes had made stale. The interim
+// fix (terminal:false) traded that for something worse: the OS's canonical line
+// discipline echoes raw CSI bytes, so arrows/Home/End showed literal "^[[D" and mid-line
+// editing didn't work at all (user-reported). Giving readline the prompt makes its
+// redraw math correct — rl.prompt() resets the cursor state after every burst of our
+// output — and raw mode means backspace/arrows/↑-history all behave like a normal shell.
+const IS_TTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: IS_TTY });
+const PROMPT = cyan(">> ");
+rl.setPrompt(PROMPT);
 // Side effect of terminal:false above: readline no longer intercepts arrow keys for
 // command-history recall, so pressing ↑/↓/→/← (or Home/End/Delete) sends the RAW escape
 // bytes straight through as literal input — the OS's own canonical line discipline
@@ -189,8 +197,13 @@ const nextLine = () =>
       ? Promise.resolve(null)
       : new Promise((res) => (_lineWaiter = res));
 const ask = async (q) => {
-  process.stdout.write(q);
+  // Route the question through readline's own prompt so its redraw logic stays
+  // consistent (a raw stdout write here would re-create the stale-cursor artifact
+  // that terminal:true mode is designed to avoid). Restored to ">> " afterwards.
+  rl.setPrompt(q);
+  rl.prompt();
   const a = await nextLine();
+  rl.setPrompt(PROMPT);
   return (a ?? "").trim();
 };
 
@@ -510,14 +523,48 @@ async function runAgentTurn(history) {
         }
         inEditCard = false; // card ended — fall through to normal handling
       }
-      if (!inCode && isCodeOpenLine(line)) {
-        stampIfThinking(); // hold/refresh the stamp; the code body commits it below
-        inCode = true;
-        continue;
+      {
+        const t = line.trim();
+        const openM = !inCode || t.startsWith("<code") ? CODE_OPEN_RE.exec(t) : null;
+        if (openM) {
+          // Enter code mode (or stay in it on a duplicate tag). Anything glued after
+          // the tag on the same line is code — print it, minus a glued close tag.
+          stampIfThinking(); // hold/refresh the stamp; the code body commits it below
+          inCode = true;
+          let rest = t.slice(openM[0].length).trim();
+          if (CODE_CLOSE_RE.test(rest)) {
+            inCode = false;
+            rest = rest.replace(CODE_CLOSE_RE, "").trim();
+          }
+          if (rest) {
+            onContent();
+            process.stdout.write(codeColor(rest) + "\n");
+            lastWasBlank = false;
+          }
+          lastContentAt = Date.now();
+          continue;
+        }
+        if (!inCode && isBareCloseTag(t)) {
+          // Stray close tag with no open in sight — swallow, never show it.
+          lastContentAt = Date.now();
+          continue;
+        }
       }
       if (inCode) {
-        if (isCodeCloseLine(line)) { inCode = false; lastContentAt = Date.now(); continue; }
-        if (line.trim() === "") { lastContentAt = Date.now(); continue; } // skip blank lines in code
+        const t = line.trim();
+        if (CODE_CLOSE_RE.test(t)) {
+          // Close tag, possibly with the code's last line glued in front of it.
+          const before = t.replace(CODE_CLOSE_RE, "").trim();
+          if (before) {
+            onContent();
+            process.stdout.write(codeColor(before) + "\n");
+            lastWasBlank = false;
+          }
+          inCode = false;
+          lastContentAt = Date.now();
+          continue;
+        }
+        if (t === "") { lastContentAt = Date.now(); continue; } // skip blank lines in code
         onContent();
         process.stdout.write(codeColor(line) + "\n");
         lastWasBlank = false;
@@ -637,20 +684,29 @@ async function main() {
       dim(`Resumed session: ${turns} prior turn(s) from last time in this folder — /reset to start fresh.\n`)
     );
   }
-  // With terminal:false, Ctrl-C is no longer intercepted by readline's raw-mode byte
-  // scanning (rl.on("SIGINT", …) would never fire) — it now delivers a real OS SIGINT to
-  // the process instead, which we catch directly here. Same behavior as before.
-  process.on("SIGINT", () => {
+  // Ctrl-C arrives on ONE of two paths depending on the readline mode: with
+  // terminal:true (real TTY) readline's raw-mode byte scanning intercepts \x03 and
+  // emits rl "SIGINT" (no OS signal is delivered); with terminal:false (piped input)
+  // the OS delivers a real SIGINT to the process. Attach the same handler to both —
+  // only one can ever fire for a given mode, so there's no double-handling.
+  const onInterrupt = () => {
     if (following) {
       followAborted = true;
       process.stdout.write(red("\n^C "));
     } else {
-      process.stdout.write(dim("\n(/exit to quit)\n") + cyan(">> "));
+      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.
+      rl.line = "";
+      rl.cursor = 0;
+      rl.prompt();
     }
-  });
+  };
+  process.on("SIGINT", onInterrupt);
+  rl.on("SIGINT", onInterrupt);
 
   for (;;) {
-    process.stdout.write(cyan(">> "));
+    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

package/package.json

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