@tiens.nguyen/gonext-cli 1.0.359 → 1.0.361

package/gonext-repl.mjs

@@ -67,17 +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). `outputLines` insets a block to that shared edge.
-const OUTPUT_INDENT = GUTTER + "  ";
-const outputLines = (s) =>
-  String(s)
-    .split("\n")
-    .map((l) => (l.length ? OUTPUT_INDENT + l : l))
-    .join("\n");
+// 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`
@@ -87,6 +84,49 @@ const outputLines = (s) =>
 // 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
+// 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, GUTTER, process.stdout.columns || 80)
+    .map((l) => (l.length ? GUTTER + renderMdBold(l) : l))
+    .join("\n");
+// 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");
 // 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 —
@@ -706,16 +746,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 */
   );
@@ -1833,14 +1873,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;
@@ -1981,7 +2021,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;
@@ -2100,7 +2140,20 @@ async function runAgentTurn(history) {
         // 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");
+        // 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.
+        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)))
+            .join("\n") + "\n"
+        );
       }
       lastWasBlank = false;
     }
@@ -2351,7 +2404,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
@@ -2398,14 +2467,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
@@ -2465,14 +2535,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
@@ -2671,10 +2741,12 @@ async function main() {
         // 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
-        // (outputLines) so it shares the ● bullets' left edge, and with ONE leading blank
+        // (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).
-        console.log(shown ? "" : `${LINE_SPACING}${outputLines(renderMdBold(answer))}\n`);
+        // 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

package/package.json

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