@tiens.nguyen/gonext-cli 1.0.361 → 1.0.363

package/gonext-repl.mjs

@@ -127,12 +127,18 @@ const wrapGutter = (plain, colorFn = (s) => s) =>
   wrapBlock(plain, GUTTER, process.stdout.columns || 80)
     .map((l) => (l.length ? GUTTER + colorFn(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.
+// 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`;
@@ -222,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);
@@ -356,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
@@ -461,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
@@ -2105,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;
@@ -2120,38 +2148,42 @@ 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);
-        // Completed actions are SCAFFOLDING, not the deliverable — commit them DIM the instant
-        // they print (they're history the moment they land), so the eye lands on the full-bright
-        // final answer below (the "spotlight the answer" design). The loud "happening now"
-        // element stays the green live ticker, not this settled history. Dimming at print time
-        // (not re-colouring afterwards) avoids cursor-walking back over wrapped/scrolled rows.
-        // The ● is a hanging margin marker (markLine): text lands on the gutter column, and a
-        // long bullet wraps so every continuation row re-indents to that SAME gutter — the whole
-        // bullet shares one text column with the prompt/banner instead of soft-wrapping to col 0.
+        // 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(dim(BULLET)) + dim(r) : GUTTER + dim(r)))
+            .map((r, i) =>
+              i === 0 ? markLine(st.markColor(st.mark)) + st.textColor(r) : GUTTER + st.textColor(r)
+            )
             .join("\n") + "\n"
         );
       }
@@ -2161,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(
@@ -2182,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 {
@@ -2272,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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gonext-cli",
-  "version": "1.0.361",
+  "version": "1.0.363",
   "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",