@pi-kaush/pi-tool-call-markers 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -6,13 +6,14 @@
 
 - Render in-progress calls as a single header line (elapsed time inline for `bash`) that settles into the final summary at the same height, so the transcript flows downwards without jumping.
 - Show the real duration in successful bash summaries (`→ done · 2.3s`) instead of dropping the elapsed time on completion.
-- Keep a call's settled shape stable once rendered: batches that settle next to an active sibling stay as individual one-liners instead of regrouping afterwards, which removes the second jump when a parallel batch completes.
+- Group adjacent calls while they are still running, so new bullets grow downward and successful settlement updates outcomes in place without upward reflow.
+- Add `PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL`, enabled by default, to keep same-assistant-message calls individual while still grouping sequential calls across quiet turns.
 - Only invalidate grouped-render caches on real state transitions, so bash's per-second ticks and resize invalidations stop busting them.
 
 - Keep failed calls collapsed by default while retaining their native error background and Ctrl+O expansion.
 - Add compact result tails for common successful tools in singleton and grouped summaries.
 - Keep grouped bullets to one line and preserve the useful result tail on narrow terminals.
-- Merge settled calls across assistant turns when no visible prose separates them, without reopening earlier groups while a later batch is active.
+- Merge calls across assistant turns as soon as they appear when no visible prose or thinking separates them.
 - Move adjacent thinking-block merging to a separate extension entrypoint bundled in this package.
 
 ## 0.1.2

package/README.md

@@ -4,14 +4,14 @@ Collapse Pi's adjacent successful tool calls into one compact, gear-headed block
 
 ## What it changes
 
-When several tool calls of the same type succeed in a row, Pi normally renders each one as its own expanded block. This extension groups them:
+When several tool calls run in a row, Pi normally renders each one as its own expanded block. This extension groups them:
 
 - **One gear header per contiguous tool type.** A run of `read` calls shares a single `⚙️ read` header; the following `write` run gets its own `⚙️ write` header.
 - **Bulleted call summaries.** Each call in a group becomes one bullet with a short summary and, for common tools, a compact outcome such as `→ done`, `→ 42 lines`, or `→ +2/-1`.
 - **Vertical spacing between tool types.** A blank line separates one tool group from the next.
 - **One-line, width-safe summaries.** Long targets truncate before their useful outcome tail instead of wrapping into taller blocks.
-- **Running calls stay one line.** While a call streams or executes, it renders as a single header line (with elapsed time inline for `bash`), so the transcript only grows downwards; the same line settles into the final `→ done · 2.3s`-style summary without changing height.
-- **Settled shapes never re-render.** A call's settled shape is decided the first time it renders settled and never changes afterwards. Batches that finish while a sibling is still active stay as individual one-liners instead of regrouping later; batches already settled on first render (e.g. restored history) still merge into groups across assistant turns that rendered no prose.
+- **Running calls group immediately.** Adjacent calls become bullets as they appear, and each pending marker or elapsed `bash` time updates to the final outcome in place. Successful settlement does not shrink the block, so the transcript only grows downwards.
+- **Sequential calls merge across quiet turns.** A later call joins the existing group immediately when no visible prose or thinking separates it; visible assistant content remains a hard boundary.
 - **Self-rendered tools keep their shell.** Tools that own their framing keep singleton previews intact. Grouped summaries use only their stable header instead of scraping preview or diff lines.
 - **Image results stay visible.** Image-bearing results are not collapsed into text-only groups. Partial text output is held back while a call runs and surfaces through the final summary.
 - **Errors stay compact and visibly failed.** A failed call keeps its own error-colored block and native collapsed detail until expanded.
@@ -39,6 +39,17 @@ pi \
   -e ./extensions/pi-tool-call-markers/src/thinking-block-merger.ts
 ```
 
+## Configuration
+
+Grouping calls from the same assistant message is enabled by default. Pi normally executes those calls in parallel. To keep those same-message calls as individual compact rows while continuing to group sequential calls across quiet turns, start Pi with:
+
+```fish
+set -lx PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL 0
+pi
+```
+
+`0`, `false`, `no`, and `off` disable parallel grouping. `1`, `true`, `yes`, and `on` enable it. The value is read when the extension loads.
+
 ## Compatibility and risk
 
 The tool presentation entrypoint currently relies on **guarded, reversible prototype patches** against two Pi component classes:

package/package.json

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

package/src/index.ts

@@ -18,6 +18,7 @@ const LEGACY_PRESENTATION_PATCHED = Symbol.for("kg.pi.toolPresentation.v2");
 const GROUPING_PATCHED = Symbol.for("kg.pi.toolGrouping.v1");
 const ANSI_RE = /\u001b\[[0-9;]*m/g;
 const BOLD_ON_RE = /\u001b\[1m/g;
+const COLLAPSE_PARALLEL_ENV = "PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL";
 
 type ThemeLike = {
   bold(text: string): string;
@@ -65,11 +66,11 @@ type ToolExecutionRow = {
 
 type PresentationPatchState = {
   theme?: ThemeLike;
+  collapseParallel: boolean;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
+  liveRenderedRows: WeakSet<ToolExecutionRow>;
   rowVersions: WeakMap<ToolExecutionRow, number>;
-  // A row's settled shape is decided the first time it renders settled and
-  // never changes afterwards, so live output only ever grows downwards.
-  rowModes: WeakMap<ToolExecutionRow, "individual" | ToolExecutionRow[]>;
+  rowGroups: WeakMap<ToolExecutionRow, ToolExecutionRow[]>;
   rowSignatures: WeakMap<ToolExecutionRow, string>;
   originalRender: (width: number) => string[];
   originalUpdateDisplay: () => void;
@@ -91,6 +92,14 @@ type GroupRenderCache = {
   width: number;
 };
 
+function envEnabled(name: string, defaultValue: boolean): boolean {
+  const value = process.env[name]?.trim().toLowerCase();
+  if (!value) return defaultValue;
+  if (["1", "true", "yes", "on"].includes(value)) return true;
+  if (["0", "false", "no", "off"].includes(value)) return false;
+  return defaultValue;
+}
+
 function stripAnsi(text: string): string {
   return text.replace(ANSI_RE, "");
 }
@@ -353,7 +362,7 @@ function isSettledToolRow(row: ToolExecutionRow): boolean {
   return row.isPartial === false && !!row.result;
 }
 
-function hasUnsettledToolInBatch(
+function hasToolSiblingInAssistantBatch(
   children: unknown[],
   index: number,
   renderAt: (index: number) => string[],
@@ -366,16 +375,31 @@ function hasUnsettledToolInBatch(
     ) {
       const candidate = children[candidateIndex];
       if (isAssistantMessageRow(candidate)) break;
-      if (isToolExecutionRow(candidate)) {
-        if (!isSettledToolRow(candidate)) return true;
-        continue;
-      }
+      if (isToolExecutionRow(candidate)) return true;
       if (renderAt(candidateIndex).some(hasVisibleContent)) break;
     }
   }
   return false;
 }
 
+function isGroupableToolRow(
+  row: ToolExecutionRow,
+  children: unknown[],
+  index: number,
+  renderAt: (index: number) => string[],
+  state: PresentationPatchState,
+): boolean {
+  if (!isLiveRow(row) && !isCollapsibleSuccess(row)) return false;
+  // Self-rendered tools can change height while active. Keep live instances
+  // individual so settling never collapses an already-painted preview.
+  if (row.getRenderShell?.() === "self" && state.liveRenderedRows.has(row))
+    return false;
+  return (
+    state.collapseParallel ||
+    !hasToolSiblingInAssistantBatch(children, index, renderAt)
+  );
+}
+
 function renderComponent(component: unknown, width: number): string[] {
   if (!component || typeof (component as ComponentLike).render !== "function")
     return [];
@@ -502,6 +526,17 @@ function renderedOutcome(
   return `${theme.fg("muted", "→")} ${theme.fg("success", summary)}`;
 }
 
+function renderedGroupedOutcome(
+  row: ToolExecutionRow,
+  theme: ThemeLike,
+): string | undefined {
+  const outcome = renderedOutcome(row, theme);
+  if (outcome) return outcome;
+  if (!isLiveRow(row)) return undefined;
+  const elapsed = liveElapsedText(row);
+  return theme.fg("muted", elapsed ? `· ${elapsed}` : "…");
+}
+
 function truncatePlain(text: string, width: number, suffix = "…"): string {
   const max = Math.max(0, width);
   const plain = stripAnsi(text);
@@ -678,7 +713,7 @@ function groupedCallComponent(
           previousToolName = row.toolName;
         }
         const call = renderedCallSummary(row, Math.max(1, width - 4), theme);
-        const outcome = renderedOutcome(row, theme);
+        const outcome = renderedGroupedOutcome(row, theme);
         lines.push(compactBulletLine(call, outcome, width, theme));
       }
       return lines;
@@ -742,9 +777,12 @@ function renderGroupedToolRows(
   const themeSample =
     theme.fg("toolTitle", "x") +
     theme.fg("muted", "x") +
+    theme.bg("toolPendingBg", "x") +
     theme.bg("toolSuccessBg", "x");
   const cached = state.groupCache.get(row);
+  const hasLiveMembers = rows.some(isLiveRow);
   if (
+    !hasLiveMembers &&
     cached &&
     cached.width === width &&
     cached.themeSample === themeSample &&
@@ -802,13 +840,17 @@ function renderGroupedToolRows(
   }
 
   const decorated = decorateHeader(row, lines, width, theme);
-  state.groupCache.set(row, {
-    lines: decorated,
-    members: [...rows],
-    memberVersions: rows.map((member) => state.rowVersions.get(member) ?? 0),
-    themeSample,
-    width,
-  });
+  if (hasLiveMembers) {
+    state.groupCache.delete(row);
+  } else {
+    state.groupCache.set(row, {
+      lines: decorated,
+      members: [...rows],
+      memberVersions: rows.map((member) => state.rowVersions.get(member) ?? 0),
+      themeSample,
+      width,
+    });
+  }
   return decorated;
 }
 
@@ -829,45 +871,10 @@ function renderContainerWithToolGroups(
 
   for (let index = 0; index < children.length; index++) {
     const child = children[index];
-    if (!isToolExecutionRow(child) || !isCollapsibleSuccess(child)) {
-      lines.push(...renderAt(index));
-      continue;
-    }
-    const decided = presentation.rowModes.get(child);
-    if (decided === "individual") {
-      lines.push(...renderAt(index));
-      continue;
-    }
-    if (Array.isArray(decided)) {
-      // A decided group is sticky, but transient states like Ctrl+O expansion
-      // still render members in full until they become collapsible again.
-      if (!decided.every(isCollapsibleSuccess)) {
-        lines.push(...renderAt(index));
-        continue;
-      }
-      const lastMember = decided[decided.length - 1];
-      let lastMemberIndex = index;
-      for (
-        let candidateIndex = index + 1;
-        candidateIndex < children.length;
-        candidateIndex++
-      ) {
-        if (children[candidateIndex] === lastMember) {
-          lastMemberIndex = candidateIndex;
-          break;
-        }
-      }
-      lines.push(...renderGroupedToolRows(child, decided, width, presentation));
-      index = lastMemberIndex;
-      continue;
-    }
-
-    // Undecided row: pick its settled shape once. A row that first settles
-    // next to an active sibling stays individual forever, so live batches
-    // never regroup after the fact; only batches that are fully settled on
-    // first render (e.g. restored history) become groups.
-    if (hasUnsettledToolInBatch(children, index, renderAt)) {
-      presentation.rowModes.set(child, "individual");
+    if (
+      !isToolExecutionRow(child) ||
+      !isGroupableToolRow(child, children, index, renderAt, presentation)
+    ) {
       lines.push(...renderAt(index));
       continue;
     }
@@ -885,8 +892,16 @@ function renderContainerWithToolGroups(
         continue;
       }
       if (isToolExecutionRow(candidate)) {
-        if (!isCollapsibleSuccess(candidate)) break;
-        if (presentation.rowModes.has(candidate)) break;
+        if (
+          !isGroupableToolRow(
+            candidate,
+            children,
+            candidateIndex,
+            renderAt,
+            presentation,
+          )
+        )
+          break;
         group.push(candidate);
         lastMemberIndex = candidateIndex;
         continue;
@@ -895,13 +910,16 @@ function renderContainerWithToolGroups(
     }
 
     if (group.length === 1) {
-      presentation.rowModes.set(child, "individual");
       lines.push(...renderAt(index));
       continue;
     }
 
-    for (const member of group) presentation.rowModes.set(member, group);
-    lines.push(...renderGroupedToolRows(child, group, width, presentation));
+    for (const member of group) presentation.rowGroups.set(member, group);
+    // An active member supplies the pending background. Once every call
+    // settles, the first member supplies the success background. Either way,
+    // the grouped row keeps the same number of lines.
+    const shellRow = group.find(isLiveRow) ?? child;
+    lines.push(...renderGroupedToolRows(shellRow, group, width, presentation));
     index = lastMemberIndex;
   }
 
@@ -998,9 +1016,11 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       return undefined;
 
     const state: PresentationPatchState = {
+      collapseParallel: envEnabled(COLLAPSE_PARALLEL_ENV, true),
       groupCache: new WeakMap(),
+      liveRenderedRows: new WeakSet(),
       rowVersions: new WeakMap(),
-      rowModes: new WeakMap(),
+      rowGroups: new WeakMap(),
       rowSignatures: new WeakMap(),
       originalRender: proto.render,
       originalUpdateDisplay: proto.updateDisplay,
@@ -1013,7 +1033,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       // ticks and resize invalidations stop busting caches.
       const signature = `${this.isPartial}|${this.expanded}|${this.result ? 1 : 0}|${this.result?.isError ? 1 : 0}`;
       if (
-        Array.isArray(state.rowModes.get(this)) ||
+        state.rowGroups.has(this) ||
         state.rowSignatures.get(this) !== signature
       ) {
         state.rowSignatures.set(this, signature);
@@ -1032,6 +1052,7 @@ function installPresentationPatch(): PresentationPatchState | undefined {
       this: ToolExecutionRow,
       width: number,
     ): string[] {
+      if (!isSettledToolRow(this)) state.liveRenderedRows.add(this);
       const lines = state.originalRender.call(this, width);
       try {
         return decorateHeader(this, lines, width, state.theme);