@pi-kaush/pi-tool-call-markers 0.2.4 → 0.2.6

package/CHANGELOG.md

@@ -2,20 +2,27 @@
 
 ## Unreleased
 
-- Compact multiline singleton calls into one width-safe summary after settlement, including timeout metadata, while preserving the full native call under Ctrl+O.
-- 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.
-- 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 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.
+- Group consecutive tool blocks under one `%` marker with per-tool sub-headings and nested sub-bullets, dropping the blank lines between tool sections (F25's compact goal, with the hierarchy that makes it readable).
+- Render subagent calls as an unboxed plan — `% subagent` heading with chain/parallel counts and numbered steps as they execute, agent names in accent with emojis scraped from the native plan component (args fallback) — replacing the accent-rail card; failed subagents follow the full-red failure tone.
+- Strip display sequences and control bytes (notably `\r` from progress writers like git) from collapsed-row text so command output cannot return the cursor to column 0 and overwrite the row.
+- Color the truncation ellipsis to match its row tone (`muted` settled, `error` failed) instead of the terminal default foreground left by pi-tui's truncation reset.
+- Render failed tool rows entirely in `error` — marker, call label, and outcome tail including the arrow and truncation ellipsis — so errored calls stand out as full red lines.
+- Render settled tool rows in one uniform `muted` tone — group headings, bullets, summaries, and outcomes — while keeping `warning` pending and `error` failure states semantic.
+- Compose container-level rendering through the shared
+  `kg.pi.chatContainerHooks.v1` registry so grouping no longer shadows (or is
+  shadowed by) `pi-content-layout`'s system-message inset in either load order.
+- Label self-rendered `edit` rows by path (`edit <path>`), matching Pi's native
+  call line instead of dumping the raw `{ path, edits }` JSON payload.
+- Redesign collapsed tools as unboxed, background-free transcript lines with a two-column outer inset, `%` tool/group headings, `•` grouped children, and semantic low-contrast foregrounds with clear warning/error states.
+- Preserve compact outcomes, right-hand tail reservation, `bash` duration, errors, image output, quiet-turn grouping, grouped-render caching, and MCP/self-rendered tool labels in the new shell.
+- Keep expanded rows fully native so `Ctrl+O` restores complete results, custom renderers, and errors without collapsed decoration.
+- Label hidden local reasoning with Pi's native braille spinner sequence (`⠋ Thinking…`, `⠙ Thinking…`, …) while streaming and `+ Thought · X.Xs` when finalized; use `+ Thought` for restored messages and older runtimes without streaming metadata.
+- Track thinking duration per assistant row in a `WeakMap`, forward optional/future `updateContent` arguments, retain display-only adjacent thinking merging, and add no timer or render loop.
+- Feature-detect private tool and thinking component shapes and fail open to Pi's native rendering while retaining Pi `>=0.80.6` support.
+- Compact multiline singleton calls into one width-safe summary after settlement, including timeout metadata, while preserving the full native call under `Ctrl+O`.
+- Group adjacent calls while they are still running, update pending outcomes in place, and merge sequential calls across quiet assistant turns.
+- Add `PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL`, enabled by default, to optionally keep same-assistant-message calls individual.
+- Only invalidate grouped-render caches on meaningful state transitions.
 
 ## 0.1.2
 

package/README.md

@@ -1,34 +1,59 @@
 # @pi-kaush/pi-tool-call-markers
 
-Collapse Pi's adjacent successful tool calls into one compact, gear-headed block per tool type, so a run of similar calls reads as a tidy bulleted list instead of a wall of repeated headers and results.
+Give Pi's collapsed tool calls a quiet, width-safe transcript shell while preserving native details under `Ctrl+O`. The package also includes a display-only thinking-block adapter.
 
 ## What it changes
 
-When several tool calls run in a row, Pi normally renders each one as its own expanded block. This extension groups them:
+Collapsed tool rows use semantic theme colors with no gear, background fill, box padding, or filled blank rows:
 
-- **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 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 get the same treatment.** Tools that own their framing (e.g. MCP adapter rows) collapse to the same one-line summary — args label plus outcome — with pending, success, and error backgrounds; expanding restores their full custom render.
-- **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 an error-colored block: native collapsed detail for built-in tools, or a one-line summary with the first error line for self-rendered tools.
-- **Ctrl+O restores full blocks.** Expanding tools (`setToolsExpanded(true)`) brings back Pi's individual full blocks, including complete error details and successful results.
+```text
+  % Read
+    • src/a.ts                         42 lines
+    • src/b.ts                         18 lines
+```
+
+- **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 headings.** A singleton stays on one line when its summary and outcome fit. A multi-call group has one `%` heading per contiguous tool type.
+- **`•` grouped children.** Bullets appear only for members of a multi-call group.
+- **Semantic, low-contrast status.** Tool names are emphasized, summaries and settled metadata are muted, 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. Pending state and elapsed `bash` time settle into the final outcome without changing the row count.
+- **Quiet-turn grouping.** Sequential calls can join across an assistant row with no visible prose or thinking. Visible assistant content remains a boundary.
+- **MCP and self-rendered tools.** Their stable call labels, compact arguments, pending state, success, and first error line use the same collapsed shell. Native self-rendered details return when expanded.
+- **Images remain visible.** Image fallback text and terminal image components render below the corresponding marker with the same inset.
+- **Native expansion remains authoritative.** `Ctrl+O` restores Pi's full individual tool rendering, including complete results, custom renderers, and error details.
+
+## Subagent plans
+
+A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic:
+
+```text
+  % subagent chain (3 steps) [repo-review]
+    1. 🐝 bee [workhorse] Challenge the compatibility conclusion…
+    2. 🐝 bee …
+```
+
+Single calls stay on one `% subagent <agent> [profile] <task preview>` row; chain calls get a heading with the kind, count, and scope followed by numbered steps (parallel tasks list without numbers). Agent display names (emoji + name) are scraped from the native plan component with an args fallback, and render in `accent`; everything else stays muted, and failed subagents go full red. Subagents never join ordinary tool groups.
+
+Malformed, ambiguous, future, or too-narrow shapes fall back to the generic `% subagent …` collapsed row rather than dropping information, and `Ctrl+O` still exposes the native subagent renderer.
 
 ## Bundled thinking-block extension
 
-The package ships a second extension entrypoint, `src/thinking-block-merger.ts`. Pi loads it independently from the tool presentation extension, so its `AssistantMessageComponent` patch and shutdown lifecycle stay isolated while install, update, and removal remain one package operation.
+The second package entrypoint, `src/thinking-block-merger.ts`, combines only directly adjacent `thinking` blocks in a display copy. Tool calls, text, provider blocks, signatures, and stored session messages are unchanged.
 
-It combines only directly adjacent `thinking` blocks for display. Tool calls, text, and other content remain boundaries; provider blocks and signatures are not modified.
+When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoning uses these native-themed labels:
 
-## Install
+```text
+⠋ Thinking…  →  ⠙ Thinking…  →  …
++ Thought · 2.5s
+```
 
-After the first npm release:
+The live label samples Pi's native braille spinner sequence from the content updates Pi already renders; it does not add a timer. The adapter stores the first local streaming timestamp per assistant row in a `WeakMap`. A restored message or an older runtime with no streaming argument uses `+ Thought`. Visible-thinking mode remains native. There is no interval, timeout, render request, model call, or network work.
+
+## Install
 
 ```bash
-pi install npm:@pi-kaush/pi-tool-call-markers@0.1.0
+pi install npm:@pi-kaush/pi-tool-call-markers
 ```
 
 For local development:
@@ -41,7 +66,7 @@ pi \
 
 ## 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:
+Grouping calls from the same assistant message is enabled by default. Pi normally executes those calls in parallel. To keep same-message calls as individual compact rows while continuing to group sequential calls across quiet turns:
 
 ```fish
 set -lx PI_TOOL_CALL_MARKERS_COLLAPSE_PARALLEL 0
@@ -50,35 +75,37 @@ 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
+## Compatibility and fallback policy
 
-The tool presentation entrypoint currently relies on **guarded, reversible prototype patches** against two Pi component classes:
+**Compatible Pi version:** `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` `>=0.80.6`.
 
-- `ToolExecutionComponent` (render + display presentation),
-- `Container` (transcript grouping).
+Pi has no public hook for native tool rows, transcript grouping, or per-message hidden-thinking labels. The package therefore uses three small guarded prototype adapters:
 
-The bundled thinking-block entrypoint separately patches `AssistantMessageComponent.updateContent`. Its patch and lifecycle do not share state with tool presentation.
+- `ToolExecutionComponent` for collapsed presentation;
+- `Container` for adjacent grouping; and
+- `AssistantMessageComponent.updateContent` for display-only thinking merging and lifecycle labels.
 
-Pi exposes no public transcript or tool-grouping hook today, so the extension patches those prototypes and restores the originals on `session_shutdown`. Every patch is wrapped in `try`/`catch` with an idempotency guard (`Symbol.for(...)` markers), so if Pi's internals change the extension silently no-ops and Pi's default rendering is preserved.
+Each adapter feature-detects the fields and methods it needs, keeps the original method, uses an idempotency symbol, catches cosmetic failures, and restores the original on `session_shutdown` when it still owns the patch. Unsupported shapes fail open to Pi's native rendering. The thinking adapter continues adjacent merging even when the private label shape is unavailable.
 
-**Compatible Pi version:** `@earendil-works/pi-coding-agent` and `@earendil-works/pi-tui` `>=0.80.6`. Because the patches touch internal prototype methods, a future Pi release that renames or restructures those methods can silently disable the affected presentation until this package is updated. All original methods are restored on shutdown.
+Expanded tools always use Pi's native renderer. The collapsed tool shell owns its two-column inset directly; transcript layout extensions should leave tool rows unchanged, preventing load-order-dependent double padding.
 
-> TODO: migrate to a public Pi tool/transcript rendering API when one becomes available, and remove the prototype patches.
+> TODO: migrate these adapters to public Pi transcript and tool-rendering APIs when available.
 
 ## Design
 
 - No runtime dependencies.
-- Startup only registers `session_start` / `session_shutdown` handlers and installs the reversible patches; no I/O, subprocesses, model requests, or timers.
-- Grouped output is cached per row and invalidated when any member's display version changes, so repeated renders reuse work while stale groups refresh on demand.
-- Removing the package restores Pi's default rendering on the next session.
+- No mutation of tool arguments, tool results, provider content, or session messages.
+- Group output is cached per row and invalidated on meaningful display transitions.
+- No timers or independent render loops.
 
 ## Development
 
 From the repository root:
 
 ```bash
-npm ci --ignore-scripts
-npm run check
+npx vitest run extensions/pi-tool-call-markers/test
+npm run typecheck
+npm run package:check --workspace @pi-kaush/pi-tool-call-markers
 ```
 
 Inspect the publish payload:

package/package.json

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

package/src/container-hooks.ts

@@ -0,0 +1,57 @@
+// Shared chat-container composition contract. pi-content-layout and
+// pi-tool-call-markers each replace Container.prototype.render for different
+// concerns (system-text inset vs tool grouping), and a whole-container
+// wrapper always shadows whatever wrapped the prototype before it. Both
+// packages instead run every registered hook before rendering and restore
+// after, so child-level decoration composes in either load order. The
+// registry is a globalThis set keyed by a well-known symbol: no module
+// coupling, and an empty registry is a no-op when the other package is
+// absent. This file is a deliberate copy of pi-content-layout's contract
+// module: the Symbol key is the shared contract, duplicated to keep both
+// packages free of runtime dependencies on each other.
+
+export type ChatContainerHook = (
+  container: object,
+  children: unknown[],
+  width: number,
+) => (() => void) | undefined;
+
+export const CHAT_CONTAINER_HOOKS = Symbol.for("kg.pi.chatContainerHooks.v1");
+
+type HookRegistry = Set<ChatContainerHook>;
+
+export function chatContainerHooks(): HookRegistry {
+  const root = globalThis as Record<symbol, HookRegistry | undefined>;
+  const existing = root[CHAT_CONTAINER_HOOKS];
+  if (existing) return existing;
+  const created: HookRegistry = new Set();
+  root[CHAT_CONTAINER_HOOKS] = created;
+  return created;
+}
+
+export function runChatContainerHooks(
+  container: object,
+  children: unknown,
+  width: number,
+): () => void {
+  const restores: Array<() => void> = [];
+  if (Array.isArray(children)) {
+    for (const hook of chatContainerHooks()) {
+      try {
+        const restore = hook(container, children, width);
+        if (typeof restore === "function") restores.push(restore);
+      } catch {
+        // Hooks are cosmetic; one failing hook must not break rendering.
+      }
+    }
+  }
+  return () => {
+    for (const restore of restores.reverse()) {
+      try {
+        restore();
+      } catch {
+        // Best-effort restore; rendering already completed.
+      }
+    }
+  };
+}