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

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/gonext_agent_chat.py

@@ -659,6 +659,36 @@ def _is_trivial_chat(text: str) -> bool:
     return bool(_TRIVIAL_CHAT.match(t))
 
 
+# The greeting/smalltalk set MINUS the coding-ambiguous words: in a registered
+# workspace (the `gonext` terminal), a bare "test"/"testing"/"ping" leans toward a
+# command ("run the tests"), so it should reach the agent, not be answered as chat.
+# This is the ONLY escape from workspace-mode's default-to-agent routing, so it must
+# stay tight — anything not obviously conversational is better handled as a task.
+_GREETING_SMALLTALK = re.compile(
+    r"^\s*(?:"
+    r"h(?:i+|ello+|ey+|iya|owdy)|yo|sup|wass?up|"
+    r"good\s*(?:morning|afternoon|evening|night|day)|greetings|"
+    r"thanks?(?:\s*you)?|thank\s*you|thx|ty|cheers|much\s*appreciated|"
+    r"bye+|goodbye|see\s*(?:ya|you)|cya|later|good\s*night|"
+    r"ok(?:ay)?|k|cool|nice|great|awesome|perfect|sounds\s*good|got\s*it|"
+    r"how\s*(?:are|r)\s*(?:you|u|ya)(?:\s*doing)?|how'?s\s*it\s*going|what'?s\s*up|"
+    r"who\s*(?:are|r)\s*(?:you|u)|what\s*(?:can|do)\s*you\s*do|what\s*are\s*you"
+    r")"
+    r"(?:\s+(?:there|everyone|all|bot|assistant|gonext|man|dude|buddy))?"
+    r"[\s!.?,'\"]*$",
+    re.IGNORECASE,
+)
+
+
+def _is_greeting_smalltalk(text: str) -> bool:
+    """Tighter than _is_trivial_chat (no test/ping) — the single chat escape from
+    workspace-mode default-to-agent routing."""
+    t = (text or "").strip()
+    if not t or len(t) > 60:
+        return False
+    return bool(_GREETING_SMALLTALK.match(t))
+
+
 # A weak/confused coding model sometimes "thinks out loud" in plain prose instead of
 # emitting the next tool call — e.g. a rambling, self-correcting scratchpad ("Wait,
 # actually... Let's try... Actually, let's just...") that can run thousands of chars.
@@ -2514,14 +2544,31 @@ def run_agent_chat(cfg):
                     and not _HOWTO_PREFIX_RE.match(t)
                     and _WS_ACTION_RE.search(t))
 
-    # Route: does this task need HTTP tool use? A trivial greeting/thank-you/"who are you"
-    # is caught LOCALLY (no model classifier call, no tool preamble) → straight to a fast
-    # small-prompt reply. Otherwise ask the model classifier.
-    if _is_trivial_chat(latest_user_text) and not _AGENT_KEYWORDS.search(latest_user_text or ""):
-        _log("router → NO (trivial greeting/smalltalk — local fast-path, no tool preamble)")
-        _emit({"type": "step", "text": "Routing your request…"})
+    # Routing. Two fundamentally different contexts:
+    #
+    # (A) WORKSPACE MODE (a folder is registered — i.e. the `gonext` terminal, or web
+    #     with a workspace): DEFAULT TO THE AGENT. The user opened a code folder and
+    #     registered it for the agent to read/edit/run — everything they type is
+    #     presumptively a task to DO, not a question to classify. We do NOT ask a model
+    #     classifier "does this need tools?" here: on a weak local model that guess is
+    #     unreliable, and every wrong guess sends an action request ("create a reactjs
+    #     project and start it", "do it for me") to plain chat, which can only hand back
+    #     instructions — the exact instability the user rejected. The ONLY escape is the
+    #     deterministic greeting/thanks fast-path, so "hi"/"thanks" stay instant instead
+    #     of spinning up the coding model. Anything else → agent, which still just
+    #     answers via final_answer when no tool is needed.
+    #
+    # (B) NO WORKSPACE (plain web chat): keep the keyword + model classifier — there are
+    #     no file/run tools to act with, so chat-vs-tool routing still earns its keep.
+    _emit({"type": "step", "text": "Routing your request…"})
+    if _is_greeting_smalltalk(latest_user_text) and not _AGENT_KEYWORDS.search(latest_user_text or ""):
+        _log("router → NO (greeting/smalltalk — local fast-path)")
         _emit({"type": "step", "text": "→ Chat reply"})
         needs_agent = False
+    elif _WS_AVAILABLE:
+        _log("router → YES (workspace registered → act by default, no classifier)")
+        _emit({"type": "step", "text": "→ Agent mode (workspace)"})
+        needs_agent = True
     else:
         needs_agent = _route(latest_user_text, agent_base_url, agent_api_key, agent_model_id)
     # A pending email awaiting 'confirm' must reach the agent even though a bare

package/package.json

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