@tiens.nguyen/gonext-cli 1.0.358 → 1.0.360

package/gonext-repl.mjs

@@ -58,15 +58,64 @@ const white = (s) => `\x1b[37m${s}\x1b[0m`;
 // Left gutter so terminal output doesn't hug the edge (task #128, Phase 1). A terminal has
 // no CSS padding — a "left margin" is just a space prefix on every printed line, applied
 // consistently at the prompt, the ● bullets, plain replies, the banner and the live status
-// so they share ONE clean left edge. Existing secondary indents already use 2 spaces, so a
-// 2-space gutter converges everything to the same column. `gutterLines` insets a multi-line
-// block (blank lines left bare — no trailing whitespace).
-const GUTTER = "  ";
+// so they share ONE clean left edge. 3 spaces reads as a deliberate margin — 2 was too subtle
+// against the window edge (the padding fix). `gutterLines` insets a multi-line block (blank
+// lines left bare — no trailing whitespace).
+const GUTTER = "   ";
 const gutterLines = (s) =>
   String(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 + "  ";
+// 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`
+// is left untouched); `.` never crosses a newline, so a bold span stays on its own line. Ends
+// with \x1b[22m (bold-off) rather than a full \x1b[0m reset so any surrounding colour/gutter
+// styling survives. Applied to the completed agent answer (a whole string) — the live plain-
+// reply stream isn't marked up because ** can straddle a chunk boundary there.
+const renderMdBold = (s) =>
+  String(s).replace(/\*\*(?=\S)(.*?\S)\*\*/g, "\x1b[1m$1\x1b[22m");
+// Word-wrap a block to the terminal width so a long line does NOT soft-wrap back to column 0
+// and lose its left margin — instead we hard-break at word boundaries and re-apply `indent` to
+// EVERY continuation row (user-reported: wrapped answer lines had no padding on line 2+). A
+// single token longer than the line (e.g. a URL) is hard-split so it can't overflow. Existing
+// newlines (paragraph breaks / list items) are preserved; blank lines stay bare. The -1 guards
+// against a wide (emoji) char nudging the visible row one past the edge into a real soft-wrap.
+const wrapBlock = (text, indent, width) => {
+  const avail = Math.max(8, (width || 80) - indent.length - 1);
+  const rows = [];
+  for (const para of String(text).split("\n")) {
+    if (para === "") { rows.push(""); continue; }
+    let cur = "";
+    for (let w of para.split(/\s+/).filter(Boolean)) {
+      if (w.length > avail) {
+        if (cur) { rows.push(cur); cur = ""; }
+        while (w.length > avail) { rows.push(w.slice(0, avail)); w = w.slice(avail); }
+        cur = w;
+        continue;
+      }
+      const next = cur ? cur + " " + w : w;
+      if (next.length <= avail) cur = next;
+      else { rows.push(cur); cur = w; }
+    }
+    if (cur) rows.push(cur);
+  }
+  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).
+const renderAnswer = (answer) =>
+  wrapBlock(answer, OUTPUT_INDENT, process.stdout.columns || 80)
+    .map((l) => (l.length ? OUTPUT_INDENT + 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 —
@@ -1814,12 +1863,13 @@ async function runAgentTurn(history) {
     // 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 already
-    // use a 2-space indent = the gutter. Safe for the redraw: clearStatus clears whole lines
-    // and the hover/click hit-testing is ROW-based, so a horizontal offset changes nothing.
+    // 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)}`;
-    for (const wl of expLines) out += "\n  " + dim(wl);
-    out += "\n" + `  ${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`;
+    for (const wl of expLines) out += "\n" + GUTTER + dim(wl);
+    out += "\n" + `${GUTTER}${color256(wc, `${glyph} ${thinkWord}…`)}${tokLabel}`;
     process.stdout.write(out);
     statusLines = drawn;
     statusShown = true;
@@ -2647,9 +2697,15 @@ async function main() {
         // termination (killed terminal, force-quit) would otherwise lose the whole
         // session even though most of it completed fine.
         await saveSession(cwd, history);
-        // A plain-reply answer already streamed live in the loop above — printing it
-        // again here would just duplicate it; a blank line is enough for spacing.
-        console.log(shown ? "" : `\n\n${gutterLines(answer)}\n`);
+        // A plain-reply answer already streamed live in the loop above (shown=true) — printing
+        // it again here would just duplicate it, so only a spacer blank line. The AGENT answer
+        // (shown=false) is printed here from resultText, indented to the bullet-text column
+        // (renderAnswer) so it shares the ● bullets' left edge, and with ONE leading blank
+        // (LINE_SPACING) matching the between-bullets rhythm — was a hard "\n\n" double gap at
+        // the seam, bigger than the gaps between bullets above it (the seam padding fix).
+        // renderAnswer also WRAPS long lines and re-indents each continuation row, so a wrapped
+        // paragraph keeps the same left margin instead of soft-wrapping back to column 0.
+        console.log(shown ? "" : `${LINE_SPACING}${renderAnswer(answer)}\n`);
         // Task #104: persistent token footer at the bottom of the screen — this turn's
         // code-model INPUT + this turn's OUTPUT (↓ out), then the model's GLOBAL lifetime
         // output total (all turns for this user + coding server), labelled with the model
@@ -2658,7 +2714,8 @@ async function main() {
         if ((inputTokens ?? 0) > 0 || (turnOutputTokens ?? 0) > 0) {
           const coder = sessionCodingLabel || defaultCodingModel;
           console.log(
-            dim("tokens · ↑ in ") +
+            GUTTER +
+              dim("tokens · ↑ in ") +
               fmtTokens(inputTokens ?? 0) +
               dim(" · ") +
               cyan(`↓ out ${fmtTokens(turnOutputTokens ?? 0)}`) +

package/package.json

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