@tiens.nguyen/gonext-cli 1.0.360 → 1.0.362

package/gonext-repl.mjs

@@ -67,12 +67,14 @@ const gutterLines = (s) =>
     .split("\n")
     .map((l) => (l.length ? GUTTER + l : l))
     .join("\n");
-// The ● action bullets and the final agent answer are ONE block of agent output, so they share
-// one left edge: the bullet's TEXT column (GUTTER + "● " = GUTTER + 2). Without this the answer
-// sat at the bare GUTTER, 2 cols left of the bullet text above it — the ragged jog between the
-// actions and "Done!" (padding fix). Plain replies have no bullets, so they keep the GUTTER
-// margin (aligned with the >> prompt).
-const OUTPUT_INDENT = GUTTER + "  ";
+// The ● (and ⏺, the spinner glyph) are MARGIN MARKERS, not text — they HANG in the gutter so a
+// bullet's text lands on the SAME column as every other line (prompt, banner, plain reply, the
+// final answer). There is ONE text column (GUTTER) and the marker sits to its left, instead of
+// pushing bullet text 2 cols right of everything else. `markLine(glyph)` builds a GUTTER-wide
+// prefix: a 1-col glyph right-aligned before a single trailing space, so text starts at the
+// gutter column exactly like an un-marked line.
+const MARK_PAD = " ".repeat(Math.max(0, GUTTER.length - 2));
+const markLine = (glyph) => MARK_PAD + glyph + " ";
 // Render the model's inline **bold** as ANSI bold (markdown polish). The terminal has no
 // markdown renderer, so a heading like `**What I did:**` was printing its literal asterisks.
 // Only paired ** with non-space content between them is consumed (so a stray `**` or `a ** b`
@@ -110,18 +112,33 @@ const wrapBlock = (text, indent, width) => {
   return rows;
 };
 // The completed agent answer, ready to print: wrapped to the current terminal width, every row
-// re-indented to the bullet-text column (OUTPUT_INDENT) so line 2+ keeps the same margin, with
-// inline **bold** rendered per row (after wrapping, so the width math is on visible text).
+// indented to the shared text column (GUTTER) so it lines up with the bullets' text and the
+// rest of the output, with inline **bold** rendered per row (after wrapping, so the width math
+// is on visible text).
 const renderAnswer = (answer) =>
-  wrapBlock(answer, OUTPUT_INDENT, process.stdout.columns || 80)
-    .map((l) => (l.length ? OUTPUT_INDENT + renderMdBold(l) : l))
+  wrapBlock(answer, GUTTER, process.stdout.columns || 80)
+    .map((l) => (l.length ? GUTTER + renderMdBold(l) : l))
     .join("\n");
-// Vertical rhythm between ● action/answer bullets (task #129). One blank line so the list
-// breathes instead of being cramped. A knob: "" = the old tight list, "\n" = one blank.
-// Applied as a LEADING blank before a bullet when the previous line wasn't already blank —
-// so blanks land BETWEEN bullets, never trailing, and it's driven by `lastWasBlank` (what
-// was actually printed), NOT the status ticker, so it can't reintroduce the #115 race.
+// Wrap a PLAIN (uncoloured) banner/status string to the terminal width and re-indent every row
+// to GUTTER, colouring each row with `colorFn` — so a long startup line keeps its left margin
+// on wrap (narrow windows) instead of soft-wrapping back to column 0. Pass plain text: the
+// colour is applied per row, AFTER the width math (ANSI codes would otherwise skew the wrap).
+const wrapGutter = (plain, colorFn = (s) => s) =>
+  wrapBlock(plain, GUTTER, process.stdout.columns || 80)
+    .map((l) => (l.length ? GUTTER + colorFn(l) : l))
+    .join("\n");
+// The blank SEAM between the dim action log and the bright final answer (grouping, senior-UI
+// advice): the completed-action bullets are now a TIGHT group with no blanks between them, so
+// this one gap is what separates the "what I did" scaffolding from the deliverable. A knob:
+// "" = answer butts against the log, "\n" = one blank line. (Task #129 originally used this
+// BETWEEN every bullet; that read too loose once the bullets went dim — see the bullet write.)
 const LINE_SPACING = "\n";
+// Plain (chat) reply rendering. false = BUFFER the reply and print it WRAPPED at completion
+// (via renderAnswer, from the authoritative resultText) so long lines keep the left margin —
+// the thinking ticker animates during generation, then the wrapped answer appears. true = the
+// old live char-by-char stream, which reads nicely but SOFT-WRAPS a long line back to column 0.
+// This is the one knob to flip back to streaming if the buffered path ever misbehaves live.
+const STREAM_PLAIN_REPLY = false;
 // ANSI 90 ("bright black") — a reliable neutral grey across terminal themes, unlike
 // code 34 (blue) which many dark-theme palettes render as purple/indigo instead.
 const codeColor = (s) => `\x1b[90m${s}\x1b[0m`;
@@ -211,7 +228,23 @@ const fmtTokens = (n) => {
   if (n < 1_000_000) return `${(n / 1000).toFixed(n < 100_000 ? 1 : 0)}k`;
   return `${(n / 1_000_000).toFixed(1)}M`;
 };
-const BULLET = "●"; // a completed action
+const BULLET = "●"; // a neutral completed action (informational step)
+const CHECK = "✓"; // a step that succeeded
+const CROSS = "✗"; // a step that FAILED
+const brightText = (s) => s; // default terminal colour (un-dimmed) — the "pops" text weight
+// Classify a finished action bullet for the "spotlight the answer" hierarchy: successes and
+// neutral steps RECEDE (dim), a FAILURE POPS (red ✗ + full-bright text) — it's the one thing
+// the user must not miss while everything else is quiet. Keyed off the worker's step strings
+// ("Command finished/failed → …", "Server up → …", "App launched → …", "HTTP … → HTTP 2xx/4xx/
+// 5xx", "Searching/Downloading/Composing …"). Failure is checked FIRST so a failing HTTP or a
+// "failed" command never reads as success.
+const classifyBullet = (text) => {
+  if (/\bfail(ed|s|ure)?\b|\berror(ed)?\b|→\s*(?:HTTP\s*)?[45]\d\d\b/i.test(text))
+    return { mark: CROSS, markColor: red, textColor: brightText };
+  if (/^(?:Command finished|Server up|App launched)\b|→\s*(?:HTTP\s*)?2\d\d\b|\b(?:passed|succeeded|ready)\b/i.test(text))
+    return { mark: CHECK, markColor: green, textColor: dim };
+  return { mark: BULLET, markColor: dim, textColor: dim };
+};
 
 // ---------- flags ----------
 const argv = process.argv.slice(2);
@@ -345,7 +378,11 @@ const rl = createInterface({
   terminal: IS_TTY,
   completer: slashCompleter,
 });
-const PROMPT = GUTTER + cyan(">> ");
+// ">>" is a MARGIN MARKER like the ● bullets — it hangs in the gutter (no leading gutter) so
+// the user's typed input lands on the SAME text column (GUTTER+1) as the agent's bullets and
+// answer. ">> " is exactly GUTTER-wide, so input aligns; the ">>" right-edge sits at the same
+// column the ● / ✓ / ✗ markers hang at (markers right-aligned in the margin, text in one column).
+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
@@ -450,9 +487,9 @@ let secretInput = false;
 
 // 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.
-// Visible width of PROMPT = the gutter + ">> " (task #128). Used by the slash-overlay
-// cursor math to park the caret at the right column, so it must include the gutter.
-const PROMPT_COLS = GUTTER.length + 3;
+// Visible width of PROMPT = ">> " (3), since it now hangs with no leading gutter. Used by the
+// slash-overlay cursor math to park the caret at the input's text column (GUTTER+1 = col 4).
+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
@@ -735,16 +772,16 @@ async function ensureWorkspace() {
     }
     wsSync = { enabled: hit.allowSync !== false, name: hit.name, path: hit.path };
     console.log(
-      GUTTER +
-      dim(
+      wrapGutter(
         `workspace: ${hit.name} → ${hit.path} (run ${hit.allowRun ? "enabled" : "disabled"}` +
-          `${hit.allowSync !== false ? ", cloud sync on" : ""})`
+          `${hit.allowSync !== false ? ", cloud sync on" : ""})`,
+        dim
       )
     );
     return;
   }
   if (!existsSync(cwd) || !statSync(cwd).isDirectory()) return;
-  console.log(gutterLines(`This folder is not a registered workspace:\n  ${cwd}`));
+  console.log(wrapGutter(`This folder is not a registered workspace:\n  ${cwd}`));
   const register = await askYesNo(
     "Register it so the agent can read/edit code here?", true /* default Yes */
   );
@@ -1862,14 +1899,14 @@ async function runAgentTurn(history) {
     // underlined bright-green hover style when the mouse is over a clickable thought. Then the
     // GREY expanded lines (if any), then LAST the SPINNER + playful word + token labels
     // (task #83/#84), e.g. "  ⠙ Caffeinating… · 12.3k tok · 8.1k max".
-    // Gutter the live status block's first line (task #128) so the blinking ● lines up with
-    // the finished ● bullets during a turn (no left-edge jump). The sub-lines below use the
-    // same GUTTER so the whole block shares one left edge. Safe for the redraw: clearStatus
-    // clears whole lines and the hover/click hit-testing is ROW-based, so a horizontal offset
-    // changes nothing.
-    let out = `${GUTTER}${green(BULLET)} ${hovering ? hoverThought(label) : green(label)}`;
+    // The blinking ● and the spinner are hanging margin markers (markLine): the label/word land
+    // on the gutter text column, matching the finished ● bullets (no left-edge jump when a live
+    // action becomes a bullet). The expanded grey sub-lines are plain text at the gutter. Safe
+    // for the redraw: clearStatus clears whole lines and hover/click hit-testing is ROW-based,
+    // so a horizontal offset changes nothing.
+    let out = `${markLine(green(BULLET))}${hovering ? hoverThought(label) : green(label)}`;
     for (const wl of expLines) out += "\n" + GUTTER + dim(wl);
-    out += "\n" + `${GUTTER}${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`;
+    out += "\n" + `${markLine(color256(wc, glyph))}${color256(wc, `${thinkWord}…`)}${tokLabel}`;
     process.stdout.write(out);
     statusLines = drawn;
     statusShown = true;
@@ -2010,7 +2047,7 @@ async function runAgentTurn(history) {
       if (isEditCardHeader(line)) {
         onContent();
         inEditCard = true;
-        process.stdout.write(GUTTER + green("⏺") + bold(line.slice(1)) + "\n");
+        process.stdout.write(markLine(green("⏺")) + bold(line.slice(1).replace(/^\s+/, "")) + "\n");
         lastWasBlank = false;
         lastContentAt = Date.now();
         continue;
@@ -2094,7 +2131,9 @@ async function runAgentTurn(history) {
         //   • 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) {
+        // When buffering the plain reply, blanks live in resultText and are re-emitted by the
+        // caller's wrapped reprint — swallow them here (and keep the ticker up: no onContent).
+        if (plainReplyFlow && STREAM_PLAIN_REPLY && !lastWasBlank) {
           onContent();
           process.stdout.write("\n");
           lastWasBlank = true;
@@ -2109,27 +2148,44 @@ async function runAgentTurn(history) {
         const mRun = /^Running → (.+)$/.exec(line.trim());
         if (mRun) { runningCmd = mRun[1]; thinking = false; lastContentAt = Date.now(); continue; }
       }
-      if (alreadyFlushed === 0) onContent();
+      // Skip the status-clear for a BUFFERED plain reply (STREAM_PLAIN_REPLY=false): nothing
+      // prints yet, so the thinking ticker should keep animating until completion.
+      if (alreadyFlushed === 0 && !(plainReplyFlow && !STREAM_PLAIN_REPLY)) onContent();
       if (plainReplyFlow) {
-        // Plain-reply content IS the answer — print it in the default color and remember
-        // it's visible so the caller doesn't reprint it once the turn completes.
-        // Gutter (task #128) ONLY at line-start: when alreadyFlushed>0 this is a re-flush of
-        // a growing SAME physical line, so a gutter here would land mid-line.
-        process.stdout.write(
-          (alreadyFlushed === 0 ? GUTTER : "") + line.slice(alreadyFlushed) + "\n"
-        );
+        // Plain-reply content IS the answer. When STREAMING, print it live (default colour) and
+        // mark it shown so the caller doesn't reprint. When BUFFERING, only accumulate — the
+        // caller reprints the whole thing WRAPPED from resultText (shown stays false), so a long
+        // line keeps its margin instead of soft-wrapping. Gutter only at a line start.
         liveAnswer += line.slice(alreadyFlushed) + "\n";
-        answerShownLive = true;
+        if (STREAM_PLAIN_REPLY) {
+          process.stdout.write(
+            (alreadyFlushed === 0 ? GUTTER : "") + line.slice(alreadyFlushed) + "\n"
+          );
+          answerShownLive = true;
+        }
       } else {
-        // The remaining out-of-fence ACTION events ("Command passed → …", "Searching code
-        // → …", "Server up → …", "Composing answer…") each print as ONE solid bullet —
-        // the clean, summarized action list (task #41), now with a blank line between them
-        // for breathing room (task #129). The spacer is a LEADING blank emitted only when
-        // the previous line wasn't already blank → one gap BETWEEN bullets, none before the
-        // first (which follows the prompt) and none trailing. Deterministic (keyed off
-        // lastWasBlank, not the ticker) so #115's status-race stays fixed.
-        if (LINE_SPACING && !lastWasBlank) process.stdout.write(LINE_SPACING);
-        process.stdout.write(GUTTER + white(BULLET) + " " + line.trim() + "\n");
+        // The out-of-fence ACTION events ("Command finished/failed → …", "Server up → …",
+        // "Searching code → …", "Composing answer…") print as ONE solid bullet each — a clean,
+        // summarized action list (task #41). They form a TIGHT group now (no blank between them,
+        // superseding #129's uniform spacing): completed actions are dim scaffolding, so a
+        // compact grey log reads better than a sparse one, and the ONE blank that matters is
+        // before the bright answer (the caller's LINE_SPACING seam), separating the log from the
+        // deliverable. #115's status-race stays gone — there are simply no per-bullet blanks.
+        //
+        // Glyph vocabulary (senior-UI advice): a step that SUCCEEDED gets a green ✓ (with dim
+        // text — a receded success), a FAILURE gets a red ✗ + full-bright text so it POPS (the
+        // one thing not to miss), and a neutral/informational step keeps the dim ● . The marker
+        // hangs in the gutter (markLine); a long bullet wraps with every continuation row
+        // re-indented to the SAME gutter, so it shares one text column with the prompt/answer.
+        const st = classifyBullet(line.trim());
+        const bRows = wrapBlock(line.trim(), GUTTER, process.stdout.columns || 80);
+        process.stdout.write(
+          bRows
+            .map((r, i) =>
+              i === 0 ? markLine(st.markColor(st.mark)) + st.textColor(r) : GUTTER + st.textColor(r)
+            )
+            .join("\n") + "\n"
+        );
       }
       lastWasBlank = false;
     }
@@ -2137,7 +2193,8 @@ async function runAgentTurn(history) {
     // reply) and can take many seconds to generate — without this, nothing would print
     // until the whole thing finally lands, right back to the "wait then dump" problem
     // this was meant to fix. Only safe in the plain-reply flow (see plainReplyFlow above).
-    if (plainReplyFlow && !inCode && carry.length > carryFlushedLen) {
+    // Buffered mode skips this entirely — the reply is reprinted wrapped at completion.
+    if (STREAM_PLAIN_REPLY && plainReplyFlow && !inCode && carry.length > carryFlushedLen) {
       if (carryFlushedLen === 0) onContent();
       // Gutter (task #128) only at the pending line's START; a continuation appends bare.
       process.stdout.write(
@@ -2158,8 +2215,10 @@ async function runAgentTurn(history) {
       fullLiveThought = thoughtFull(fenceThought + carry); // #96: fuller thought for expand
     }
     // A non-empty remainder is a partial CONTENT line (heartbeats always arrive whole with
-    // a newline), so tokens are actively flowing — keep the ticker asleep.
-    if (carry.trim() !== "") lastContentAt = Date.now();
+    // a newline), so tokens are actively flowing — keep the ticker asleep. EXCEPT a buffered
+    // plain reply: nothing prints during generation, so let the ticker keep animating
+    // "Thinking…" (don't mark content as flowing) until the wrapped answer lands at completion.
+    if (carry.trim() !== "" && !(plainReplyFlow && !STREAM_PLAIN_REPLY)) lastContentAt = Date.now();
   };
 
   try {
@@ -2248,11 +2307,14 @@ async function runAgentTurn(history) {
         // nothing (the reported "Hello! How" cut) or a garbage tail. Verify with the
         // seenRaw fingerprint; on a mismatch, recover by answer-prefix instead: print
         // whatever of the final answer wasn't already shown live.
+        // Buffered plain reply: nothing streamed live (answerShownLive stays false), so skip
+        // the suffix reconciliation entirely — the caller reprints the whole reply WRAPPED from
+        // resultText (shown=false), which is also more truncation-proof than the live-stream math.
         const extendsStream = text.length >= shownChars && text.startsWith(seenRaw);
-        if (plainReplyFlow && extendsStream && text.length > shownChars) {
+        if (STREAM_PLAIN_REPLY && plainReplyFlow && extendsStream && text.length > shownChars) {
           consume(text.slice(shownChars));
           shownChars = text.length;
-        } else if (plainReplyFlow && !extendsStream && answerShownLive) {
+        } else if (STREAM_PLAIN_REPLY && plainReplyFlow && !extendsStream && answerShownLive) {
           const ans = answerFrom(text);
           let rest = ans.startsWith(liveAnswer) ? ans.slice(liveAnswer.length) : null;
           if (rest === null) {
@@ -2380,7 +2442,23 @@ async function runAgentTurn(history) {
 
 // ---------- REPL ----------
 async function main() {
-  console.log(GUTTER + cyan("GoNext agent REPL") + dim(` v${REPL_VERSION} · API ${apiBase} · key ${workerKey.slice(0, 8)}…`));
+  // Wrap the header so a narrow window doesn't soft-wrap "key wk_…" to column 0; keep the
+  // "GoNext agent REPL" label cyan on row 0, dim the rest (and any wrapped continuation rows).
+  {
+    const LABEL = "GoNext agent REPL";
+    const header = `${LABEL} v${REPL_VERSION} · API ${apiBase} · key ${workerKey.slice(0, 8)}…`;
+    console.log(
+      wrapBlock(header, GUTTER, process.stdout.columns || 80)
+        .map((l, i) =>
+          !l.length
+            ? l
+            : i === 0 && l.startsWith(LABEL)
+              ? GUTTER + cyan(LABEL) + dim(l.slice(LABEL.length))
+              : GUTTER + dim(l)
+        )
+        .join("\n")
+    );
+  }
   // Task #127, Phase 2: the REPL enqueues jobs that the polling DAEMON executes, so ensure
   // one is running — no GoTerminal needed. Idempotent + BC4-safe: startDaemon() no-ops when
   // a daemon (ours, GoTerminal's, or a manual one) is already alive. Best-effort; a failure
@@ -2427,14 +2505,15 @@ async function main() {
       await saveSessionRagMode(resolve(process.cwd()), sessionRagMode);
     }
     console.log(
-      GUTTER +
-      dim(
+      wrapGutter(
         `agent model: ${p.agentModelId || probe?.modelKey || "?"}` +
           (p.codingModelId ? ` · coder: ${p.codingModelId}` : "") +
           (p.ragEnabled ? ` · RAG ${sessionRagMode === "cloud" ? "cloud" : "local"}` : "") +
           ` · auto-test: ${sessionTestAuto ? "on" : "off"}` +
-          (selectedServer ? ` · deploy: ${selectedServer.name} (${selectedServer.user}@${selectedServer.host})` : "")
-      ) + (sessionTestAuto ? "" : dim(" (/test-auto to enable)"))
+          (selectedServer ? ` · deploy: ${selectedServer.name} (${selectedServer.user}@${selectedServer.host})` : "") +
+          (sessionTestAuto ? "" : " (/test-auto to enable)"),
+        dim
+      )
     );
     // Task #127, Phase 3: if the base chat model server isn't answering, offer to set it up
     // (download + start mlx_lm.server). BC3: only runs when NOTHING answers — an already-up
@@ -2494,14 +2573,14 @@ async function main() {
     }
     process.exit(1);
   }
-  console.log(GUTTER + dim("Ask about this repo. Type / to see commands (Tab completes). Ctrl-C aborts a running turn.\n"));
+  console.log(wrapGutter("Ask about this repo. Type / to see commands (Tab completes). Ctrl-C aborts a running turn.", dim) + "\n");
 
   const cwd = resolve(process.cwd());
   const history = await loadSession(cwd);
   if (history.length > 0) {
     const turns = history.filter((m) => m.role === "user").length;
     console.log(
-      GUTTER + dim(`Resumed session: ${turns} prior turn(s) from last time in this folder — /reset to start fresh.\n`)
+      wrapGutter(`Resumed session: ${turns} prior turn(s) from last time in this folder — /reset to start fresh.`, dim) + "\n"
     );
   }
   // Ctrl-C arrives on ONE of two paths depending on the readline mode: with

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-cli",
-  "version": "1.0.360",
+  "version": "1.0.362",
   "description": "GoNext CLI — the gonext terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",