@tiens.nguyen/gu-cli 1.0.785 → 1.0.786

package/gu-repl.mjs

@@ -127,6 +127,7 @@ import {
   slashMenuWindow,
 } from "./terminal-layout.mjs";
 import { completedFlush, splitLiveStream } from "./completed-flush.mjs";
+import { isScaffoldStep, isGroupableStep, stepGroupRows, relativizePaths } from "./step-group.mjs";
 import { discoverSkills, matchSkillCommand } from "./skills.mjs";
 import { appendNew, archivePathFor, archivedWorkspaceKey, markReset, seedArchive } from "./conversation-archive.mjs";
 import { addAllowRule, listServers as listMcpServers } from "./mcp-config.mjs";
@@ -3280,14 +3281,27 @@ const hoverCtl = createHoverController({
   afterPaint: () => paintBar(),
 });
 
-/** One block's rows, painted: dim normally, full-bright while the pointer is on it. */
-const paintThoughtRows = (block, hovered) => {
+/**
+ * One block's rows, painted: dim normally, full-bright while the pointer is on it.
+ *
+ * TWO KINDS OF BLOCK share the registry, the hover and the click (#326): a THOUGHT (prose) and a
+ * group of the turn's look-ups (`kind: "steps"`, see step-group.mjs) — "searched code 3× · read
+ * lines 2×", one row until it is clicked open. They differ only in how their rows are made, so
+ * that is the one place they are told apart.
+ */
+const paintThoughtRows = (block, hovered, collapsed = block.collapsed) => {
+  const paint = (r) => (hovered ? hoverThought(r) : dim(r));
+  if (block.kind === "steps") {
+    return stepGroupRows(block.items, { width: thoughtWidth(), collapsed }).map(
+      (r) => (r.head ? markLine(dim(BULLET)) : GUTTER) + paint(r.text)
+    );
+  }
   const rows = thoughtBlockRows(block.prose, {
     width: thoughtWidth(),
-    collapsed: block.collapsed,
+    collapsed,
     lines: THOUGHT_COLLAPSED_LINES,
   });
-  return rows.map((r) => GUTTER + (hovered ? hoverThought(r) : dim(r)));
+  return rows.map((r) => GUTTER + paint(r));
 };
 
 /** Width available to a thought row: the screen, less the gutter it hangs in. */
@@ -3328,7 +3342,7 @@ function printThoughtBlock(raw, before) {
   // between, so the two really are continuous — grow it rather than start a new one. Any
   // bullet, blank or answer in between breaks contiguity, and a separate block is then right.
   const prev = thoughtBlocks[thoughtBlocks.length - 1];
-  if (prev && prev.collapsed && prev.to === transcript.dropped() + transcript.length() - 2) {
+  if (prev && !prev.kind && prev.collapsed && prev.to === transcript.dropped() + transcript.length() - 2) {
     const merged = prev.prose.replace(/\s+$/, "") + " " + prose;
     const grown = thoughtBlockRows(merged, {
       width: thoughtWidth(),
@@ -3607,12 +3621,7 @@ function hoverThoughtAtRow(row) {
 
 /** Swap one recorded block for its other form and repaint from the transcript. */
 function toggleThoughtBlock(block) {
-  const next = thoughtBlockRows(block.prose, {
-    width: thoughtWidth(),
-    collapsed: !block.collapsed,
-    lines: THOUGHT_COLLAPSED_LINES,
-  });
-  const painted = next.map((r) => GUTTER + dim(r));
+  const painted = paintThoughtRows(block, false, !block.collapsed);
   const newEnd = transcript.replaceRange(block.from, block.to, painted);
   if (newEnd === null) {
     // Scrolled out of the buffer — the block is gone, and so is the thing to toggle.
@@ -11263,6 +11272,67 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
   const openBullet = () => {
     if (!lastWasBlank) process.stdout.write("\n");
   };
+  // THE TURN'S LOOK-UPS AS ONE LINE (#326, step-group.mjs). `stepGroup` is the group still OPEN:
+  // the next look-up joins it and its row is rewritten where it sits. It stays open only while
+  // nothing but thoughts has been printed under it — an edit card, a command's result, a failure,
+  // an approval or the answer ends it, and the next look-up starts a new group below them.
+  let stepGroup = null;
+  const turnCwd = resolve(process.cwd());
+  /** The last finished transcript line — where a block must end to still be the tail. */
+  const transcriptTail = () => transcript.dropped() + transcript.length() - 2;
+  /** Is the open group still followed by nothing but thought blocks? */
+  const stepGroupStillOpen = () => {
+    if (!stepGroup || !barPinned() || scrolledBack()) return false;
+    let end = stepGroup.to;
+    const at = thoughtBlocks.indexOf(stepGroup);
+    if (at < 0) return false; // dropped from the registry (it is capped): no longer ours to rewrite
+    for (let i = at + 1; i < thoughtBlocks.length; i++) {
+      if (thoughtBlocks[i].from !== end + 1) return false;
+      end = thoughtBlocks[i].to;
+    }
+    return end === transcriptTail();
+  };
+  const addLookupStep = (text) => {
+    if (stepGroupStillOpen()) {
+      stepGroup.items.push(text);
+      const painted = paintThoughtRows(stepGroup, hoverCtl.hovered === stepGroup);
+      const newEnd = transcript.replaceRange(stepGroup.from, stepGroup.to, painted);
+      if (newEnd !== null) {
+        const delta = newEnd - stepGroup.to;
+        stepGroup.to = newEnd;
+        if (delta === 0) {
+          // Collapsed: one row before, one row after — rewrite that row and nothing else.
+          ui(thoughtBlockRepaintSeq(stepGroup));
+          paintBar();
+        } else {
+          // Open (the user clicked it mid-turn): it grew, and what is under it moved down.
+          for (const b of thoughtBlocks) {
+            if (b !== stepGroup && b.from > stepGroup.from) {
+              b.from += delta;
+              b.to += delta;
+            }
+          }
+          hoverCtl.reset();
+          paintLiveTail();
+        }
+        return;
+      }
+      stepGroup.items.pop(); // scrolled out of the buffer: it is history now — start a new one
+    }
+    stepGroup = null;
+    const block = { kind: "steps", from: 0, to: 0, items: [text], collapsed: true };
+    const painted = paintThoughtRows(block, false);
+    openBullet();
+    process.stdout.write(painted.join("\n") + "\n");
+    block.to = transcriptTail();
+    block.from = block.to - painted.length + 1;
+    // Unpinned (a window too short for the zone, or piped): nothing can be rewritten in place, so
+    // every look-up is its own line, as it always was — and there is no click to register for.
+    if (!barPinned()) return;
+    thoughtBlocks.push(block);
+    if (thoughtBlocks.length > 200) thoughtBlocks = thoughtBlocks.slice(-200);
+    stepGroup = block;
+  };
   // Chars of the CURRENT trailing (newline-less) `carry` line already flushed live — lets
   // a long plain-reply answer stream character-by-character instead of waiting for a "\n"
   // that might not arrive until the very end (most short replies have none at all).
@@ -11482,6 +11552,12 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
       }
       // 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.
+      // #326: the turn's own machinery ("Starting 1 MCP server(s)…", "Composing answer…", the
+      // retrieval tally the group line now carries) is live status, not history. --verbose keeps it.
+      if (!plainReplyFlow && !REPL_VERBOSE && isScaffoldStep(line)) {
+        lastContentAt = Date.now();
+        continue;
+      }
       if (alreadyFlushed === 0 && !(plainReplyFlow && !STREAM_PLAIN_REPLY)) onContent();
       if (plainReplyFlow) {
         // Plain-reply content IS the answer. When STREAMING, print it live (default colour) and
@@ -11509,8 +11585,17 @@ async function runAgentTurn(history, { attachJobId = "", ownJob = false } = {})
         // 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);
+        // Paths under this folder are shown relative to it (#326): the folder is on the bar.
+        const stepText = relativizePaths(line.trim(), turnCwd);
+        // A LOOK-UP joins the turn's open group — one counted row, a click away from the lines
+        // it stands for — instead of printing a line of its own.
+        if (isGroupableStep(stepText, bulletKind(stepText))) {
+          addLookupStep(stepText);
+          lastWasBlank = false;
+          continue;
+        }
+        const st = classifyBullet(stepText);
+        const bRows = wrapBlock(stepText, GUTTER, process.stdout.columns || 80);
         // One empty line above EVERY bullet now (see openBullet), which SUBSUMES the old
         // special case that opened only the turn's final phase — opensAnswerPhase's blank is
         // just one of these. Still idempotent, so it cannot double the seam the caller owns.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.785",
+  "version": "1.0.786",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",
@@ -110,6 +110,7 @@
     "install-path.mjs",
     "skills.mjs",
     "skill-source.mjs",
+    "step-group.mjs",
     "mcp-config.mjs",
     "mcp-command.mjs",
     "hooks-config.mjs",

package/step-group.mjs

@@ -0,0 +1,140 @@
+/**
+ * A TURN'S LOOK-UPS AS ONE LINE (task #326) — pure helpers; gu-repl.mjs does the drawing.
+ *
+ * Asked for after reading a Claude Code session beside a gu one. gu printed one "●" line per tool
+ * call — "Searching code → …", "Reading lines → …", again and again — so a turn that read six
+ * files and searched five times was thirty rows of scaffolding above a ten-row answer. Claude Code
+ * says the same thing in one line ("Searched for 2 patterns, read 6 files") and keeps the detail a
+ * click away. That is what a GROUP is: consecutive look-ups share one row, counted by kind, and a
+ * click opens it into the lines gu used to print.
+ *
+ * WHAT IS GROUPED: a neutral step of the shape "Label → detail" — the agent telling us what it
+ * looked at. NOT grouped, because each is something the user must be able to see at a glance:
+ * a failure (✗), a command's result (✓), an edit card, an approval, the answer.
+ *
+ * NOTHING HERE KNOWS A TOOL'S NAME. The kind is whatever stands before the arrow, so a tool added
+ * tomorrow is counted with no change here — the same rule the tool list itself follows (#37).
+ *
+ * SCAFFOLD LINES are the turn's machinery talking about itself ("Starting 1 MCP server(s)…",
+ * "Composing answer…", the retrieval tally the group line now carries): live status, not history.
+ * Still printed under --verbose.
+ */
+
+const ARROW = " → ";
+
+const SCAFFOLD = [/^Starting \d+ MCP server\(s\)…$/, /^Composing answer…$/, /^Found code by → /];
+
+/** The turn's own machinery, not something it did for the user. */
+export function isScaffoldStep(text) {
+  const t = String(text ?? "").trim();
+  return SCAFFOLD.some((re) => re.test(t));
+}
+
+/** "Searching code → seenNames (3 hits)" → "Searching code"; "" when the line has no such shape. */
+export function stepLabel(text) {
+  const t = String(text ?? "").trim();
+  const at = t.indexOf(ARROW);
+  if (at <= 0 || at > 40) return ""; // a sentence that merely contains an arrow is not a step
+  const label = t.slice(0, at).trim();
+  // A label is a few words ("Indexing project for RAG" is the longest the agent writes) — more
+  // than four is prose that happens to hold an arrow.
+  if (label.split(/\s+/).length > 4) return "";
+  return /^[A-Za-z][A-Za-z0-9 _.\-/]*$/.test(label) ? label : "";
+}
+
+/** Does this step join a group? `kind` is bulletKind()'s: only neutral ("info") steps do. */
+export function isGroupableStep(text, kind) {
+  return kind === "info" && !isScaffoldStep(text) && stepLabel(text) !== "";
+}
+
+// "Searching code" reads as work in progress; a finished group is said in the past. Only the first
+// word changes, and only when it is one of these — anything else is shown as the agent wrote it.
+const PAST = {
+  searching: "searched", reading: "read", listing: "listed", locating: "located", exploring: "explored",
+  calculating: "calculated", downloading: "downloaded", fetching: "fetched", checking: "checked",
+  calling: "called", indexing: "indexed", sending: "sent", deploying: "deployed",
+};
+
+function pastLabel(label) {
+  const [first, ...rest] = label.split(" ");
+  const past = PAST[first.toLowerCase()];
+  return past ? [past, ...rest].join(" ") : label;
+}
+
+/** "searched code 3× · read lines 2× · listed files" — kinds in the order they first happened. */
+export function stepGroupSummary(items) {
+  const counts = new Map();
+  for (const it of items ?? []) {
+    const label = stepLabel(it) || String(it ?? "").trim();
+    counts.set(label, (counts.get(label) ?? 0) + 1);
+  }
+  return [...counts].map(([label, n]) => pastLabel(label) + (n > 1 ? ` ${n}×` : "")).join(" · ");
+}
+
+function wrapWords(text, width) {
+  const rows = [];
+  let cur = "";
+  for (const word of String(text).trim().split(/\s+/)) {
+    const next = cur ? cur + " " + word : word;
+    if (next.length <= width) cur = next;
+    else {
+      if (cur) rows.push(cur);
+      // a word longer than the row (a path) is cut into row-sized pieces, never dropped
+      let w = word;
+      while (w.length > width) {
+        rows.push(w.slice(0, width));
+        w = w.slice(width);
+      }
+      cur = w;
+    }
+  }
+  if (cur) rows.push(cur);
+  return rows;
+}
+
+const clip = (text, width) => (text.length <= width ? text : text.slice(0, Math.max(1, width - 1)) + "…");
+
+const EXPAND_HINT = "  (click to expand)";
+const COLLAPSE_HINT = "(click to collapse)";
+
+/**
+ * The rows of one group: plain text, no colour, no gutter — the caller owns both.
+ * → [{ text, head }]; `head` marks a row that starts an entry (it gets the "●").
+ *
+ * COLLAPSED IS ALWAYS EXACTLY ONE ROW, whatever the width. The group is updated in place as the
+ * turn goes on, and a row that is always one row can be rewritten without moving anything below
+ * it — the lesson of every repaint bug in this terminal (#109, #321, #324): rows must not wrap,
+ * and what is on screen must stay what gu thinks is on screen.
+ *   one look-up  → the look-up itself (cut with "…" if it is too long; a click shows it whole)
+ *   several      → the counted summary, with the hint when there is room for it
+ */
+export function stepGroupRows(items, { width = 76, collapsed = true } = {}) {
+  const list = (items ?? []).map((x) => String(x ?? "").trim()).filter(Boolean);
+  const w = Math.max(20, width);
+  if (!list.length) return [];
+  if (collapsed) {
+    if (list.length === 1) return [{ text: clip(list[0], w), head: true }];
+    const summary = stepGroupSummary(list);
+    const withHint = summary + EXPAND_HINT;
+    return [{ text: withHint.length <= w ? withHint : clip(summary, w), head: true }];
+  }
+  const rows = [];
+  for (const item of list) wrapWords(item, w).forEach((text, i) => rows.push({ text, head: i === 0 }));
+  // Only a group that HAS a shorter form offers to go back to it.
+  if (list.length > 1 || rows.length > 1) rows.push({ text: COLLAPSE_HINT, head: false });
+  return rows;
+}
+
+/**
+ * Paths under the project folder, shown relative to it: "/Users/x/proj/src/a.ts:1-9" → "src/a.ts:1-9".
+ * Display only. The folder itself becomes "." so "Listing files → /Users/x/proj" still says where.
+ */
+export function relativizePaths(text, cwd) {
+  const root = String(cwd ?? "").replace(/[\\/]+$/, "");
+  const src = String(text ?? "");
+  if (!root || root.length < 2 || !src.includes(root)) return src;
+  const esc = root.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return src
+    .replace(new RegExp(esc + "[\\\\/]", "g"), "")
+    .replace(new RegExp(esc + "(?![\\w.-])", "g"), ".");
+}

package/terminal-layout.mjs

@@ -1038,6 +1038,10 @@ export function thoughtProse(buf) {
     // A leading pipe or quote survives some streams ("| Thought: …").
     .replace(/^\s*[|>\-]+\s*/, "")
     .replace(/^\s*Thought:\s*/i, "")
+    // …and the same label in the MIDDLE, glued to the sentence before it ("…the app does.Thought:
+    // I have all the file contents") — a model that reasons and then restates under the label
+    // (seen live, #326). It is a label, not a word of the thought: a space takes its place.
+    .replace(/(?<=\S)\s*\bThought:\s*/g, " ")
     .replace(/```[a-z]*\n?/gi, " ")
     .replace(/\s+/g, " ")
     .trim();
@@ -1735,7 +1739,12 @@ export function answerBlock({
   doneAt = Date.now(),
   inputLabel = "",
 } = {}) {
-  const rendered = render(worked ? `recap: ${answer}` : answer);
+  // NO "recap:" LABEL (#326). It was added when the answer arrived under a long list of step
+  // lines and needed saying what it was; the look-ups are one row now, so the answer is simply
+  // the bright text under them — and a label on it read as if a recap FOLLOWED the answer.
+  // `worked` is still accepted: callers pass it, and it is what a real recap line would gate on.
+  void worked;
+  const rendered = render(answer);
   const clock = formatClockTime(doneAt);
   // The stamp is DROPPED, not defaulted, when the time is unusable — "done Invalid Date" beside
   // a correct duration is worse than no stamp at all. The same for the input figure (#53): the
@@ -2619,6 +2628,11 @@ export function formatThinkTime(ms) {
 const _PICTOGRAPH =
   /[\p{Extended_Pictographic}\p{Emoji_Modifier}\p{Regional_Indicator}️‍]+[ \t]?/gu;
 
+// A KEYCAP ("1️⃣") is a digit + a variation selector + U+20E3, and only the selector is a
+// pictograph: stripping left "1⃣ What it is" — a digit wearing a combining box, which terminals
+// draw badly or over the next letter (seen live, #326). The model meant a numbered point: "1.".
+const _KEYCAP = /([0-9#*])\uFE0F?\u20E3/g;
+
 /**
  * The answer as PLAIN TEXT: decorative emoji removed (task #178).
  *
@@ -2643,7 +2657,7 @@ export function plainAnswer(text) {
         : // …and within prose, odd indices are inline code spans.
           part
             .split(/(`[^`\n]*`)/g)
-            .map((seg, j) => (j % 2 ? seg : seg.replace(_PICTOGRAPH, "")))
+            .map((seg, j) => (j % 2 ? seg : seg.replace(_KEYCAP, "$1.").replace(_PICTOGRAPH, "")))
             .join("")
     )
     .join("")