@pi-kaush/pi-tool-call-markers 0.3.14 → 0.3.15

package/CHANGELOG.md

@@ -2,11 +2,22 @@
 
 ## Unreleased
 
+- Fix assistant replies vanishing behind the thinking label. The label
+  restyle matched any text node containing the label, so a reply that quoted
+  `Thinking...` or `│ * Thought` was replaced by the label until Ctrl+T. Only
+  Pi's thinking-run label nodes are restyled now, on an exact match, and only
+  on rows that carry thinking.
+- Keep the live thinking spinner moving between thinking deltas. The frame is
+  read from the clock on each redraw that Pi's working indicator already
+  drives, instead of only when new thinking text arrives.
+
 - Anchor the settled thinking label like a collapsed tool call:
   `│ * Thought · 2.5s` instead of `+ Thought · 2.5s`. The faint rail and
   bold glyph match the tool rows around it, so a turn that alternates
-  thinking and calls reads as one column. The live `⠋ Thinking…` spinner is
-  unchanged.
+  thinking and calls reads as one column. The live label takes the same
+  anchor, `│ ⠋ Thinking…`, with the spinner in the glyph slot, so settling
+  swaps only the glyph, the words, and the tint instead of shifting the text
+  two columns and drawing a rail in.
 
 - Paint collapsed rows with the theme's `dim` token instead of
   `syntaxComment`. Pi's generated `system` theme solves `syntaxComment` to

package/README.md

@@ -97,11 +97,11 @@ The second package entrypoint, `src/thinking-block-merger.ts`, combines only dir
 When Pi exposes its per-row hidden-thinking and streaming fields, hidden reasoning uses these native-themed labels:
 
 ```text
-⠋ Thinking…  →  ⠙ Thinking…  →  …
+│ ⠋ Thinking…  →  │ ⠙ Thinking…  →  …
 │ * Thought · 2.5s
 ```
 
-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`. The settled label borrows the collapsed tool-row anchor — a faint `│` rail and a bold `*` — so finished reasoning reads like the tool calls around it. There is no interval, timeout, render request, model call, or network work.
+The live label samples Pi's native braille spinner sequence from the clock each time the TUI draws it, so it steps with the redraws Pi's working indicator already drives instead of freezing between bursty thinking deltas. It does not add a timer; with the working indicator hidden, the spinner advances on each content update. 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`. Both labels borrow the collapsed tool-row anchor — a faint `│` rail and a bold glyph — so reasoning reads like the tool calls around it. The spinner holds the glyph slot and settles into `*` in place: the rail and the label text keep their columns, and the rail keeps the settled tone throughout. There is no interval, timeout, render request, model call, or network work.
 
 Pi renders thinking labels and traces italic. This package drops those italics: both labels read as plain collapsed rows (the live spinner keeps its thinking-level tint, the settled row the muted tone, and a theme that resolves no color still loses the italics), and a visible trace stays italic only while it streams, then settles into ordinary transcript text. `PI_TOOL_CALL_MARKERS_THOUGHT_COLOR=inherit` is the opt-out that keeps Pi's native italic `thinkingText` styling.
 

package/package.json

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

package/src/thinking-block-merger.ts

@@ -105,21 +105,34 @@ function labelStyle(
   return styledWith(token, theme);
 }
 
-// The settled label wears the collapsed tool-row anchor — faint rail, bold
-// glyph — so finished reasoning reads like the tool calls around it. Every
-// other label is the live spinner.
+// Both labels wear the collapsed tool-row anchor — faint rail, bold glyph —
+// so reasoning reads like the tool calls around it. The live spinner holds
+// the glyph slot and settles into `*` in place: the rail and the label text
+// keep their columns, and only the glyph, the words, and the tint change.
 const THOUGHT_RAIL = "│";
 const THOUGHT_GLYPH = "*";
-const THOUGHT_ANCHOR = `${THOUGHT_RAIL} ${THOUGHT_GLYPH}`;
-const SETTLED_THOUGHT = `${THOUGHT_ANCHOR} Thought`;
+const SETTLED_THOUGHT = `${THOUGHT_RAIL} ${THOUGHT_GLYPH} Thought`;
+const ANCHORED_LABEL_RE = /^│ (\S) (.*)$/su;
 
 function isSettledThoughtLabel(label: string): boolean {
   return label.startsWith(SETTLED_THOUGHT);
 }
 
-function styledSettledThought(raw: string, style: LabelStyle): string {
-  const rest = raw.slice(THOUGHT_ANCHOR.length);
-  return `${style.prefix}\x1b[2m${THOUGHT_RAIL}\x1b[22m \x1b[1m${THOUGHT_GLYPH}\x1b[22m${rest}${style.suffix}`;
+// The rail keeps the settled collapsed tone in both states, like a pending
+// tool row's rail, so settling never repaints it.
+function styledAnchoredLabel(
+  raw: string,
+  style: LabelStyle,
+  theme: ThemeDetail,
+): string {
+  const match = ANCHORED_LABEL_RE.exec(raw);
+  if (!match) return `${style.prefix}${raw}${style.suffix}`;
+  const rail = settledMutedStyle(theme) ?? style;
+  const railText = `\x1b[2m${THOUGHT_RAIL}\x1b[22m`;
+  const body = ` \x1b[1m${match[1]}\x1b[22m ${match[2]}${style.suffix}`;
+  return rail.prefix === style.prefix
+    ? `${style.prefix}${railText}${body}`
+    : `${rail.prefix}${railText}${rail.suffix}${style.prefix}${body}`;
 }
 
 export function visibleThoughtLabel(label: string): string {
@@ -129,10 +142,8 @@ export function visibleThoughtLabel(label: string): string {
   const settled = isSettledThoughtLabel(raw);
   const style = theme ? labelStyle(settled, theme) : undefined;
   // A theme that cannot resolve a color still drops Pi's italics.
-  if (!style) return `${ITALIC_OFF}${raw}`;
-  return settled
-    ? styledSettledThought(raw, style)
-    : `${style.prefix}${raw}${style.suffix}`;
+  if (!style || !theme) return `${ITALIC_OFF}${raw}`;
+  return styledAnchoredLabel(raw, style, theme);
 }
 
 type AssistantMessageLike = {
@@ -149,6 +160,7 @@ type AssistantMessageRow = {
 type TextLikeChild = {
   text?: unknown;
   setText?(text: string): void;
+  render?(width: number): string[];
 };
 
 type MarkdownLikeChild = {
@@ -192,7 +204,63 @@ function unitalicizeSettledThinking(row: AssistantMessageRow): void {
 // previous (italic) frame, so an in-line italic reset may never reach the
 // terminal. Swap the node's text for a self-contained styled version after
 // each native render pass instead.
-function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
+//
+// Only label nodes qualify. Answer prose and a click-revealed trace are
+// Markdown nodes that also carry `text` and `setText`, so Markdown never
+// matches, and a candidate's plain text must equal the label exactly. Pi 1.0
+// wraps each thinking run in a MouseRegion; each child is judged on its own,
+// unwrapped when it has a wrapped inner.
+function hiddenLabelNodes(row: AssistantMessageRow): unknown[] {
+  const children = row.contentContainer?.children;
+  if (!Array.isArray(children)) return [];
+  return children
+    .map((child) => (child as { child?: unknown } | undefined)?.child ?? child)
+    .filter((node) => !isMarkdownLike(node));
+}
+
+// Duck-typed, not `instanceof`: a locally loaded extension can resolve its
+// own pi-tui copy, so class identity is not shared with Pi's. pi-tui's
+// Markdown declares `theme` and `defaultTextStyle` fields; Text has neither.
+function isMarkdownLike(node: unknown): boolean {
+  return (
+    !!node &&
+    typeof node === "object" &&
+    ("defaultTextStyle" in node || "theme" in node)
+  );
+}
+
+function plainText(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+// A live label re-reads the clock whenever the TUI draws it, so the spinner
+// steps with the redraws Pi's working indicator already drives instead of
+// freezing between bursty thinking deltas. Pi rebuilds the label node on
+// every content update, so the override dies with the node; no timer is
+// added, and with no redraws the spinner still advances on each delta.
+function animateLiveLabel(node: TextLikeChild, startedAt: number): void {
+  const render = node.render;
+  if (typeof render !== "function") return;
+  node.render = function renderLiveThinkingLabel(
+    this: TextLikeChild,
+    width: number,
+  ): string[] {
+    try {
+      const styled = visibleThoughtLabel(
+        liveThinkingLabel(startedAt, Date.now()),
+      );
+      if (this.text !== styled) this.setText?.(styled);
+    } catch {
+      // Keep the last frame if styling fails mid-render.
+    }
+    return Reflect.apply(render, this, [width]) as string[];
+  };
+}
+
+function restyleHiddenThinkingLabel(
+  row: AssistantMessageRow,
+  liveSince?: number,
+): void {
   if (
     row.hideThinkingBlock !== true ||
     typeof row.hiddenThinkingLabel !== "string"
@@ -202,16 +270,18 @@ function restyleHiddenThinkingLabel(row: AssistantMessageRow): void {
   const label = row.hiddenThinkingLabel;
   if (!stylesThinkingLabels()) return;
   const styled = visibleThoughtLabel(label);
-  for (const child of contentNodes(row)) {
+  const plainLabel = plainText(label);
+  for (const child of hiddenLabelNodes(row)) {
     const textChild = child as TextLikeChild | undefined;
     if (
       typeof textChild?.text !== "string" ||
       typeof textChild.setText !== "function" ||
-      !textChild.text.includes(label)
+      plainText(textChild.text) !== plainLabel
     ) {
       continue;
     }
     textChild.setText(styled);
+    if (liveSince !== undefined) animateLiveLabel(textChild, liveSince);
   }
 }
 
@@ -256,7 +326,9 @@ function trackReplayRow(
   args: unknown[],
 ): void {
   try {
-    if (!hasThinkingContent(message)) return;
+    // A tracked row keeps tracking even when its final content drops
+    // thinking, so a replay never resurrects an earlier streaming snapshot.
+    if (!hasThinkingContent(message) && !state.rows.has(row)) return;
     state.rows.set(row, { message, args });
     while (state.rows.size > MAX_REPLAY_ROWS) {
       const oldest = state.rows.keys().next().value;
@@ -321,6 +393,10 @@ function formatThoughtDuration(startedAt: number, finishedAt: number): string {
   return `${(Math.max(0, finishedAt - startedAt) / 1000).toFixed(1)}s`;
 }
 
+function liveThinkingLabel(startedAt: number, now: number): string {
+  return `${THOUGHT_RAIL} ${thinkingSpinner(startedAt, now)} Thinking…`;
+}
+
 function thinkingSpinner(startedAt: number, now: number): string {
   const frame = Math.floor(Math.max(0, now - startedAt) / SPINNER_INTERVAL_MS);
   return PI_SPINNER_FRAMES[frame % PI_SPINNER_FRAMES.length]!;
@@ -342,23 +418,59 @@ function thinkingStillLive(
   );
 }
 
+// Thinking ends when the answer starts: visible text or a tool call after
+// the last thinking block. Settling there keeps the duration honest and
+// keeps a live label as the transcript's last line, so its spinner never
+// changes a line scrolled above the viewport (which forces a full replay).
+function answerStarted(message: AssistantMessageLike): boolean {
+  const content = Array.isArray(message.content) ? message.content : [];
+  let lastThinking = -1;
+  content.forEach((block, index) => {
+    if (isThinkingContent(block)) lastThinking = index;
+  });
+  return content.slice(lastThinking + 1).some((block) => {
+    const b = block as { type?: unknown; text?: unknown } | undefined;
+    return (
+      b?.type === "toolCall" ||
+      (b?.type === "text" && typeof b.text === "string" && b.text.trim() !== "")
+    );
+  });
+}
+
+function timingLive(
+  streaming: boolean | undefined,
+  timing: ThinkingTiming | undefined,
+): boolean {
+  return (
+    streaming !== false &&
+    timing !== undefined &&
+    timing.finishedAt === undefined
+  );
+}
+
 function lifecycleLabel(
   row: AssistantMessageRow,
+  message: AssistantMessageLike,
   streaming: boolean | undefined,
   timings: WeakMap<AssistantMessageRow, ThinkingTiming>,
 ): string {
   const now = Date.now();
   const previous = timings.get(row);
-  if (thinkingStillLive(streaming, previous)) {
+  const answering = answerStarted(message);
+  if (!answering && thinkingStillLive(streaming, previous)) {
     const current =
       previous && previous.finishedAt === undefined
         ? previous
         : { startedAt: now };
     timings.set(row, current);
-    return `${thinkingSpinner(current.startedAt, now)} Thinking…`;
+    return liveThinkingLabel(current.startedAt, now);
   }
 
-  if (streaming === false && previous && previous.finishedAt === undefined) {
+  if (
+    (streaming === false || answering) &&
+    previous &&
+    previous.finishedAt === undefined
+  ) {
     previous.finishedAt = now;
   }
 
@@ -411,7 +523,7 @@ function applyHiddenThinkingLabel(
 ): void {
   // Record the component's first streaming update even when the provider has
   // not emitted a non-empty thinking block yet.
-  const label = lifecycleLabel(row, streaming, timings);
+  const label = lifecycleLabel(row, message, streaming, timings);
   if (!hasThinkingContent(message)) return;
   if (
     row.hideThinkingBlock !== true ||
@@ -483,14 +595,21 @@ function installThinkingGroupingPatch():
       }
       Reflect.apply(state.originalUpdateContent, this, [combined, ...args]);
       try {
-        restyleHiddenThinkingLabel(this);
+        if (hasThinkingContent(combined)) {
+          const timing = state.timings.get(this);
+          const liveSince =
+            timing && timingLive(streaming, timing)
+              ? timing.startedAt
+              : undefined;
+          restyleHiddenThinkingLabel(this, liveSince);
+        }
       } catch {
         // Keep Pi's native label styling if the row shape changes.
       }
       try {
         if (
           hasThinkingContent(combined) &&
-          !thinkingStillLive(streaming, state.timings.get(this))
+          !timingLive(streaming, state.timings.get(this))
         ) {
           unitalicizeSettledThinking(this);
         }