@pi-kaush/pi-tool-call-markers 0.3.8 → 0.3.10

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+- Give the codemode tool its own `¢¢` anchor and collapsed label. Codemode
+  rows used to collapse to a script preview; they now show the nested
+  calls the script ran (repeats deduped to `name ×N`) followed by the
+  script's `// @options:` params — `¢¢ read ×2, fffind · "max_output_tokens":
+2500, "timeout_ms": 120000` — so the row says what the script did and
+  how it ran. While the script streams, the call list grows live; scripts
+  with neither calls nor a parsable options line keep the generic args
+  summary, and click-to-expand still restores the full script and result.
+
 - Render an asked question as a user-input moment instead of a raw tool row.
   `ask_user_question` used to collapse to `│ * {"questions":…`, which is a tool
   call marker doing the work of a prompt. An asked question now takes the

package/README.md

@@ -21,7 +21,7 @@ Collapsed tool rows use semantic theme colors with no gear, background fill, box
 ```
 
 - **Two-column outer inset.** Tool markers and image output align with an inset conversation surface. Very narrow terminals reduce the decoration before useful content.
-- **`│` tool-call rail.** Every collapsed call anchors on a bold glyph instead of its tool name — `●` read, `+` write, `±` edit, `○` local search, `≡` ls, `↗` web search and fetch, and `$` bash; unmapped tools fall back to `*` — with a single space between the anchor and the call text, no joining colon. Grouped rows flow directly across tool types.
+- **`│` tool-call rail.** Every collapsed call anchors on a bold glyph instead of its tool name — `●` read, `+` write, `±` edit, `○` local search, `≡` ls, `↗` web search and fetch, `¢¢` codemode, and `$` bash; unmapped tools fall back to `*` — with a single space between the anchor and the call text, no joining colon. Grouped rows flow directly across tool types.
 - **Semantic, low-contrast status.** The anchor and the call content share the collapsed mute, pending state is warning-colored, and failures remain error-colored. Ordinary tool states have no background.
 - **Width-safe outcome tails.** Long summaries truncate before useful tails such as `→ done`, `→ 42 lines`, `→ +2/-1`, or a `bash` duration.
 - **Stable running groups.** Adjacent calls group as they appear, including settled failures, which stay error-colored inside the group. Pending state and elapsed `bash` time settle into the final outcome without changing the row count.

package/package.json

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

package/src/index.ts

@@ -42,6 +42,7 @@ const TOOL_CALL_GLYPHS: ReadonlyMap<string, string> = new Map([
   ["web_search", "↗"],
   ["fetch_content", "↗"],
   ["get_search_content", "↗"],
+  ["codemode", "¢¢"],
 ]);
 const PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v3");
 const LEGACY_PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v2");
@@ -835,6 +836,68 @@ function renderedCallSummary(
     : fgCollapsed(theme, "muted", "(no arguments)");
 }
 
+// Codemode carries its tunables in the script's first line —
+// `// @options: {"max_output_tokens": 2500, "timeout_ms": 120000}` — so a
+// collapsed row shows those params instead of a script preview. The
+// prefix and first-line handling mirror pi-codemode's parseCodemodeSource;
+// anything absent or unparsable returns undefined so the row keeps the
+// ordinary summary paths.
+const CODEMODE_OPTIONS_PREFIX = "// @options:";
+
+function codemodeOptionsLabel(row: ToolExecutionRow): string | undefined {
+  if (row.toolName !== "codemode") return undefined;
+  const code = (row.args as { code?: unknown } | undefined)?.code;
+  if (typeof code !== "string") return undefined;
+  const newline = code.indexOf("\n");
+  const head = newline === -1 ? code : code.slice(0, newline);
+  const firstLine = head.replace(/\r$/, "").trimStart();
+  if (!firstLine.startsWith(CODEMODE_OPTIONS_PREFIX)) return undefined;
+  const directive = firstLine.slice(CODEMODE_OPTIONS_PREFIX.length).trim();
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(directive);
+  } catch {
+    return undefined;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return undefined;
+  const params = Object.entries(parsed as Record<string, unknown>).map(
+    ([key, value]) => `${JSON.stringify(key)}: ${JSON.stringify(value)}`,
+  );
+  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.
+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>();
+  for (const call of calls) {
+    if (!isRecord(call)) continue;
+    const name = call.name;
+    if (typeof name !== "string" || name.length === 0) continue;
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  if (counts.size === 0) return undefined;
+  return [...counts]
+    .map(([name, count]) => (count > 1 ? `${name} ×${count}` : name))
+    .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
+// falls through to the ordinary summary paths.
+function codemodeCallLabel(row: ToolExecutionRow): string | undefined {
+  if (row.toolName !== "codemode") return undefined;
+  const parts = [codemodeCallsSummary(row), codemodeOptionsLabel(row)].filter(
+    (part) => part !== undefined,
+  );
+  return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+
 // 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`,
@@ -864,9 +927,13 @@ function collapsedSeam(
   // is gone once settled — while ordinary rows scrape the rendered call
   // line, which already drops its heading token.
   const selfRendered = row.getRenderShell?.() === "self";
-  const source = selfRendered
-    ? selfRenderedCallLabel(row)
-    : renderedCallSummary(row, budget, theme);
+  // Codemode rows pair the script's nested calls with its `@options` params;
+  // with neither, they fall through to the ordinary summary paths.
+  const source =
+    codemodeCallLabel(row) ??
+    (selfRendered
+      ? selfRenderedCallLabel(row)
+      : renderedCallSummary(row, budget, theme));
   const plain = sanitizeInline(stripAnsi(source)).trim();
   // The anchor stands in for the label's leading token. Only self-rendered
   // labels still carry it; a subagent fallback keeps `subagent` as its own

package/src/thinking-block-merger.ts

@@ -148,10 +148,23 @@ type MarkdownLikeChild = {
 // the italic default style is what identifies the trace: Pi passes it for
 // thinking content and for nothing else. Callers gate on the row actually
 // carrying thinking, so no other italic block is touched.
-function unitalicizeSettledThinking(row: AssistantMessageRow): void {
+// Pi 1.0 wraps each thinking child in a MouseRegion (click toggles
+// visibility); older versions hang the Markdown/Text directly. Walk both
+// shapes so the restyle reaches the node either way.
+function contentNodes(row: AssistantMessageRow): unknown[] {
   const children = row.contentContainer?.children;
-  if (!Array.isArray(children)) return;
+  if (!Array.isArray(children)) return [];
+  const nodes: unknown[] = [];
   for (const child of children) {
+    nodes.push(child);
+    const inner = (child as { child?: unknown } | undefined)?.child;
+    if (inner !== undefined && inner !== null) nodes.push(inner);
+  }
+  return nodes;
+}
+
+function unitalicizeSettledThinking(row: AssistantMessageRow): void {
+  for (const child of contentNodes(row)) {
     const markdown = child as MarkdownLikeChild | undefined;
     const style = markdown?.defaultTextStyle;
     if (style?.italic !== true) continue;
@@ -174,11 +187,9 @@ function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
     return;
   }
   const label = row.hiddenThinkingLabel;
-  const children = row.contentContainer?.children;
-  if (!Array.isArray(children)) return;
   if (!stylesThinkingLabels()) return;
   const styled = visibleThoughtLabel(label);
-  for (const child of children) {
+  for (const child of contentNodes(row)) {
     const textChild = child as TextLikeChild | undefined;
     if (
       typeof textChild?.text !== "string" ||