@pi-kaush/pi-tool-call-markers 0.3.15 → 0.3.17

package/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## Unreleased
 
+- Include bash command previews in collapsed codemode rows, with the total
+  bash call count before the first command preview. Every nested tool shows
+  its count, including ×1, on its first preview. Distinct commands
+  no longer disappear behind a generic bash count. Decode truncated argument
+  previews safely, keep live updates and width limits, and preserve native
+  expansion.
+
+- Draw subagent rows with the same faint rail as every other collapsed
+  tool call. They used a bold `│` of their own, and failed subagent plans
+  painted the rail in the error color.
+- Stop the thinking spinner from forcing full transcript redraws. Changing
+  a line above the viewport makes the terminal clear and replay the whole
+  transcript, and the live label kept animating after answer text pushed it
+  out of view. The label now settles when the answer or a tool call starts,
+  so its duration is the real thinking time. With several thinking runs in
+  one message, earlier runs show a static `│ * Thought`, and the current
+  run animates only while it is the message's last line.
+- Never animate over a click-revealed thinking trace or answer Markdown
+  that happens to equal the label.
+- Keep `/toggle-info` replay from bringing back thinking that a message's
+  final update dropped.
+
 - Fix assistant replies vanishing behind the thinking label. The label
   restyle matched any text node containing the label, so a reply that quoted
   `Thinking...` or `│ * Thought` was replaced by the label until Ctrl+T. Only

package/README.md

@@ -31,6 +31,25 @@ Collapsed tool rows use semantic theme colors with no gear, background fill, box
 - **User-run `!` bash blocks.** Execution display is owned here: user-typed commands trade Pi's green rules for the railed prompt shell (dark surface, status-colored rail) that submitted prompts use.
 - **Native expansion remains authoritative.** `Ctrl+O` restores Pi's full individual tool rendering, including complete results, custom renderers, and error details.
 
+## Codemode commands
+
+Collapsed codemode rows include bash command previews instead of only tool names:
+
+```text
+  │ ¢ bash ×1 npm test
+  │ ¢ bash ×2 git status --short, bash npm test
+```
+
+The first preview for each tool shows its total call count, including ×1.
+Distinct command previews remain separate. Identical previews appear only once.
+Long commands truncate to the row width. Pi can also truncate the stored
+argument preview; those commands keep an ellipsis. Calls without a usable
+command preview keep their tool name. Other nested tools show their
+name counts, including ×1, and script options follow the call list.
+
+Previews update while scripts run. Click a row or use Ctrl+O to restore Pi's
+native script, nested call status, and result details.
+
 ## Subagent plans
 
 A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, using the same `│` tool-call rail:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-kaush/pi-tool-call-markers",
-  "version": "0.3.15",
+  "version": "0.3.17",
   "description": "Compact and group Pi tool calls, with a bundled extension for adjacent thinking blocks.",
   "license": "MIT",
   "author": "Kaushik Gopal",

package/src/index.ts

@@ -24,8 +24,7 @@ import { isQuestionToolCall, renderQuestionBlock } from "./question-block.ts";
 import { sanitizeInline } from "./sanitize.ts";
 
 const OUTER_INSET = 2;
-const SUBAGENT_MARKER = "│";
-const GROUP_CALL_MARKER = "│";
+const TOOL_RAIL_MARKER = "│";
 // Collapsed rows anchor with a glyph instead of repeating the tool name;
 // tools that read as one family share a glyph, and unmapped tools fall back
 // to `*`. A single space separates the glyph from the call content: the
@@ -867,28 +866,66 @@ function codemodeOptionsLabel(row: ToolExecutionRow): string | undefined {
   return params.length > 0 ? params.join(", ") : undefined;
 }
 
-// The nested calls a script makes stream through result.details.calls with
-// a status per call — the clearest one-line account of what the script did
-// (or is doing, while partial). Repeats collapse to `name ×N` in first-seen
-// order; anything unshaped returns undefined.
+// Pi stores a JSON argument preview, capped at 200 characters. Long bash
+// commands can therefore end inside a JSON string. Decode only complete
+// escape sequences from a leading command field; never evaluate script text.
+function codemodeBashCommand(args: unknown): string | undefined {
+  if (typeof args !== "string") return undefined;
+  try {
+    const parsed: unknown = JSON.parse(args);
+    return isRecord(parsed) && typeof parsed.command === "string"
+      ? parsed.command
+      : undefined;
+  } catch {
+    if (!args.endsWith("...")) return undefined;
+    const prefix = args.slice(0, -3);
+    const match =
+      /^\{\s*"command"\s*:\s*"((?:[^"\\]|\\(?:["\\/bfnrt]|u[\da-fA-F]{4}))*)/.exec(
+        prefix,
+      );
+    if (!match) return undefined;
+    try {
+      const command: unknown = JSON.parse('"' + match[1] + '"');
+      const suffix = prefix[match[0].length] === '"' ? "" : "…";
+      return typeof command === "string" ? command + suffix : undefined;
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+// Show each tool's total count, including ×1, on its first preview.
+// Distinct previews remain visible; repeated previews take no extra space.
 function codemodeCallsSummary(row: ToolExecutionRow): string | undefined {
   const calls = row.result?.details?.calls;
   if (!Array.isArray(calls) || calls.length === 0) return undefined;
   const counts = new Map<string, number>();
+  const labels = new Map<string, { name: string; preview: string }>();
   for (const call of calls) {
     if (!isRecord(call)) continue;
     const name = call.name;
     if (typeof name !== "string" || name.length === 0) continue;
+    const command =
+      name === "bash" ? codemodeBashCommand(call.args) : undefined;
+    const preview = command === undefined ? "" : sanitizeInline(command).trim();
+    const label = preview ? name + " " + preview : name;
     counts.set(name, (counts.get(name) ?? 0) + 1);
+    labels.set(label, { name, preview });
   }
   if (counts.size === 0) return undefined;
-  return [...counts]
-    .map(([name, count]) => (count > 1 ? `${name} ×${count}` : name))
+  const shown = new Set<string>();
+  return [...labels.values()]
+    .map(({ name, preview }) => {
+      const count = counts.get(name) ?? 1;
+      const heading = !shown.has(name) ? name + " ×" + count : name;
+      shown.add(name);
+      return preview ? heading + " " + preview : heading;
+    })
     .join(", ");
 }
 
 // Codemode's collapsed label pairs what the script did with how it ran:
-// `read ×2, fffind · "max_output_tokens": 2500`. Without either part the row
+// `read ×2, fffind ×1 · "max_output_tokens": 2500`. Without either part the row
 // falls through to the ordinary summary paths.
 function codemodeCallLabel(row: ToolExecutionRow): string | undefined {
   if (row.toolName !== "codemode") return undefined;
@@ -898,11 +935,23 @@ function codemodeCallLabel(row: ToolExecutionRow): string | undefined {
   return parts.length > 0 ? parts.join(" · ") : undefined;
 }
 
+// One anchor builder for every collapsed row: the faint rail, then the
+// row's bold glyph when it has one — `│ ● src/a.ts`, `│ $ npm test`. A
+// subagent row anchors on the rail alone and keeps its `│ subagent …`
+// reading instead of a glyph.
+function collapsedAnchor(
+  theme: ThemeLike,
+  color: string,
+  glyph: string | undefined,
+): string {
+  const rail = `${fgCollapsedRail(theme, TOOL_RAIL_MARKER)} `;
+  return glyph === undefined
+    ? rail
+    : `${rail}${fgCollapsed(theme, color, glyph, true)} `;
+}
+
 // The collapsed-row seam lives here and nowhere else: which anchor a row
-// takes, how that anchor is styled, and the call text that follows it.
-// Anchors always render bold and take no joining colon — `│ ● src/a.ts`,
-// `│ $ npm test` — and subagent fallbacks keep their `│ subagent …`
-// reading instead of a glyph. Callers append the outcome tail.
+// takes, and the call text that follows it. Callers append the outcome tail.
 function collapsedSeam(
   row: ToolExecutionRow,
   width: number,
@@ -911,17 +960,12 @@ function collapsedSeam(
 ): { anchor: string; content: string } {
   const isBash = row.toolName === "bash";
   const isSubagent = row.toolName === "subagent";
-  const glyph = isBash
-    ? "$"
-    : (TOOL_CALL_GLYPHS.get(row.toolName ?? "") ?? "*");
-  const anchor = isSubagent
-    ? `${fgCollapsed(theme, color, SUBAGENT_MARKER, true)} `
-    : `${fgCollapsedRail(theme, GROUP_CALL_MARKER)} ${fgCollapsed(
-        theme,
-        color,
-        glyph,
-        true,
-      )} `;
+  const glyph = isSubagent
+    ? undefined
+    : isBash
+      ? "$"
+      : (TOOL_CALL_GLYPHS.get(row.toolName ?? "") ?? "*");
+  const anchor = collapsedAnchor(theme, color, glyph);
   const budget = Math.max(1, width - visibleWidth(anchor));
   // Self-rendered rows build their own `tool {args}` label — Pi's call title
   // is gone once settled — while ordinary rows scrape the rendered call
@@ -1209,7 +1253,7 @@ function renderSubagentPlan(
   const previewOf = (step: SubagentStep) =>
     fgCollapsed(theme, detailColor, ` ${subagentStepPreview(step.task)}`);
 
-  const marker = `${fgCollapsed(theme, color, SUBAGENT_MARKER, true)} `;
+  const marker = collapsedAnchor(theme, color, undefined);
   const budget = Math.max(1, width - visibleWidth(marker));
   const progress = subagentProgressText(row);
   const outcome = failed

package/src/thinking-block-merger.ts

@@ -210,12 +210,27 @@ function unitalicizeSettledThinking(row: AssistantMessageRow): void {
 // matches, and a candidate's plain text must equal the label exactly. Pi 1.0
 // wraps each thinking run in a MouseRegion; each child is judged on its own,
 // unwrapped when it has a wrapped inner.
-function hiddenLabelNodes(row: AssistantMessageRow): unknown[] {
+function hiddenLabelNodes(
+  row: AssistantMessageRow,
+  plainLabel: string,
+): Array<{ node: TextLikeChild; trailing: boolean }> {
   const children = row.contentContainer?.children;
   if (!Array.isArray(children)) return [];
-  return children
-    .map((child) => (child as { child?: unknown } | undefined)?.child ?? child)
-    .filter((node) => !isMarkdownLike(node));
+  const labels: Array<{ node: TextLikeChild; trailing: boolean }> = [];
+  children.forEach((child, index) => {
+    const node = ((child as { child?: unknown } | undefined)?.child ??
+      child) as TextLikeChild | undefined;
+    if (
+      isMarkdownLike(node) ||
+      typeof node?.text !== "string" ||
+      typeof node.setText !== "function" ||
+      plainText(node.text) !== plainLabel
+    ) {
+      return;
+    }
+    labels.push({ node, trailing: index === children.length - 1 });
+  });
+  return labels;
 }
 
 // Duck-typed, not `instanceof`: a locally loaded extension can resolve its
@@ -257,8 +272,15 @@ function animateLiveLabel(node: TextLikeChild, startedAt: number): void {
   };
 }
 
+// Pi gives every thinking run in a message the same label. Only the last
+// run is the current one; earlier runs read as settled so a line above later
+// content never changes. The current run animates only when it is the
+// message's last line and no tool rows render below the message: changing
+// a line above the viewport makes pi-tui clear and replay the transcript.
+// Otherwise it holds one spinner frame until it settles.
 function restyleHiddenThinkingLabel(
   row: AssistantMessageRow,
+  message: AssistantMessageLike,
   liveSince?: number,
 ): void {
   if (
@@ -269,20 +291,28 @@ function restyleHiddenThinkingLabel(
   }
   const label = row.hiddenThinkingLabel;
   if (!stylesThinkingLabels()) return;
-  const styled = visibleThoughtLabel(label);
-  const plainLabel = plainText(label);
-  for (const child of hiddenLabelNodes(row)) {
-    const textChild = child as TextLikeChild | undefined;
-    if (
-      typeof textChild?.text !== "string" ||
-      typeof textChild.setText !== "function" ||
-      plainText(textChild.text) !== plainLabel
-    ) {
-      continue;
+  const labels = hiddenLabelNodes(row, plainText(label));
+  const hasToolCalls =
+    Array.isArray(message.content) &&
+    message.content.some(
+      (block) => (block as { type?: unknown } | undefined)?.type === "toolCall",
+    );
+  labels.forEach(({ node, trailing }, index) => {
+    if (index < labels.length - 1) {
+      node.setText?.(visibleThoughtLabel(SETTLED_THOUGHT));
+      return;
     }
-    textChild.setText(styled);
-    if (liveSince !== undefined) animateLiveLabel(textChild, liveSince);
-  }
+    if (liveSince === undefined) {
+      node.setText?.(visibleThoughtLabel(label));
+    } else if (trailing && !hasToolCalls) {
+      node.setText?.(visibleThoughtLabel(label));
+      animateLiveLabel(node, liveSince);
+    } else {
+      node.setText?.(
+        visibleThoughtLabel(liveThinkingLabel(liveSince, liveSince)),
+      );
+    }
+  });
 }
 
 type ThinkingTiming = {
@@ -601,7 +631,7 @@ function installThinkingGroupingPatch():
             timing && timingLive(streaming, timing)
               ? timing.startedAt
               : undefined;
-          restyleHiddenThinkingLabel(this, liveSince);
+          restyleHiddenThinkingLabel(this, combined, liveSince);
         }
       } catch {
         // Keep Pi's native label styling if the row shape changes.