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

package/src/tool/render-status.ts

@@ -0,0 +1,166 @@
+import type { Theme } from "@code-yeongyu/senpi";
+import { type RenderEnvironment, STATUS_PREVIEW_COUNT, style } from "./render-blocks.ts";
+import type { EvalStatusEvent } from "./types.ts";
+
+export function eventString(value: unknown): string | undefined {
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function eventNumber(value: unknown): number {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+
+function plural(count: number, singular: string, pluralNoun: string): string {
+	return `${count} ${count === 1 ? singular : pluralNoun}`;
+}
+
+function formatCallsPerSecond(calls: number, wallDurationMs: number | undefined): string {
+	const seconds = typeof wallDurationMs === "number" && Number.isFinite(wallDurationMs) ? wallDurationMs / 1_000 : 0;
+	if (seconds <= 0) return "n/a calls/s";
+	return `${(calls / seconds).toFixed(2)} calls/s`;
+}
+
+// A cell that issued no tool calls has no throughput to report: emitting
+// "0 calls · 0.00 calls/s" is noise, so the whole badge is dropped instead.
+export function formatThroughputBadge(throughput: {
+	readonly calls: number;
+	readonly wallDurationMs: number | undefined;
+}): string | undefined {
+	if (throughput.calls <= 0) return undefined;
+	return `${plural(throughput.calls, "call", "calls")} · ${formatCallsPerSecond(
+		throughput.calls,
+		throughput.wallDurationMs,
+	)}`;
+}
+
+function statusIcon(op: string): string {
+	if (op.startsWith("git_")) return "⌁";
+	switch (op) {
+		case "read":
+		case "write":
+		case "cat":
+		case "touch":
+			return "▣";
+		case "ls":
+		case "cd":
+		case "pwd":
+		case "mkdir":
+			return "▤";
+		case "run":
+		case "sh":
+			return "▶";
+		case "completion":
+			return "◇";
+		case "phase":
+			return "◆";
+		default:
+			return "•";
+	}
+}
+
+function formatStatusEvent(event: EvalStatusEvent, theme: Theme | undefined): string {
+	const op = event.op;
+	const icon = style(theme, "muted", statusIcon(op));
+	const error = eventString(event.error);
+	if (error !== undefined) return `${icon} ${style(theme, "warning", op)}: ${style(theme, "dim", error)}`;
+	const parts: string[] = [];
+	switch (op) {
+		case "read": {
+			parts.push(`${eventNumber(event.chars ?? event.bytes)} chars`);
+			const path = eventString(event.path);
+			if (path !== undefined) parts.push(`from ${path}`);
+			break;
+		}
+		case "write": {
+			parts.push(`${eventNumber(event.chars ?? event.bytes)} chars`);
+			const path = eventString(event.path);
+			if (path !== undefined) parts.push(`to ${path}`);
+			break;
+		}
+		case "cat":
+			parts.push(plural(eventNumber(event.files), "file", "files"));
+			parts.push(`${eventNumber(event.chars)} chars`);
+			break;
+		case "ls":
+			parts.push(plural(eventNumber(event.count), "entry", "entries"));
+			break;
+		case "env": {
+			const action = eventString(event.action);
+			const key = eventString(event.key);
+			const value = eventString(event.value) ?? "";
+			if (action === "set" && key !== undefined) parts.push(`set ${key}=${value.slice(0, 30)}`);
+			else if (action === "get" && key !== undefined) parts.push(`${key}=${value.slice(0, 30)}`);
+			else parts.push(plural(eventNumber(event.count), "variable", "variables"));
+			break;
+		}
+		case "git_status": {
+			if (event.clean === true) parts.push("clean");
+			else {
+				const changes: string[] = [];
+				for (const key of ["staged", "modified", "untracked"] as const) {
+					const count = eventNumber(event[key]);
+					if (count > 0) changes.push(`${count} ${key}`);
+				}
+				parts.push(changes.join(", ") || "unknown");
+			}
+			const branch = eventString(event.branch);
+			if (branch !== undefined) parts.push(`on ${branch}`);
+			break;
+		}
+		case "git_diff":
+			parts.push(plural(eventNumber(event.lines), "line", "lines"));
+			if (event.staged === true) parts.push("staged");
+			break;
+		case "git_log":
+			parts.push(plural(eventNumber(event.commits), "commit", "commits"));
+			break;
+		case "run":
+		case "sh": {
+			const command = eventString(event.command ?? event.cmd);
+			if (command !== undefined) parts.push(command);
+			if (typeof event.exitCode === "number") parts.push(`exit ${event.exitCode}`);
+			break;
+		}
+		case "completion": {
+			const model = eventString(event.model);
+			const tier = eventString(event.tier);
+			if (model !== undefined) parts.push(model);
+			if (tier !== undefined && tier !== model) parts.push(tier);
+			parts.push(`${eventNumber(event.chars)} chars`);
+			break;
+		}
+		case "log":
+			parts.push(eventString(event.message) ?? "");
+			break;
+		case "phase":
+			parts.push(eventString(event.title) ?? "");
+			break;
+		case "status-events-omitted":
+			parts.push(`${eventNumber(event.count)} earlier events omitted`);
+			break;
+		default: {
+			if (event.count !== undefined) parts.push(String(event.count));
+			const path = eventString(event.path);
+			if (path !== undefined) parts.push(path);
+		}
+	}
+	const description = parts.filter((part) => part.length > 0).join(" · ");
+	return `${icon} ${style(theme, "muted", op)}${description.length > 0 ? ` ${style(theme, "dim", description)}` : ""}`;
+}
+
+export function renderStatusEvents(events: readonly EvalStatusEvent[], environment: RenderEnvironment): string[] {
+	// A bounded history stores its exact omission count in a leading marker event; fold that
+	// count into the summary line so collapsing the preview can never understate omissions.
+	const first = events[0];
+	const omittedByBound = first?.op === "status-events-omitted" && typeof first.count === "number" ? first.count : 0;
+	const visible = omittedByBound > 0 ? events.slice(1) : events;
+	const retained = environment.expanded ? visible : visible.slice(-STATUS_PREVIEW_COUNT);
+	const skipped = visible.length - retained.length + omittedByBound;
+	const lines: string[] = [];
+	if (skipped > 0) lines.push(style(environment.theme, "dim", `├ … ${skipped} earlier status events`));
+	for (const [index, event] of retained.entries()) {
+		const branch = index === retained.length - 1 ? "└" : "├";
+		lines.push(`${style(environment.theme, "dim", branch)} ${formatStatusEvent(event, environment.theme)}`);
+	}
+	return lines;
+}

package/src/tool/render-tail.ts

@@ -0,0 +1,139 @@
+import { visibleWidth } from "@code-yeongyu/senpi";
+import { appendLines, previewText, type RenderEnvironment, renderPrefixed, style } from "./render-blocks.ts";
+import { FRAME_INNER_PREFIX, FRAME_SECTION_PREFIX } from "./render-live.ts";
+import { renderStatusEvents } from "./render-status.ts";
+import type { EvalCellResult } from "./types.ts";
+
+export function cellOutputSection(
+	cell: EvalCellResult,
+	environment: RenderEnvironment,
+	maxLinesOrBudget: number,
+	rowBudget?: number,
+): string[] {
+	const output = cell.output.trimEnd();
+	if (output.length === 0) return [];
+	const lines = renderPrefixed("output", environment, FRAME_SECTION_PREFIX);
+	const outputColor = cell.status === "error" ? "error" : "toolOutput";
+	const styledOutput = output
+		.split("\n")
+		.map((line) => style(environment.theme, outputColor, line))
+		.join("\n");
+	const innerWidth = Math.max(1, environment.width - 2);
+	if (rowBudget !== undefined) {
+		// Fit and pad inside the row budget (review HIGH-C): header + body never exceed the
+		// budget, the marker consumes one body row when anything is hidden, and a short section
+		// is padded so the block's total height never changes. The marker counts every hidden
+		// row (review NEW-1): the kept tail plus the marker together are the whole output.
+		const bodyRows = rowBudget - 1;
+		const preview = previewText(styledOutput, bodyRows, innerWidth);
+		const body: string[] = [];
+		const kept = preview.skipped > 0 ? preview.lines.slice(-(bodyRows - 1)) : preview.lines;
+		const omitted = preview.skipped + preview.lines.length - kept.length;
+		if (omitted > 0) {
+			appendLines(
+				body,
+				renderPrefixed(`${omitted} earlier output lines`, environment, {
+					prefix: "│ ",
+					continuation: "│ ",
+					color: "muted",
+				}),
+			);
+		}
+		for (const line of kept) appendLines(body, renderPrefixed(line, environment, FRAME_INNER_PREFIX));
+		const rows = [...lines, ...body];
+		while (rows.length < rowBudget) rows.push(style(environment.theme, "borderMuted", "│ "));
+		return rows.slice(0, rowBudget);
+	}
+	const preview = previewText(styledOutput, maxLinesOrBudget, innerWidth);
+	if (preview.skipped > 0)
+		appendLines(
+			lines,
+			renderPrefixed(`${preview.skipped} earlier output lines`, environment, {
+				prefix: "│ ",
+				continuation: "│ ",
+				color: "muted",
+			}),
+		);
+	for (const line of preview.lines) appendLines(lines, renderPrefixed(line, environment, FRAME_INNER_PREFIX));
+	return lines;
+}
+
+export function cellStatusSection(cell: EvalCellResult, environment: RenderEnvironment, rowBudget?: number): string[] {
+	const statusEvents = (cell.statusEvents ?? []).filter((event) => event.op !== "agent");
+	if (statusEvents.length === 0) return [];
+	if (rowBudget === undefined) {
+		const lines = renderPrefixed("status", environment, FRAME_SECTION_PREFIX);
+		for (const line of renderStatusEvents(statusEvents, environment))
+			appendLines(lines, renderPrefixed(line, environment, FRAME_INNER_PREFIX));
+		return lines;
+	}
+	// Budget in visual ROWS, not events (review HIGH-C). The tail keeps the NEWEST rows (review
+	// NEW-2): whole events fold from the front into the exact marker when their rows overflow,
+	// and a single event that alone overflows keeps its newest rows while the marker counts the
+	// rows cut from its head. Rows are kept or dropped whole, never re-styled (review r4 HIGH-1).
+	const first = statusEvents[0];
+	const omittedByBound = first?.op === "status-events-omitted" && typeof first.count === "number" ? first.count : 0;
+	const visible = omittedByBound > 0 ? statusEvents.slice(1) : statusEvents;
+	const bodyRows = rowBudget - 1;
+	// Render each event to its own rows so whole events fold cleanly. The fold marker counts
+	// exactly the folded events plus the stored bound (review HIGH-2, HIGH-C).
+	const perEvent = visible.map((event) => {
+		const rendered = renderStatusEvents([event], { ...environment, expanded: true });
+		const rows: string[] = [];
+		for (const line of rendered) appendLines(rows, renderPrefixed(line, environment, FRAME_INNER_PREFIX));
+		return rows;
+	});
+	// Keep events from the newest until the next-older one would overflow the body; the newest
+	// event is always kept, even when it alone overflows (review NEW-2). The fold marker counts
+	// exactly the folded events plus the stored bound (review HIGH-2, HIGH-C).
+	const keptEvents: string[][] = [];
+	let used = 0;
+	let firstShown = perEvent.length;
+	for (let i = perEvent.length - 1; i >= 0; i--) {
+		const rows = perEvent[i] ?? [];
+		// The fold marker appears whenever anything older than event i (an earlier event or the
+		// stored bound) is hidden, so it reserves one body row of the budget for keeping event i.
+		const marker = i > 0 || omittedByBound > 0 ? 1 : 0;
+		if (used + rows.length <= bodyRows - marker || keptEvents.length === 0) {
+			keptEvents.unshift(rows);
+			used += rows.length;
+			firstShown = i;
+		} else {
+			break;
+		}
+	}
+	const skipped = firstShown + omittedByBound;
+	const eventRows: string[] = [];
+	for (const rows of keptEvents) appendLines(eventRows, rows);
+	// A still-overflowing tail is a single event taller than its share: keep its newest rows and
+	// count the rows cut from its head in the marker, which then always takes one body row.
+	const needsMarker = skipped > 0 || eventRows.length > bodyRows;
+	const shownBudget = Math.max(0, bodyRows - (needsMarker ? 1 : 0));
+	const cutRows = Math.max(0, eventRows.length - shownBudget);
+	const body: string[] = [];
+	if (needsMarker) body.push(statusMarker(skipped, cutRows, environment));
+	appendLines(body, eventRows.slice(cutRows));
+	const rows = [...renderPrefixed("status", environment, FRAME_SECTION_PREFIX), ...body.slice(0, bodyRows)];
+	while (rows.length < rowBudget) rows.push(style(environment.theme, "borderMuted", "│ "));
+	return rows;
+}
+
+// The fold marker is always exactly one row: the longest wording that fits the width wins, so
+// both counts survive narrow terminals (review r4 HIGH-1, MEDIUM-1).
+function statusMarker(skippedEvents: number, cutRows: number, environment: RenderEnvironment): string {
+	const candidates =
+		cutRows === 0
+			? [`├ … ${skippedEvents} earlier status events`, `├ … ${skippedEvents} earlier`, `├ … ${skippedEvents}`]
+			: skippedEvents === 0
+				? [`├ … ${cutRows} earlier rows of this event`, `├ … ${cutRows} earlier rows`, `├ … ${cutRows} rows`]
+				: [
+						`├ … ${skippedEvents} earlier status events, ${cutRows} rows`,
+						`├ … ${skippedEvents} events, ${cutRows} rows`,
+						`├ … ${skippedEvents} ev, ${cutRows} rows`,
+						`├ … ${skippedEvents}ev ${cutRows}r`,
+					];
+	const innerWidth = Math.max(1, environment.width - visibleWidth(FRAME_INNER_PREFIX.prefix));
+	const text = candidates.find((candidate) => visibleWidth(candidate) <= innerWidth) ?? candidates.at(-1) ?? "";
+	const [row] = renderPrefixed(text, environment, { prefix: "│ ", continuation: "│ ", color: "dim" });
+	return row ?? "";
+}