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

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## 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.

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.16",
+  "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

@@ -866,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;