@code-yeongyu/senpi-codemode 2026.10.10-10 → 2026.10.10-12

package/src/tool/render-blocks.ts

@@ -0,0 +1,252 @@
+import { type Theme, type ThemeColor, type ToolDefinition, truncateToVisualLines } from "@code-yeongyu/senpi";
+import type { TruncationMeta } from "../output/output-meta.ts";
+import { codePointPrefix } from "./tool-widgets.ts";
+import type { EvalInputSchema, EvalResultDetails, EvalToolInput, EvalToolRequest } from "./types.ts";
+
+type EvalToolDefinition = ToolDefinition<EvalInputSchema, EvalResultDetails>;
+export type CallRenderContext = Parameters<NonNullable<EvalToolDefinition["renderCall"]>>[2];
+export type ResultRenderContext = Parameters<NonNullable<EvalToolDefinition["renderResult"]>>[3];
+type CollapsibleKind = "code" | "output";
+
+export interface EvalRenderComponent {
+	render(width: number): string[];
+	invalidate(): void;
+}
+type ToolCallRow = {
+	readonly summary: string;
+	readonly error?: string;
+	readonly color: "success" | "error";
+};
+export type RenderBlock =
+	| { readonly kind: "blank" }
+	| {
+			readonly kind: "text";
+			readonly text: string;
+			readonly maxVisualLines?: number;
+			readonly collapseKind?: CollapsibleKind;
+			readonly theme?: Theme;
+	  }
+	| {
+			readonly kind: "toolCalls";
+			readonly calls: readonly ToolCallRow[];
+			readonly expanded: boolean;
+			readonly theme?: Theme;
+	  }
+	| { readonly kind: "dynamic"; readonly render: (width: number) => readonly string[] };
+
+export const CODE_PREVIEW_LINES = 4;
+export const SUMMARY_PREVIEW_LINES = 3;
+export const OUTPUT_PREVIEW_LINES = 8;
+export const STATUS_PREVIEW_COUNT = 3;
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"] as const;
+export const TOOL_CALL_PREVIEW_COUNT = 5;
+const TOOL_CALL_COLLAPSED_VISUAL_LINES = 4;
+const TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS = 512;
+const TOOL_ERROR_OMISSION_MARKER = "[tool error omitted]";
+export const LIVE_RENDER_TICK_MS = 100;
+// A live row repaints on every tick, so this many ticks without a render means the row is gone.
+const LIVE_TICKER_MAX_IDLE_TICKS = 600;
+
+export type StatusPresentation = { readonly label: string; readonly icon: string; readonly color: ThemeColor };
+export type RenderEnvironment = {
+	readonly expanded: boolean;
+	readonly theme: Theme | undefined;
+	readonly spinnerFrame: number | undefined;
+	readonly width: number;
+	readonly meta: TruncationMeta | undefined;
+	/** Render-time clock, injected so elapsed time is deterministic under test. */
+	readonly now: number;
+	/** Repaints the row once a background-formatted code preview is ready; absent while args stream. */
+	readonly repaint?: () => void;
+};
+export type PrefixStyle = { readonly prefix: string; readonly continuation: string; readonly color: ThemeColor };
+
+class PlainTextComponent implements EvalRenderComponent {
+	#blocks: readonly RenderBlock[] = [];
+	#ticker: ReturnType<typeof setInterval> | undefined;
+	#live = false;
+	#invalidate: (() => void) | undefined;
+	#idleTicks = 0;
+
+	setBlocks(blocks: readonly RenderBlock[]): void {
+		this.#blocks = blocks;
+	}
+
+	/**
+	 * The host only animates tool rows for streaming args, `task`, and results carrying
+	 * `details.progress`; an eval row matches none of them, so nothing repaints it between
+	 * update events. While a cell is non-terminal this drives the repaint itself so the
+	 * header's spinner and elapsed time advance, with no tool updates or RPC traffic. Detached
+	 * and terminal cards never arm it, and a ticker whose row stopped rendering (transcript
+	 * rebuild, session switch) stops itself after LIVE_TICKER_MAX_IDLE_TICKS and rearms on
+	 * the next render, so dropped rows cannot accumulate intervals.
+	 */
+	syncLiveTicker(isLive: boolean, invalidate: () => void): void {
+		this.#live = isLive;
+		this.#invalidate = invalidate;
+		if (!isLive) {
+			this.stopLiveTicker();
+			return;
+		}
+		this.#armTicker();
+	}
+
+	stopLiveTicker(): void {
+		if (this.#ticker === undefined) return;
+		clearInterval(this.#ticker);
+		this.#ticker = undefined;
+	}
+
+	#armTicker(): void {
+		if (this.#ticker !== undefined || this.#invalidate === undefined) return;
+		this.#ticker = setInterval(() => this.#tick(), LIVE_RENDER_TICK_MS);
+		this.#ticker.unref?.();
+	}
+
+	#tick(): void {
+		this.#idleTicks += 1;
+		if (this.#idleTicks >= LIVE_TICKER_MAX_IDLE_TICKS) {
+			this.stopLiveTicker();
+			return;
+		}
+		this.#invalidate?.();
+	}
+
+	render(width: number): string[] {
+		this.#idleTicks = 0;
+		if (this.#live) this.#armTicker();
+		const lines: string[] = [];
+		for (const block of this.#blocks) {
+			switch (block.kind) {
+				case "blank":
+					lines.push("");
+					break;
+				case "toolCalls":
+					appendLines(lines, renderToolCallBlock(block, width));
+					break;
+				case "text":
+					appendLines(lines, renderTextBlock(block, width));
+					break;
+				case "dynamic":
+					appendLines(lines, block.render(width));
+					break;
+				default:
+					assertNever(block);
+			}
+		}
+		return lines;
+	}
+
+	invalidate(): void {}
+}
+
+export function componentFor(context: CallRenderContext | ResultRenderContext): PlainTextComponent {
+	const existing = context.lastComponent;
+	if (existing instanceof PlainTextComponent) return existing;
+	return new PlainTextComponent();
+}
+
+/** Render-time clock; tests inject a fixed value so elapsed output never depends on wall time. */
+export function renderNow(context: CallRenderContext | ResultRenderContext): number {
+	const injected: unknown = Reflect.get(context, "now");
+	return typeof injected === "number" && Number.isFinite(injected) ? injected : Date.now();
+}
+
+export function isEvalRunInput(args: EvalToolRequest | Partial<EvalToolInput>): args is EvalToolInput {
+	return args.action === undefined || args.action === "run";
+}
+
+export function style(theme: Theme | undefined, color: ThemeColor, text: string): string {
+	return theme ? theme.fg(color, text) : text;
+}
+
+export function appendLines(target: string[], source: readonly string[]): void {
+	for (const line of source) target.push(line);
+}
+
+export function renderAllVisualLines(text: string, width: number): string[] {
+	return truncateToVisualLines(text, Number.POSITIVE_INFINITY, width).visualLines.map((line) => line.trimEnd());
+}
+
+function renderTextBlock(block: Extract<RenderBlock, { kind: "text" }>, width: number): string[] {
+	if (block.maxVisualLines === undefined) return renderAllVisualLines(block.text, width);
+	const result = truncateToVisualLines(block.text, block.maxVisualLines, width);
+	const visualLines = result.visualLines.map((line) => line.trimEnd());
+	if (result.skippedCount === 0 || block.collapseKind === undefined) return visualLines;
+	return [
+		...renderAllVisualLines(
+			style(block.theme, "muted", `${result.skippedCount} earlier ${block.collapseKind} lines`),
+			width,
+		),
+		...visualLines,
+	];
+}
+
+export function renderToolCall(
+	call: ToolCallRow,
+	block: Extract<RenderBlock, { kind: "toolCalls" }>,
+	width: number,
+): string[] {
+	if (call.error === undefined) return renderAllVisualLines(style(block.theme, call.color, call.summary), width);
+	if (block.expanded)
+		return renderAllVisualLines(style(block.theme, call.color, `${call.summary} (${call.error})`), width);
+
+	const guardedError = codePointPrefix(call.error, TOOL_CALL_COLLAPSED_ERROR_CODE_POINTS);
+	const guardedLines = renderAllVisualLines(
+		style(block.theme, call.color, `${call.summary} (${guardedError})`),
+		width,
+	);
+	if (guardedError.length === call.error.length && guardedLines.length <= TOOL_CALL_COLLAPSED_VISUAL_LINES)
+		return guardedLines;
+
+	const summaryLines = renderAllVisualLines(style(block.theme, call.color, call.summary), width);
+	const errorLines = renderAllVisualLines(style(block.theme, call.color, `  (${guardedError})`), width);
+	const markerLines = renderAllVisualLines(style(block.theme, "muted", TOOL_ERROR_OMISSION_MARKER), width);
+	const lines: string[] = [];
+	const summaryBudget = Math.max(1, TOOL_CALL_COLLAPSED_VISUAL_LINES - markerLines.length);
+	appendLines(lines, summaryLines.slice(0, summaryBudget));
+	const errorBudget = Math.max(0, TOOL_CALL_COLLAPSED_VISUAL_LINES - lines.length - markerLines.length);
+	appendLines(lines, errorLines.slice(0, errorBudget));
+	appendLines(lines, markerLines.slice(0, TOOL_CALL_COLLAPSED_VISUAL_LINES - lines.length));
+	return lines;
+}
+
+function renderToolCallBlock(block: Extract<RenderBlock, { kind: "toolCalls" }>, width: number): string[] {
+	const retainedCalls = block.expanded ? block.calls : block.calls.slice(-TOOL_CALL_PREVIEW_COUNT);
+	const skippedCount = block.calls.length - retainedCalls.length;
+	const toolCallNoun = skippedCount === 1 ? "call" : "calls";
+	const lines =
+		block.expanded || skippedCount === 0
+			? []
+			: renderAllVisualLines(style(block.theme, "muted", `${skippedCount} earlier tool ${toolCallNoun}`), width);
+	for (const call of retainedCalls) {
+		appendLines(lines, renderToolCall(call, block, width));
+	}
+	return lines;
+}
+
+export function assertNever(value: never): never {
+	throw new TypeError(`Unhandled eval render variant: ${String(value)}`);
+}
+
+export function spinner(frame: number | undefined): string {
+	return SPINNER_FRAMES.at((frame ?? 0) % SPINNER_FRAMES.length) ?? SPINNER_FRAMES[0];
+}
+
+export function renderPrefixed(text: string, environment: RenderEnvironment, prefixStyle: PrefixStyle): string[] {
+	const bodyLines = renderAllVisualLines(text, Math.max(1, environment.width - prefixStyle.prefix.length));
+	if (bodyLines.length === 0) return [style(environment.theme, prefixStyle.color, prefixStyle.prefix.trimEnd())];
+	return bodyLines.map(
+		(line, index) =>
+			`${style(environment.theme, prefixStyle.color, index === 0 ? prefixStyle.prefix : prefixStyle.continuation)}${line}`,
+	);
+}
+
+export function previewText(
+	text: string,
+	maxLines: number,
+	width: number,
+): { readonly lines: string[]; readonly skipped: number } {
+	const preview = truncateToVisualLines(text, maxLines, Math.max(1, width));
+	return { lines: preview.visualLines.map((line) => line.trimEnd()), skipped: preview.skippedCount };
+}

package/src/tool/render-call.ts

@@ -0,0 +1,130 @@
+import { sanitizeTerminalLabel, type Theme } from "@code-yeongyu/senpi";
+import { displayCode } from "./display-code.ts";
+import { normalizeEvalSummary } from "./eval-request.ts";
+import { knownLanguage } from "./live-headline.ts";
+import {
+	type CallRenderContext,
+	CODE_PREVIEW_LINES,
+	componentFor,
+	type EvalRenderComponent,
+	isEvalRunInput,
+	type RenderEnvironment,
+	renderNow,
+	renderPrefixed,
+	spinner,
+	style,
+} from "./render-blocks.ts";
+import { renderCell, summaryBlock } from "./render-cell.ts";
+import { headlined, LIVE_LINE_PREFIX } from "./render-live.ts";
+import type { EvalCellResult, EvalToolInput, EvalToolRequest } from "./types.ts";
+
+// The call renderer reads the assistant message's raw arguments, which keep the provider's
+// original summary (senpi#1472 detached preparation from the message), so it normalizes here,
+// idempotently: an already-normalized value is returned unchanged.
+function displaySummary(summary: string | undefined): string | undefined {
+	return normalizeEvalSummary(summary);
+}
+
+function cellIdSuffix(cellId: unknown): string {
+	return typeof cellId === "string" && cellId !== "" ? ` ${sanitizeTerminalLabel(cellId)}` : "";
+}
+
+export function renderEvalCall(
+	args: EvalToolRequest | Partial<EvalToolInput>,
+	theme: Theme | undefined,
+	context: CallRenderContext,
+): EvalRenderComponent {
+	const component = componentFor(context);
+	if (context.hasResult === true) {
+		// The result renderer owns the full pending -> running -> done frame once a result exists.
+		// Rendering the call frame too would stack a duplicate box, so yield to it here.
+		component.syncLiveTicker(false, context.invalidate);
+		component.setBlocks([]);
+		return component;
+	}
+	if (!isEvalRunInput(args)) {
+		// While a peek/stop call streams in, `cell_id` can still be missing; the title is the action alone until it arrives.
+		const cellId = "cell_id" in args ? args.cell_id : undefined;
+		const title = args.action === "list" ? "eval list" : `eval ${args.action}${cellIdSuffix(cellId)}`;
+		component.syncLiveTicker(false, context.invalidate);
+		component.setBlocks([{ kind: "text", text: style(theme, "toolTitle", title) }]);
+		return component;
+	}
+	// While the model streams the call, `code` usually arrives before `language` and `summary`; a partial call still
+	// renders (the host would otherwise fall back to a raw key=value row).
+	const code = typeof args.code === "string" ? args.code : "";
+	const language = knownLanguage(args.language);
+	component.syncLiveTicker(theme !== undefined, context.invalidate);
+	if (theme === undefined && context.spinnerFrame === undefined) {
+		const reset = args.reset === true ? " reset" : "";
+		const timeout = args.timeout === undefined ? "" : ` timeout ${args.timeout}s`;
+		component.setBlocks([
+			{
+				kind: "text",
+				text: style(theme, "toolTitle", `eval${language === undefined ? "" : ` ${language}`}${reset}${timeout}`),
+			},
+			...(displaySummary(args.summary) === undefined
+				? []
+				: [summaryBlock(displaySummary(args.summary) ?? "", theme, context.expanded)]),
+			{
+				kind: "text",
+				text: style(
+					theme,
+					"mdCodeBlock",
+					code.trim().length === 0
+						? "..."
+						: language === undefined
+							? code
+							: displayCode(code, language, context.argsComplete ? context.invalidate : undefined),
+				),
+				maxVisualLines: context.expanded ? undefined : CODE_PREVIEW_LINES,
+				collapseKind: "code",
+				theme,
+			},
+		]);
+		return component;
+	}
+	component.setBlocks([
+		{
+			kind: "dynamic",
+			render: (width) => {
+				const environment: RenderEnvironment = {
+					expanded: context.expanded,
+					theme,
+					spinnerFrame: context.spinnerFrame,
+					width,
+					meta: undefined,
+					now: renderNow(context),
+					...(context.argsComplete ? { repaint: context.invalidate } : {}),
+				};
+				const summary = displaySummary(args.summary);
+				if (language === undefined) return streamingCallLines(summary, code, environment);
+				// The host never supplies a spinner frame for an eval call, so the state comes from
+				// the call lane itself: run args are present and no result exists yet (review MEDIUM-1).
+				// The ticker (armed in renderEvalCall) repaints the block, so the spinner advances.
+				const streaming = context.hasResult !== true;
+				const cell: EvalCellResult = {
+					index: 0,
+					...(summary === undefined ? {} : { summary }),
+					code,
+					language,
+					output: "",
+					status: streaming ? "running" : "pending",
+				};
+				return renderCell(cell, environment, {
+					reset: args.reset === true,
+					timeout: args.timeout,
+					throughput: undefined,
+					streaming,
+				});
+			},
+		},
+	]);
+	return component;
+}
+
+/** A call whose language has not streamed in yet: the headline row alone, until the full frame can render. */
+function streamingCallLines(summary: string | undefined, code: string, environment: RenderEnvironment): string[] {
+	const icon = environment.spinnerFrame === undefined ? "○" : spinner(environment.spinnerFrame);
+	return renderPrefixed(headlined(icon, summary, code, "eval", environment), environment, LIVE_LINE_PREFIX);
+}

package/src/tool/render-cell.ts

@@ -0,0 +1,165 @@
+import { highlightedCode } from "./code-preview.ts";
+import { leadsWithHeadline } from "./live-headline.ts";
+import { renderAgentProgressEvents } from "./render-agent.ts";
+import {
+	appendLines,
+	assertNever,
+	CODE_PREVIEW_LINES,
+	OUTPUT_PREVIEW_LINES,
+	previewText,
+	type RenderBlock,
+	type RenderEnvironment,
+	renderAllVisualLines,
+	renderPrefixed,
+	SUMMARY_PREVIEW_LINES,
+	style,
+} from "./render-blocks.ts";
+import {
+	type CellBadges,
+	cellElapsedMs,
+	cellHeader,
+	cellPresentation,
+	FRAME_HEADER_PREFIX,
+	FRAME_INNER_PREFIX,
+	headlined,
+	LIVE_LINE_PREFIX,
+	renderLiveCellFrame,
+} from "./render-live.ts";
+import { formatThroughputBadge } from "./render-status.ts";
+import { cellOutputSection, cellStatusSection } from "./render-tail.ts";
+import { formatRuntimeBadge } from "./runtime-label.ts";
+import { formatDuration } from "./tool-widgets.ts";
+import type { EvalCellResult } from "./types.ts";
+
+export type { CellBadges } from "./render-live.ts";
+export { LIVE_CODE_WINDOW_LINES } from "./render-live.ts";
+
+// A summary has no length limit, so a collapsed block shows its first lines and marks the cut.
+function summaryVisualLines(summary: string, width: number, expanded: boolean): string[] {
+	const lines = renderAllVisualLines(summary, width);
+	if (expanded || lines.length <= SUMMARY_PREVIEW_LINES) return lines;
+	const kept = renderAllVisualLines(summary, Math.max(1, width - 1)).slice(0, SUMMARY_PREVIEW_LINES);
+	kept[SUMMARY_PREVIEW_LINES - 1] = `${kept[SUMMARY_PREVIEW_LINES - 1] ?? ""}…`;
+	return kept;
+}
+
+export function summaryBlock(summary: string, theme: RenderEnvironment["theme"], expanded: boolean): RenderBlock {
+	return {
+		kind: "dynamic",
+		render: (width) => summaryVisualLines(summary, width, expanded).map((line) => style(theme, "muted", line)),
+	};
+}
+
+export function renderCell(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string[] {
+	const agentEvents = (cell.statusEvents ?? []).filter((event) => event.op === "agent");
+	const lines = renderCellFrame(cell, environment, badges);
+	if (agentEvents.length > 0) appendLines(lines, renderAgentProgressEvents(agentEvents, environment));
+	return lines;
+}
+
+function renderCellFrame(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string[] {
+	switch (cell.status) {
+		case "pending":
+		case "queued":
+		case "running":
+			return environment.expanded
+				? renderExpandedCellFrame(cell, environment, badges)
+				: renderLiveCellFrame(cell, environment, badges);
+		case "complete":
+		case "error":
+		case "cancelled":
+			return environment.expanded
+				? renderExpandedCellFrame(cell, environment, badges)
+				: renderTerminalCellLine(cell, environment, badges);
+		case "detached":
+			return environment.expanded
+				? renderExpandedCellFrame(cell, environment, badges)
+				: renderDetachedCellFrame(cell, environment, badges);
+		default:
+			return assertNever(cell.status);
+	}
+}
+
+// A terminal row collapses to one line: icon, the cell's headline (summary or first code line),
+// status and duration. The full frame stays reachable through the expand action.
+function renderTerminalCellLine(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string[] {
+	const presentation = cellPresentation(cell.status, environment.spinnerFrame);
+	const runtimeBadge = cell.runtime === undefined ? "" : ` (${formatRuntimeBadge(cell.language, cell.runtime)})`;
+	// The runtime badge rides the base label when it fits (review MEDIUM-1); when it would wrap
+	// the row it drops like any badge, so the done row stays one line at any width.
+	const segments: string[] = [];
+	if (badges.throughput !== undefined) {
+		const badge = formatThroughputBadge(badges.throughput);
+		if (badge !== undefined) segments.push(badge);
+	}
+	const elapsedMs = badges.throughput?.wallDurationMs ?? cellElapsedMs(cell, environment);
+	if (elapsedMs !== undefined) segments.push(formatDuration(elapsedMs));
+	if (badges.reset) segments.push("reset");
+	if (badges.timeout !== undefined) segments.push(`timeout ${badges.timeout}s`);
+	const tail = segments.length === 0 ? "" : ` · ${segments.join(" · ")}`;
+	const rest = `eval ${cell.language}${runtimeBadge} ${presentation.label}${tail}`;
+	const badgelessRest = runtimeBadge === "" ? rest : `eval ${cell.language} ${presentation.label}${tail}`;
+	const line = style(
+		environment.theme,
+		presentation.color,
+		headlined(presentation.icon, cell.summary, cell.code, rest, environment, { badgelessRest }),
+	);
+	return renderPrefixed(line, environment, LIVE_LINE_PREFIX);
+}
+
+// A detached row keeps its collapsed frame: the cell is no longer live, but its output and status
+// history are the reason it is inspected, so they stay visible without expand.
+function renderDetachedCellFrame(cell: EvalCellResult, environment: RenderEnvironment, badges: CellBadges): string[] {
+	if (cell.output.trim().length === 0) {
+		const statusEvents = (cell.statusEvents ?? []).filter((event) => event.op !== "agent");
+		if (statusEvents.length === 0)
+			return renderPrefixed(cellHeader(cell, environment, badges), environment, LIVE_LINE_PREFIX);
+	}
+	return renderExpandedCellFrame(cell, environment, badges, { collapsedPreviews: true });
+}
+
+function renderExpandedCellFrame(
+	cell: EvalCellResult,
+	environment: RenderEnvironment,
+	badges: CellBadges,
+	options: { readonly collapsedPreviews?: boolean } = {},
+): string[] {
+	const previewsCollapsed = options.collapsedPreviews === true && !environment.expanded;
+	const lines = renderPrefixed(cellHeader(cell, environment, badges), environment, FRAME_HEADER_PREFIX);
+	if (cell.summary !== undefined && !leadsWithHeadline(cell.status)) {
+		appendLines(
+			lines,
+			summaryVisualLines(cell.summary, Math.max(1, environment.width - 2), environment.expanded).map(
+				(line) => `${style(environment.theme, "muted", "│ ")}${style(environment.theme, "muted", line)}`,
+			),
+		);
+	}
+	const innerWidth = Math.max(1, environment.width - 2);
+	const codePreview = previewText(
+		highlightedCodeForFrame(cell, environment),
+		previewsCollapsed ? CODE_PREVIEW_LINES : Number.POSITIVE_INFINITY,
+		innerWidth,
+	);
+	if (codePreview.skipped > 0) {
+		appendLines(
+			lines,
+			renderPrefixed(`${codePreview.skipped} earlier code lines`, environment, {
+				prefix: "│ ",
+				continuation: "│ ",
+				color: "muted",
+			}),
+		);
+	}
+	for (const line of codePreview.lines) appendLines(lines, renderPrefixed(line, environment, FRAME_INNER_PREFIX));
+	appendLines(
+		lines,
+		cellOutputSection(cell, environment, previewsCollapsed ? OUTPUT_PREVIEW_LINES : Number.POSITIVE_INFINITY),
+	);
+	appendLines(lines, cellStatusSection(cell, environment));
+	lines.push(style(environment.theme, "borderMuted", "╰─"));
+	return lines;
+}
+
+function highlightedCodeForFrame(cell: EvalCellResult, environment: RenderEnvironment): string {
+	return highlightedCode(cell.code, cell.language, environment.theme, environment.repaint);
+}