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

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 ## Unreleased
 
+- Compose capped in-progress rows before the Box paints its background, fixing elapsed tails leaking outside the tool background and restoring the block's bottom padding.
+
+- 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.
+- 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.

package/README.md

@@ -10,9 +10,10 @@ When several tool calls of the same type succeed in a row, Pi normally renders e
 - **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.
-- **Tool batches settle before grouping.** A tool batch stays ungrouped while any sibling call is active. Earlier groups remain stable while a later batch runs, then visually adjacent settled calls merge across assistant turns that rendered no prose.
+- **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.
 - **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.
-- **Partial and image results stay visible.** Streaming progress and image-bearing results are not collapsed into text-only groups.
+- **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.
 - **Ctrl+O restores full blocks.** Expanding tools (`setToolsExpanded(true)`) brings back Pi's individual full blocks, including complete error details and successful results.
 

package/package.json

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

package/src/index.ts

@@ -50,6 +50,7 @@ type ToolExecutionRow = {
     content?: Array<{ type?: unknown; text?: unknown }>;
     details?: Record<string, unknown>;
   };
+  rendererState?: { startedAt?: unknown; endedAt?: unknown };
   contentBox?: ComponentContainer;
   contentText?: TextComponent;
   selfRenderContainer?: ComponentContainer;
@@ -66,6 +67,10 @@ type PresentationPatchState = {
   theme?: ThemeLike;
   groupCache: WeakMap<ToolExecutionRow, GroupRenderCache>;
   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[]>;
+  rowSignatures: WeakMap<ToolExecutionRow, string>;
   originalRender: (width: number) => string[];
   originalUpdateDisplay: () => void;
   patchedRender?: (width: number) => string[];
@@ -227,6 +232,113 @@ function hasImageResult(row: ToolExecutionRow): boolean {
   );
 }
 
+function formatDuration(ms: number): string {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function bashDurationText(row: ToolExecutionRow): string | undefined {
+  const startedAt = row.rendererState?.startedAt;
+  const endedAt = row.rendererState?.endedAt;
+  if (
+    typeof startedAt !== "number" ||
+    typeof endedAt !== "number" ||
+    !Number.isFinite(startedAt) ||
+    !Number.isFinite(endedAt)
+  )
+    return undefined;
+  return formatDuration(Math.max(0, endedAt - startedAt));
+}
+
+function liveElapsedText(row: ToolExecutionRow): string | undefined {
+  if (row.toolName !== "bash") return undefined;
+  const startedAt = row.rendererState?.startedAt;
+  if (typeof startedAt !== "number" || !Number.isFinite(startedAt))
+    return undefined;
+  return formatDuration(Math.max(0, Date.now() - startedAt));
+}
+
+function isLiveRow(row: ToolExecutionRow): boolean {
+  return (
+    row.expanded === false &&
+    (row.isPartial !== false || !row.result) &&
+    row.getRenderShell?.() !== "self" &&
+    !hasImageResult(row)
+  );
+}
+
+function liveTailText(
+  row: ToolExecutionRow,
+  droppedVisible: boolean,
+  theme?: ThemeLike,
+): string | undefined {
+  if (!theme) return undefined;
+  const elapsed = liveElapsedText(row);
+  if (!droppedVisible && !elapsed) return undefined;
+  const parts: string[] = [];
+  if (droppedVisible) parts.push("…");
+  if (elapsed) parts.push("·", elapsed);
+  return theme.fg("muted", parts.join(" "));
+}
+
+function fitLiveHeader(
+  header: string,
+  tail: string,
+  width: number,
+  droppedVisible: boolean,
+): string {
+  const max = Math.max(1, width);
+  const head = header.trimEnd();
+  if (visibleWidth(head) + visibleWidth(tail) + 1 <= max)
+    return `${head} ${tail}`;
+  const headWidth = Math.max(1, max - visibleWidth(tail) - 1);
+  const headSuffix = droppedVisible ? "" : "…";
+  return `${truncateToWidth(head, headWidth, headSuffix, false)} ${tail}`;
+}
+
+// While a call streams or runs, pin it to a single header line with the
+// elapsed time inline, so the block never grows and never collapses on
+// completion; the header text simply settles into the outcome summary. The
+// cap is composed before the Box applies background and padding, so the live
+// line keeps the tool background edge to edge and the block's bottom padding.
+function capLiveRowDisplay(row: ToolExecutionRow, theme?: ThemeLike): void {
+  if (row.hasRendererDefinition?.()) {
+    const container = row.contentBox;
+    if (!container || !Array.isArray(container.children)) return;
+    const hadExtraChildren = container.children.length > 1;
+    removeResultComponent(container);
+    const original = container.children[0] as ComponentLike | undefined;
+    if (!original || typeof original.render !== "function") return;
+    container.children[0] = {
+      render(width: number): string[] {
+        const lines = original.render(width);
+        const headerIndex = lines.findIndex(hasVisibleContent);
+        if (headerIndex === -1) return lines;
+        const header = lines[headerIndex] ?? "";
+        const droppedVisible =
+          hadExtraChildren ||
+          lines.slice(headerIndex + 1).some(hasVisibleContent);
+        const tail = liveTailText(row, droppedVisible, theme);
+        return [
+          tail ? fitLiveHeader(header, tail, width, droppedVisible) : header,
+        ];
+      },
+      invalidate() {
+        original.invalidate();
+      },
+    };
+    return;
+  }
+
+  const text = row.contentText;
+  if (typeof text?.text !== "string" || typeof text.setText !== "function")
+    return;
+  const lines = text.text.split("\n");
+  const title = lines[0] ?? "";
+  const droppedVisible = lines.slice(1).some((line) => line.trim().length > 0);
+  const tail = liveTailText(row, droppedVisible, theme);
+  text.setText(tail ? `${title} ${tail}` : title);
+}
+
 function isCollapsibleSuccess(row: ToolExecutionRow): boolean {
   return (
     row.expanded === false &&
@@ -348,8 +460,10 @@ function outcomeSummary(row: ToolExecutionRow): string | undefined {
 
   const text = resultText(row);
   switch (row.toolName) {
-    case "bash":
-      return "done";
+    case "bash": {
+      const duration = bashDurationText(row);
+      return duration ? `done · ${duration}` : "done";
+    }
     case "read": {
       const lines = readLineCount(row, text);
       return `${lines} ${lines === 1 ? "line" : "lines"}`;
@@ -719,7 +833,41 @@ function renderContainerWithToolGroups(
       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");
       lines.push(...renderAt(index));
       continue;
     }
@@ -738,6 +886,7 @@ function renderContainerWithToolGroups(
       }
       if (isToolExecutionRow(candidate)) {
         if (!isCollapsibleSuccess(candidate)) break;
+        if (presentation.rowModes.has(candidate)) break;
         group.push(candidate);
         lastMemberIndex = candidateIndex;
         continue;
@@ -746,10 +895,12 @@ 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));
     index = lastMemberIndex;
   }
@@ -849,17 +1000,30 @@ function installPresentationPatch(): PresentationPatchState | undefined {
     const state: PresentationPatchState = {
       groupCache: new WeakMap(),
       rowVersions: new WeakMap(),
+      rowModes: new WeakMap(),
+      rowSignatures: new WeakMap(),
       originalRender: proto.render,
       originalUpdateDisplay: proto.updateDisplay,
     };
     const patchedUpdateDisplay = function updateDisplayWithCollapsedResult(
       this: ToolExecutionRow,
     ): void {
-      state.rowVersions.set(this, (state.rowVersions.get(this) ?? 0) + 1);
-      state.groupCache.delete(this);
+      // Group members always bump so their leader's cache refreshes; other
+      // rows only bump on state transitions, so bash's per-second invalidate
+      // 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.rowSignatures.get(this) !== signature
+      ) {
+        state.rowSignatures.set(this, signature);
+        state.rowVersions.set(this, (state.rowVersions.get(this) ?? 0) + 1);
+        state.groupCache.delete(this);
+      }
       state.originalUpdateDisplay.call(this);
       try {
-        collapseSuccessfulResult(this, state.theme);
+        if (isLiveRow(this)) capLiveRowDisplay(this, state.theme);
+        else collapseSuccessfulResult(this, state.theme);
       } catch {
         // Presentation is cosmetic; preserve Pi's renderer if its internals change.
       }