@pi-kaush/pi-tool-call-markers 0.2.8 → 0.2.10

package/CHANGELOG.md

@@ -2,6 +2,35 @@
 
 ## Unreleased
 
+- Add `/toggle-info`: hide tool calls and thinking entirely, or restore them
+  collapsed. Execution rows (including user-run `!` blocks) are lifted out of
+  the render pass via the shared chat-container hook; thinking blocks are
+  stripped before Pi builds the label/expanded block and replayed on restore.
+  Every session starts visible, and Ctrl+O/Ctrl+T behavior is unchanged when
+  visible. The toggle state lives on globalThis because Pi loads each package
+  entrypoint through jiti with module caching disabled — module-level state
+  would otherwise be duplicated between entrypoints.
+- Adopt Pi's native content-color split in collapsed rows: tool names ride
+  `toolTitle` and call content/outcomes ride `toolOutput` (structural
+  chrome stays muted; failed rows stay uniformly error).
+- Tint the collapsed "+ Thought" label with the session's active
+  thinking-level token (thinkingOff…thinkingMax), re-tinting on
+  thinking_level_select; the expanded thinking block is untouched. The
+  PI_TOOL_CALL_MARKERS_THOUGHT_COLOR values are now `level` (default),
+  `mdheading`, and `inherit`; the midpoint `gray` variant and its RGB
+  color math are gone.
+- Paint user-run `!` bash block surfaces with the theme's
+  `userMessageBg` token instead of a hardcoded hex, matching
+  pi-content-layout's prompt surfaces under any theme.
+- Show subagent progress in the collapsed plan headline: while running, the tail reads `→ N turns · provider/model` in the warning tone from streamed result details; settled calls keep the same `→ N turns · provider/model` in muted instead of a bare `→ done` (turns aggregate across tasks, model only when all tasks agree).
+- Source the settled "+ Thought" label color from the theme's mdHeading
+  token (orange in cobalt2, amber in Pi's stock themes) instead of a
+  hardcoded RGB. The PI_TOOL_CALL_MARKERS_THOUGHT_COLOR experiment values
+  are now `mdheading` (default), `gray`, and `inherit`.
+- Fix: preserve the visible text of hyperlink-wrapped paths in collapsed rows. Pi renders `read` call paths as OSC 8 hyperlinks (`ESC]8;;url ESC\ <path> ESC]8;; ESC\`); the previous greedy OSC strip consumed the path text along with the sequences, collapsing `% read: README.md:1-400` to `% read: :1-400`. OSC payloads now end at their first BEL/ST terminator, so `read`/`write`/`ls` rows show their filenames again.
+- Show settled `edit` changes inline: the call line gains a `+added/-removed` outcome stat, and the display diff from `result.details.diff` renders as a bounded block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, `...` for folded regions; capped at 12 lines with a `+N more` tail). `Ctrl+O` still returns Pi's full native diff.
+- Render subagent plans with a `&` marker instead of `%`, so delegated calls read differently from ordinary tool rows (both the parsed plan shape and the generic fallback).
+- Render user-run `!` bash blocks (BashExecutionComponent) with the railed prompt shell previously owned by `pi-content-layout` — execution display now lives entirely in this package, while `pi-content-layout` keeps only the transcript surface (message insets, status rows, editor, user prompts). The bash-block inset mirrors that package's message inset.
 - Render every collapsed tool call as a `% tool: call → outcome` line with the tool name bolded — one marker per call, no bullets, no blank lines between sections; grouped blocks share only their leading blank row (supersedes the nested sub-heading layout).
 - 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.

package/README.md

@@ -21,21 +21,44 @@ Collapsed tool rows use semantic theme colors with no gear, background fill, box
 - **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.
+- **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.
 
 ## Subagent plans
 
-A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic:
+A recognized `subagent` call renders as an unboxed plan in the shared tool aesthetic, marked with `&` instead of the ordinary `%` tool marker:
 
 ```text
-  % subagent chain (3 steps) [repo-review]
+  & 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.
+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.
+While a subagent runs, the plan headline's tail shows live progress from the streamed result details — `→ 1 turn · provider/model` in the warning tone — and a settled call keeps the same `→ N turns · provider/model` summary in muted (turns aggregate across tasks; the model shows only when every task used the same one).
+
+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.
+
+## Edit diffs
+
+Settled `edit` calls keep their change visible without expanding: the call line gains a `+added/-removed` outcome stat, and the hunk renders as a bounded diff block underneath (`+` lines in the added tone, `-` in the removed tone, context muted, folded regions as `...`, capped at 12 lines with a count tail). The full native diff — line numbers, intra-line word highlights — still returns with `Ctrl+O`.
+
+Files and paths in collapsed rows are preserved as displayed by Pi: hyperlink-wrapped paths (Pi wraps `read` call paths in OSC 8 hyperlinks) keep their visible text when sanitized for one-line rows.
+
+## Scope boundary
+
+This package owns every **execution row** in the transcript: collapsed tool calls, tool grouping, subagent plans, thinking labels, and user-run `!` bash blocks (reshaped into the railed prompt shell). Transcript _surface_ layout — message insets, system-text and status-rule alignment, the editor surface, and the submitted-prompt shell for user messages — belongs to `@pi-kaush/pi-content-layout`, which never renders tool rows.
+
+One shared visual contract crosses the line: `!` blocks align with message text, so their inset mirrors `pi-content-layout`'s message `contentInset` (see `src/bash-block.ts`). Change indentation in both packages together.
+
+## Hiding info entirely: /toggle-info
+
+The default transcript keeps tool calls and thinking collapsed, and Ctrl+O /
+Ctrl+T expand them as usual. When you want prose only, `/toggle-info` hides
+tool calls (including user-run `!` blocks) and thinking completely; running it
+again restores the collapsed view. The toggle is per-session: every session
+starts visible.
 
 ## Bundled thinking-block extension
 

package/package.json

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

package/src/bash-block.ts

@@ -0,0 +1,303 @@
+import { BashExecutionComponent } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+
+type ThemeLike = {
+  bold(text: string): string;
+  fg(color: string, text: string): string;
+  getBgAnsi?(color: string): string;
+};
+
+const BASH_BLOCK_PATCHED = Symbol.for("kg.pi.bashBlock.v1");
+
+// The prompt surface paints with the theme's userMessageBg token, matching
+// pi-content-layout's surfaces. userMessageBg is a required pi theme token;
+// the legacy hex remains only as a fallback for theme lookalikes without
+// getBgAnsi.
+const PROMPT_SURFACE_BG_FALLBACK = "\x1b[48;2;7;19;18m"; // #071312
+
+function promptSurfaceBg(theme: ThemeLike): string {
+  try {
+    return theme.getBgAnsi?.("userMessageBg") ?? PROMPT_SURFACE_BG_FALLBACK;
+  } catch {
+    return PROMPT_SURFACE_BG_FALLBACK;
+  }
+}
+const PROMPT_RAIL = "▎";
+
+// User-run bash blocks align with the message inset pi-content-layout
+// applies to transcript lines. Keep this in sync with that package's
+// contentInset (2 columns outside the rail for any width above 4); the
+// conversation surface has one shared visual contract even though the two
+// packages otherwise own disjoint components.
+function bashBlockInset(width: number): number {
+  return width > BASH_BLOCK_INSET * 2 ? BASH_BLOCK_INSET : 0;
+}
+const BASH_BLOCK_INSET = 2;
+
+const SGR_PATTERN = /\x1b\[([0-9;]*)m/g;
+const BACKGROUND_PATTERN =
+  /\x1b\[(?:4[0-8]|10[0-7]|48;5;\d{1,3}|48;2;\d{1,3};\d{1,3};\d{1,3})m/g;
+const DISPLAY_ANSI_PATTERN = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
+
+function semanticControlEnd(text: string, offset: number): number | undefined {
+  if (text[offset] !== "\x1b") return undefined;
+  const kind = text[offset + 1];
+  if (kind !== "]" && kind !== "_" && kind !== "P" && kind !== "^") {
+    return undefined;
+  }
+  for (let index = offset + 2; index < text.length; index++) {
+    if (text[index] === "\x07") return index + 1;
+    if (text[index] === "\x1b" && text[index + 1] === "\\") {
+      return index + 2;
+    }
+  }
+  return undefined;
+}
+
+function splitLeadingSemanticControls(line: string): {
+  controls: string;
+  content: string;
+} {
+  let offset = 0;
+  while (offset < line.length) {
+    const end = semanticControlEnd(line, offset);
+    if (end === undefined) break;
+    offset = end;
+  }
+  return { controls: line.slice(0, offset), content: line.slice(offset) };
+}
+
+function fitLine(line: string, width: number): string {
+  if (width <= 0) return "";
+  const clipped = truncateToWidth(line, width, "");
+  return clipped + " ".repeat(Math.max(0, width - visibleWidth(clipped)));
+}
+
+function reapplyBackgroundAfterReset(
+  text: string,
+  backgroundAnsi: string,
+): string {
+  return text.replace(SGR_PATTERN, (sequence, rawParameters: string) => {
+    const parameters =
+      rawParameters === "" ? [0] : rawParameters.split(";").map(Number);
+    return parameters.includes(0) || parameters.includes(49)
+      ? `${sequence}${backgroundAnsi}`
+      : sequence;
+  });
+}
+
+function paintBackground(
+  line: string,
+  width: number,
+  backgroundAnsi: string,
+): string {
+  const fitted = fitLine(line, width);
+  // Mirrors Theme.bg: background, content, then a background-only reset.
+  return `${backgroundAnsi}${reapplyBackgroundAfterReset(fitted, backgroundAnsi)}\x1b[49m`;
+}
+
+function stripDisplayAnsi(text: string): string {
+  return text.replace(DISPLAY_ANSI_PATTERN, "");
+}
+
+function replaceBackground(text: string, backgroundAnsi: string): string {
+  return text.replace(BACKGROUND_PATTERN, backgroundAnsi);
+}
+
+// Renders lines inside a railed, dark-surfaced block (the submitted-prompt
+// shell): optional leading semantic controls stay outside the inset, the rail
+// is recolored, and content backgrounds are normalized to the prompt surface.
+function renderRailedBlockLines(
+  lines: string[],
+  width: number,
+  theme: ThemeLike,
+  inset: number,
+  railColor: string,
+): string[] {
+  const blockWidth = width - inset * 2;
+  if (inset === 0 || blockWidth <= visibleWidth(PROMPT_RAIL)) {
+    return lines.map((line) => fitLine(line, width));
+  }
+  const bodyWidth = blockWidth - visibleWidth(PROMPT_RAIL);
+  const margin = " ".repeat(inset);
+  const surfaceBg = promptSurfaceBg(theme);
+  return lines.map((line) => {
+    const { controls, content } = splitLeadingSemanticControls(line);
+    const recolored = replaceBackground(content, surfaceBg);
+    const rail = theme.fg(railColor, PROMPT_RAIL);
+    // One extra leading space inside the body, so submitted text sits two
+    // columns right of the rail instead of one.
+    const body = paintBackground(
+      ` ${fitLine(recolored, Math.max(1, bodyWidth - 1))}`,
+      bodyWidth,
+      surfaceBg,
+    );
+    return `${controls}${margin}${rail}${body}${margin}`;
+  });
+}
+
+const RULE_LINE_RE = /^─+$/;
+
+function isRuleLine(line: string | undefined): line is string {
+  return line !== undefined && RULE_LINE_RE.test(stripDisplayAnsi(line).trim());
+}
+
+// `!!` commands draw their rules dim instead of bashMode green, but the
+// component does not store that flag, so sniff the top rule's color to keep
+// the rail consistent with the framing it replaces.
+function sniffsDimRule(rule: string, theme: ThemeLike): boolean {
+  const prefixOf = (colored: string) => colored.slice(0, colored.indexOf("─"));
+  const dimPrefix = prefixOf(theme.fg("dim", "─"));
+  return (
+    dimPrefix.length > 0 &&
+    dimPrefix !== prefixOf(theme.fg("bashMode", "─")) &&
+    rule.startsWith(dimPrefix)
+  );
+}
+
+// Rail tone for a user bash block: failures read red and cancellations
+// yellow, matching the block's status text; anything else keeps the green
+// the rules used (dim for `!!` commands).
+function bashBlockRailColor(
+  status: string | undefined,
+  topRule: string | undefined,
+  theme: ThemeLike,
+): string {
+  if (status === "error") return "error";
+  if (status === "cancelled") return "warning";
+  if (topRule !== undefined && sniffsDimRule(topRule, theme)) return "dim";
+  return "bashMode";
+}
+
+// Reshapes BashExecutionComponent output into the submitted-prompt shell: the
+// leading spacer stays outside the block, the top/bottom rules are dropped,
+// and the remaining lines get one blank padded row at each end plus the rail
+// and dark surface.
+function renderBashBlockLines(
+  lines: string[],
+  width: number,
+  theme: ThemeLike,
+  status: string | undefined,
+  inset = bashBlockInset(width),
+): string[] {
+  const [spacer, ...rest] = lines;
+  const topRule = isRuleLine(rest[0]) ? rest[0] : undefined;
+  const inner = topRule !== undefined ? rest.slice(1) : rest.slice();
+  if (isRuleLine(inner[inner.length - 1])) inner.pop();
+  const railColor = bashBlockRailColor(status, topRule, theme);
+  const block = renderRailedBlockLines(
+    ["", ...inner, ""],
+    width,
+    theme,
+    inset,
+    railColor,
+  );
+  return [fitLine(spacer ?? "", width), ...block];
+}
+
+type BashRow = { status?: unknown };
+
+type BashBlockPatchState = {
+  owners: number;
+  theme?: ThemeLike;
+  cache: WeakMap<object, { width: number; src: string[]; lines: string[] }>;
+  originalRender: (width: number) => string[];
+  patchedRender?: (width: number) => string[];
+};
+
+// User-typed `!` commands are execution rows, so their presentation belongs
+// here with every other collapsed execution display; pi-content-layout stops
+// at the message surface. Pi's BashExecutionComponent already draws the
+// command, rules, and status; this patch reshapes that output into the
+// railed prompt shell and recolors the rail from the exit outcome.
+// TODO: Replace prototype patching with a public Pi rendering API when available.
+function installBashBlockPatch(): BashBlockPatchState | undefined {
+  try {
+    const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
+      [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
+      render?: (width: number) => string[];
+    };
+    if (!proto || typeof proto.render !== "function") return undefined;
+
+    const existing = proto[BASH_BLOCK_PATCHED];
+    if (existing) {
+      existing.owners++;
+      return existing;
+    }
+
+    const state: BashBlockPatchState = {
+      owners: 1,
+      cache: new WeakMap(),
+      originalRender: proto.render,
+    };
+    const patchedRender = function renderWithBashBlockShell(
+      this: BashRow,
+      width: number,
+    ): string[] {
+      const theme = state.theme;
+      if (!theme) return state.originalRender.call(this, width);
+      const inset = bashBlockInset(width);
+      const bodyWidth = width - inset * 2 - visibleWidth(PROMPT_RAIL);
+      if (inset === 0 || bodyWidth < 8) {
+        return state.originalRender.call(this, width);
+      }
+      const lines = state.originalRender.call(this, Math.max(1, bodyWidth));
+      const entry = state.cache.get(this);
+      if (
+        entry &&
+        entry.width === width &&
+        entry.src.length === lines.length &&
+        entry.src.every((line, index) => line === lines[index])
+      ) {
+        return entry.lines;
+      }
+      const status = this.status;
+      const decorated = renderBashBlockLines(
+        lines,
+        width,
+        theme,
+        typeof status === "string" ? status : undefined,
+        inset,
+      );
+      state.cache.set(this, { width, src: lines, lines: decorated });
+      return decorated;
+    };
+
+    try {
+      state.patchedRender = patchedRender;
+      proto.render = patchedRender;
+      Object.defineProperty(proto, BASH_BLOCK_PATCHED, {
+        configurable: true,
+        value: state,
+      });
+    } catch {
+      proto.render = state.originalRender;
+      return undefined;
+    }
+    return state;
+  } catch {
+    // Pi internals can change across versions; fail silently.
+    return undefined;
+  }
+}
+
+function uninstallBashBlockPatch(state: BashBlockPatchState | undefined): void {
+  if (!state || state.owners <= 0) return;
+  state.owners--;
+  if (state.owners > 0) return;
+  const proto = BashExecutionComponent?.prototype as unknown as BashRow & {
+    [BASH_BLOCK_PATCHED]?: BashBlockPatchState;
+    render?: (width: number) => string[];
+  };
+  if (
+    proto[BASH_BLOCK_PATCHED] !== state ||
+    proto.render !== state.patchedRender
+  ) {
+    return;
+  }
+  proto.render = state.originalRender;
+  delete proto[BASH_BLOCK_PATCHED];
+}
+
+export { PROMPT_RAIL, installBashBlockPatch, uninstallBashBlockPatch };
+export type { BashBlockPatchState };