@oh-my-pi/pi-tui 18.2.4 → 18.2.6

package/src/chat/transcript-render-helpers.ts

@@ -0,0 +1,315 @@
+/**
+ * Render helpers shared between the live transcript ({@link UiHelpers}) and the
+ * file/remote-backed {@link ChatTranscriptBuilder}. Both surfaces build the same
+ * transcript rows from persisted message entries; holding the row construction
+ * here keeps the two byte-for-byte identical.
+ */
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type Component } from "../tui";
+import { formatBytes, formatDuration } from "@oh-my-pi/pi-utils";
+import type { JobSnapshot } from "../tools/hub";
+import type { DaemonSnapshot } from "../tools/hub";
+import { type CustomMessage, type FileMentionMessage, resolveAbortLabel, shouldRenderAbortReason } from "./messages";
+import { createIrcMessageCard } from "../tools/hub";
+import { formatArtifactErrorNotice, type OutputMeta } from "../tools/output-meta";
+import { replaceTabs, TRUNCATE_LENGTHS, truncateToWidth } from "../render/render-utils";
+import { canonicalizeMessage } from "./thinking-display";
+import { ToolActivityContainer } from "../chrome/tool-activity";
+import { type TranscriptBlock } from "../chrome/transcript-container";
+import { TranscriptStatusBlock, type TranscriptStatusRow } from "../chrome/transcript-status";
+import { theme } from "../theme";
+
+type CustomOrHookMessage = Extract<AgentMessage, { role: "custom" | "hookMessage" }>;
+type AssistantAgentMessage = Extract<AgentMessage, { role: "assistant" }>;
+
+/**
+ * Render an `async-result` custom message (a completed background bash/task job,
+ * or a batch of them) as a transcript block of one "Background job completed"
+ * row per job.
+ */
+export function buildAsyncResultBlock(message: CustomOrHookMessage): ToolActivityContainer {
+	const details = (
+		message as CustomMessage<{
+			jobId?: string;
+			type?: JobSnapshot["type"];
+			label?: string;
+			durationMs?: number;
+			jobs?: Array<{
+				jobId?: string;
+				type?: JobSnapshot["type"];
+				label?: string;
+				durationMs?: number;
+				meta?: OutputMeta;
+			}>;
+			meta?: OutputMeta;
+		}>
+	).details;
+	const jobs =
+		details?.jobs && details.jobs.length > 0
+			? details.jobs
+			: [
+					{
+						jobId: details?.jobId,
+						type: details?.type,
+						label: details?.label,
+						durationMs: details?.durationMs,
+					},
+				];
+	const rows: TranscriptStatusRow[] = [];
+	for (const job of jobs) {
+		const jobId = job.jobId ?? "unknown";
+		const typeLabel = job.type ? `[${job.type}]` : "[job]";
+		const duration = typeof job.durationMs === "number" ? formatDuration(job.durationMs) : undefined;
+		rows.push({
+			parts: [
+				theme.fg("success", `${theme.status.done} Background job completed`),
+				theme.fg("dim", typeLabel),
+				theme.fg("accent", jobId),
+				duration ? theme.fg("dim", `(${duration})`) : undefined,
+			],
+		});
+		if (job.meta?.artifactError) {
+			rows.push({ parts: [theme.fg("warning", formatArtifactErrorNotice(job.meta.artifactError))] });
+		}
+	}
+	if (details?.meta?.artifactError) {
+		rows.push({ parts: [theme.fg("warning", formatArtifactErrorNotice(details.meta.artifactError))] });
+	}
+	return new ToolActivityContainer(new TranscriptStatusBlock(rows));
+}
+
+/**
+ * Render a `launch-completion` custom message (terminal supervised-process
+ * exits from the launch broker) as a transcript block of one compact
+ * "Supervised process ..." row per daemon, matching background-job rows.
+ */
+export function buildLaunchCompletionBlock(message: CustomOrHookMessage): ToolActivityContainer {
+	const details = (message as CustomMessage<{ daemons?: DaemonSnapshot[] }>).details;
+	const rows: TranscriptStatusRow[] = [];
+	const daemons = details?.daemons ?? [];
+	if (daemons.length === 0 && typeof message.content === "string") {
+		rows.push({ parts: [theme.fg("dim", `${theme.status.done} ${message.content}`)] });
+	}
+	for (const daemon of daemons) {
+		const failed = daemon.state === "failed" || (daemon.exitCode !== undefined && daemon.exitCode !== 0);
+		const duration =
+			daemon.exitedAt !== undefined && daemon.startedAt !== undefined
+				? formatDuration(daemon.exitedAt - daemon.startedAt)
+				: undefined;
+		rows.push({
+			parts: [
+				failed
+					? theme.fg("error", `${theme.status.error} Supervised process failed`)
+					: theme.fg("success", `${theme.status.done} Supervised process completed`),
+				theme.fg("accent", daemon.name),
+				daemon.exitCode !== undefined ? theme.fg("dim", `(exit ${daemon.exitCode})`) : undefined,
+				duration ? theme.fg("dim", `(${duration})`) : undefined,
+			],
+		});
+	}
+	return new ToolActivityContainer(new TranscriptStatusBlock(rows));
+}
+
+/**
+ * Render a live IRC traffic custom message (`irc:incoming` / `irc:autoreply` /
+ * `irc:relay`) as a transcript card. `getExpanded` supplies the live
+ * expanded-state getter for the cached card.
+ */
+export function buildIrcMessageCard(message: CustomOrHookMessage, getExpanded: () => boolean): Component {
+	const details = (
+		message as CustomMessage<{
+			from?: string;
+			to?: string;
+			message?: string;
+			body?: string;
+			replyTo?: string;
+			pool?: string;
+			mode?: string;
+		}>
+	).details;
+	const kind =
+		message.customType === "irc:incoming"
+			? ("incoming" as const)
+			: message.customType === "irc:autoreply"
+				? ("autoreply" as const)
+				: message.customType === "irc:workpool"
+					? ("workpool" as const)
+					: ("relay" as const);
+	return createIrcMessageCard(
+		{
+			kind,
+			from: details?.from,
+			to: details?.to,
+			body: kind === "incoming" ? details?.message : details?.body,
+			replyTo: details?.replyTo,
+			timestamp: message.timestamp,
+			pool: details?.pool,
+			mode: details?.mode,
+		},
+		getExpanded,
+		theme,
+	);
+}
+
+/**
+ * Render a `fileMention` message's files as a transcript block of "Read <path>"
+ * rows. `indent` sets the left pad: the live chat renders within an outer gutter
+ * (0), the transcript viewer renders body rows without one so rows own their pad
+ * (1).
+ */
+export function buildFileMentionBlock(files: FileMentionMessage["files"], indent: number): TranscriptBlock {
+	const rows: TranscriptStatusRow[] = [];
+	for (const file of files) {
+		let suffix: string;
+		if (file.skippedReason === "tooLarge" || file.skippedReason === "binary") {
+			const size = typeof file.byteSize === "number" ? formatBytes(file.byteSize) : "unknown size";
+			suffix = file.skippedReason === "binary" ? `(skipped: binary, ${size})` : `(skipped: ${size})`;
+		} else {
+			suffix = file.image
+				? "(image)"
+				: file.lineCount === undefined
+					? "(unknown lines)"
+					: `(${file.lineCount} lines)`;
+		}
+		rows.push({
+			parts: [
+				`${theme.fg("dim", `${theme.tree.last} `)}${theme.fg("muted", "Read")}`,
+				theme.fg("accent", file.path),
+				theme.fg("dim", suffix),
+			],
+			indent,
+		});
+	}
+	return new TranscriptStatusBlock(rows);
+}
+
+/**
+ * Whether an assistant turn has visible text, thinking, or image content — i.e.
+ * content that closes the current read-tool run.
+ */
+export function assistantHasVisibleContent(message: AssistantAgentMessage): boolean {
+	return message.content.some(
+		content =>
+			content.type === "image" ||
+			(content.type === "text" && canonicalizeMessage(content.text)) ||
+			(content.type === "thinking" && canonicalizeMessage(content.thinking)),
+	);
+}
+
+/**
+ * Split mixed assistant turns into visible text before tool execution and
+ * visible text segments that must render immediately after the preceding tool.
+ * Cursor can return intro text, tool calls, progress text, and the final answer
+ * in one assistant message; keeping every text block in the leading assistant
+ * block buries post-tool text above tool results in the transcript.
+ */
+export function splitAssistantMessageToolTimeline(message: AssistantAgentMessage): {
+	beforeTools: AssistantAgentMessage;
+	afterToolCalls: ReadonlyMap<string, AssistantAgentMessage>;
+	hasToolCalls: boolean;
+	lastToolCallId?: string;
+} {
+	const beforeTools: AssistantAgentMessage["content"] = [];
+	const afterToolCalls = new Map<string, AssistantAgentMessage>();
+	let pendingAfterTool: AssistantAgentMessage["content"] = [];
+	let lastToolCallId: string | undefined;
+	let sawToolCall = false;
+
+	const displaySegment = (content: AssistantAgentMessage["content"]): AssistantAgentMessage => ({
+		...message,
+		content,
+		stopReason: "stop",
+		errorMessage: undefined,
+		retryRecovery: undefined,
+	});
+
+	const flushPendingAfterTool = () => {
+		if (!lastToolCallId || pendingAfterTool.length === 0) return;
+		afterToolCalls.set(lastToolCallId, displaySegment(pendingAfterTool));
+		pendingAfterTool = [];
+	};
+
+	for (const content of message.content) {
+		if (content.type === "toolCall") {
+			flushPendingAfterTool();
+			sawToolCall = true;
+			lastToolCallId = content.id;
+			continue;
+		}
+		if (sawToolCall) {
+			pendingAfterTool.push(content);
+		} else {
+			beforeTools.push(content);
+		}
+	}
+	flushPendingAfterTool();
+
+	if (!sawToolCall) {
+		return { beforeTools: message, afterToolCalls, hasToolCalls: false };
+	}
+
+	return { beforeTools: displaySegment(beforeTools), afterToolCalls, hasToolCalls: true, lastToolCallId };
+}
+
+/**
+ * Normalize raw tool-call arguments to a plain record, collapsing non-object or
+ * array values to an empty object.
+ */
+export function normalizeToolArgs(args: unknown): Record<string, unknown> {
+	return args && typeof args === "object" && !Array.isArray(args) ? (args as Record<string, unknown>) : {};
+}
+
+export type AssistantErrorPresentation =
+	| { kind: "none" }
+	| { kind: "full"; text: string; isError: true }
+	| { kind: "compact-recovered"; text: string; isError: false };
+
+function sanitizeRecoveredRetryNote(note: string): string {
+	const normalized = replaceTabs(note).replace(/\s+/g, " ").trim();
+	return truncateToWidth(normalized || "retried", TRUNCATE_LENGTHS.CONTENT);
+}
+
+/**
+ * Resolve the turn-ending assistant error presentation, if any.
+ * Silent and user-interrupt aborts yield no label. Recovered retry attempts
+ * render a compact note; attempts superseded by an exhausted budget are hidden
+ * while the final terminal error keeps its full presentation.
+ */
+export function resolveAssistantErrorPresentation(
+	message: AssistantAgentMessage,
+	retryAttempt = 0,
+): AssistantErrorPresentation {
+	if (message.retryRecovery?.status === "superseded") return { kind: "none" };
+	if (message.retryRecovery?.status === "recovered") {
+		return {
+			kind: "compact-recovered",
+			text: sanitizeRecoveredRetryNote(message.retryRecovery.note),
+			isError: false,
+		};
+	}
+	if (message.stopReason === "aborted") {
+		if (!shouldRenderAbortReason(message)) return { kind: "none" };
+		return { kind: "full", text: resolveAbortLabel(message, retryAttempt), isError: true };
+	}
+	if (message.stopReason === "error") {
+		return { kind: "full", text: message.errorMessage || "Error", isError: true };
+	}
+	if (message.errorMessage && shouldRenderAbortReason(message)) {
+		return { kind: "full", text: message.errorMessage, isError: true };
+	}
+	return { kind: "none" };
+}
+
+/**
+ * Whether an assistant turn's `usage` reflects work the operator was billed
+ * for. Empty automated turns from providers that emit `usage: 0` collapse to
+ * `false`, but any input, output, cache, or premium request keeps the row so
+ * cost transparency survives — the live path and the resume/rebuild path
+ * agree turn-by-turn.
+ */
+export function assistantUsageIsBilled(usage: AssistantAgentMessage["usage"]): boolean {
+	if (usage.input > 0 || usage.output > 0) return true;
+	if (usage.cacheRead > 0 || usage.cacheWrite > 0) return true;
+	if ((usage.premiumRequests ?? 0) > 0) return true;
+	return false;
+}

package/src/chat/ttsr-notification.ts

@@ -0,0 +1,123 @@
+import { Text } from "../components/text";
+import { type Component, Container } from "../tui";
+import { MessageNoticeComponent, type MessageNoticePresentation } from "../chrome/message-notice";
+import { theme } from "../theme";
+
+/** Rule fields shown in rewind notifications. */
+export interface NotificationRule {
+	name: string;
+	description?: string;
+	content?: string;
+}
+
+/** Collapsed view shows at most this many rules before eliding the rest. */
+const MAX_COLLAPSED_RULES = 4;
+
+/**
+ * Component that renders a TTSR (Time Traveling Stream Rules) notification.
+ * Shows when a rule violation is detected and the stream is being rewound.
+ * One block can carry several rules: a single event may match multiple rules,
+ * and consecutive notifications merge into the previous block via
+ * {@link addRules} while it is still the live transcript tail.
+ */
+export class TtsrNotificationComponent extends Container {
+	#rules: NotificationRule[];
+	readonly #notice: MessageNoticeComponent;
+
+	constructor(rules: NotificationRule[]) {
+		super();
+		this.#rules = [...rules];
+		this.#notice = new MessageNoticeComponent({
+			presentation: context => this.#presentation(context.expanded),
+		});
+		this.addChild(this.#notice);
+	}
+
+	setToolActivityVisible(visible: boolean): void {
+		this.#notice.setToolActivityVisible(visible);
+	}
+
+	/** Merge additional rules into this block (deduped by rule name). */
+	addRules(rules: NotificationRule[]): void {
+		let changed = false;
+		for (const rule of rules) {
+			if (this.#rules.some(existing => existing.name === rule.name)) continue;
+			this.#rules.push(rule);
+			changed = true;
+		}
+		if (changed) this.#notice.refresh();
+	}
+
+	setExpanded(expanded: boolean): void {
+		this.#notice.setExpanded(expanded);
+	}
+
+	isExpanded(): boolean {
+		return this.#notice.isExpanded();
+	}
+
+	#presentation(expanded: boolean): MessageNoticePresentation {
+		// fg colors conflict with inverse, so styling inside the block is limited
+		// to bold (names) and italic (descriptions).
+		if (this.#rules.length === 1) {
+			return this.#presentationSingle(this.#rules[0]!, expanded);
+		}
+		return this.#presentationMulti(expanded);
+	}
+
+	#presentationSingle(rule: NotificationRule, expanded: boolean): MessageNoticePresentation {
+		const header = `Injecting rule: ${theme.bold(rule.name)}  ${theme.icon.rewind}`;
+
+		const desc = (rule.description || rule.content)?.trim();
+		if (!desc) return { icon: theme.icon.warning, header };
+
+		let displayText = desc;
+		let truncated = false;
+		if (!expanded) {
+			const lines = desc.split("\n");
+			if (lines.length > 2) {
+				displayText = `${lines.slice(0, 2).join("\n")}…`;
+				truncated = true;
+			}
+		}
+
+		const body: Component[] = [new Text(theme.italic(displayText), 0, 0)];
+		if (truncated) {
+			body.push(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
+		}
+		return { icon: theme.icon.warning, header, body };
+	}
+
+	#presentationMulti(expanded: boolean): MessageNoticePresentation {
+		const header = `Injecting ${this.#rules.length} rules:  ${theme.icon.rewind}`;
+
+		const visible = expanded ? this.#rules : this.#rules.slice(0, MAX_COLLAPSED_RULES);
+		const body: Component[] = [];
+		let elidedDetail = false;
+		for (const rule of visible) {
+			const desc = (rule.description || rule.content)?.trim();
+			let line = theme.bold(rule.name);
+			if (desc) {
+				let displayText = desc;
+				if (!expanded) {
+					// One line per rule when collapsed; full description when expanded.
+					const newline = desc.indexOf("\n");
+					if (newline !== -1) {
+						displayText = `${desc.slice(0, newline).trimEnd()}…`;
+						elidedDetail = true;
+					}
+				}
+				line += `: ${theme.italic(displayText)}`;
+			}
+			body.push(new Text(line, 0, 0));
+		}
+
+		const hidden = this.#rules.length - visible.length;
+		if (hidden > 0) {
+			body.push(new Text(theme.italic(`… +${hidden} more (ctrl+o to expand)`), 0, 0));
+		} else if (elidedDetail) {
+			body.push(new Text(theme.italic(" (ctrl+o to expand)"), 0, 0));
+		}
+		return { icon: theme.icon.warning, header, body };
+	}
+}