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

package/src/tools/vibe.ts

@@ -0,0 +1,420 @@
+import type { Component } from "../tui";
+import { Text } from "../components/text";
+import { shimmerEnabled, shimmerText } from "../theme/shimmer";
+import type { Theme } from "../theme/theme";
+import { oneLineLabel } from "./task";
+import { renderStatusLine } from "../render/index";
+import {
+	Ellipsis,
+	formatBadge,
+	formatDuration,
+	formatStatusIcon,
+	replaceTabs,
+	type ToolUIColor,
+	type ToolUIStatus,
+	truncateToWidth,
+} from "../render/render-utils";
+import type { RenderResultOptions, ToolRenderer } from "./renderer";
+/** Operation represented by a worker-session tool result. */
+export type VibeOp = "spawn" | "send" | "wait" | "kill" | "list";
+
+/** Details payload shared by every vibe tool for TUI rendering. */
+export interface VibeToolDetails {
+	op: VibeOp;
+	/** Live TV-wall snapshot of the owner's worker sessions at (or during) the call. */
+	screens: VibeScreenSnapshot[];
+	spawned?: { id: string; cli: VibeCli; jobId: string };
+	send?: VibeSendOutcome;
+	wait?: {
+		settled: Array<{ id: string; jobId: string; status: "completed" | "failed" | "cancelled" }>;
+		stillRunning: string[];
+		timedOut: boolean;
+		/** True on interim progress emissions while the wait is still blocking. */
+		waiting?: boolean;
+	};
+	killed?: VibeKillOutcome;
+}
+/** Worker session lifecycle as shown to the director. */
+export type VibeSessionState = "starting" | "running" | "idle" | "dead";
+
+/**
+ * Live per-session "screen" for rich rendering: what the worker is doing right
+ * now (tool trace, current tool, streamed text tail) plus roster metadata.
+ * Every string is already one-line sanitized.
+ */
+export interface VibeScreenSnapshot {
+	id: string;
+	cli: VibeCli;
+	state: VibeSessionState;
+	model?: string;
+	turns: number;
+	queued: number;
+	/** Start of the in-flight turn, when running. */
+	turnStartedAt?: number;
+	/** Gist of the message that started the in-flight turn. */
+	turnMessage?: string;
+	currentTool?: string;
+	currentToolArgs?: string;
+	lastIntent?: string;
+	/** Completed tool calls of the in-flight turn, oldest first (tail). */
+	trace: string[];
+	/** Latest streamed worker text lines, oldest first. */
+	outputTail: string[];
+	lastActivity?: string;
+	lastActivityAt: number;
+}
+
+/** Worker identity and job handle returned by a spawn. */
+export interface VibeSpawnOutcome {
+	id: string;
+	jobId: string;
+}
+
+/** Delivery mode and optional turn job for a worker message. */
+export interface VibeSendOutcome {
+	id: string;
+	/**
+	 * - `turn`: a new background turn was started (`jobId` set).
+	 * - `steered`: worker was mid-turn and streaming; delivered as steering.
+	 * - `queued`: worker was mid-turn but not steerable; drained into the next turn.
+	 */
+	mode: "turn" | "steered" | "queued";
+	jobId?: string;
+}
+
+/** Worker shutdown outcome including any cancelled turn. */
+export interface VibeKillOutcome {
+	id: string;
+	/** True when an in-flight turn job was cancelled along the way. */
+	cancelledTurn: boolean;
+}
+
+/** Settled and still-running worker turns observed by a wait. */
+export interface VibeWaitOutcome {
+	/** Watched sessions whose snapshotted turn settled during (or before) the wait.
+	 * May overlap `stillRunning` when a queued follow-up turn already started. */
+	settled: Array<{ id: string; jobId: string; status: "completed" | "failed" | "cancelled"; resultText: string }>;
+	/** Watched sessions with a turn in flight when the wait returned. */
+	stillRunning: string[];
+	timedOut: boolean;
+}
+/** The two worker CLI flavors the director drives. */
+export type VibeCli = "fast" | "good";
+// =============================================================================
+// TUI Renderer — mini composer (spawn/send) + TV wall (wait/list)
+// =============================================================================
+
+const COMPOSER_LINE_MAX = 96;
+const TV_LINE_MAX = 110;
+const TV_TRACE_COLLAPSED = 2;
+const TV_TRACE_EXPANDED = 6;
+const TV_OUTPUT_COLLAPSED = 1;
+const TV_OUTPUT_EXPANDED = 3;
+const CURSOR_GLYPH = "▌";
+
+function stateToIcon(state: VibeSessionState): ToolUIStatus {
+	switch (state) {
+		case "running":
+			return "running";
+		case "starting":
+			return "pending";
+		case "idle":
+			return "done";
+		case "dead":
+			return "aborted";
+	}
+}
+
+function stateToColor(state: VibeSessionState): ToolUIColor {
+	switch (state) {
+		case "running":
+			return "accent";
+		case "starting":
+			return "accent";
+		case "idle":
+			return "success";
+		case "dead":
+			return "muted";
+	}
+}
+
+interface VibeRenderArgs {
+	cli?: VibeCli;
+	prompt?: string;
+	name?: string;
+	session?: string;
+	message?: string;
+	sessions?: string[];
+}
+
+/** One-line, escape-stripped fragment for embedding in a frame row. */
+function frameText(text: string, max: number): string {
+	return oneLineLabel(replaceTabs(text), max);
+}
+
+/**
+ * Draw a left-railed mini terminal:
+ * ```
+ * ╭─ <header>
+ * │ <body…>
+ * ╰─ <footer>
+ * ```
+ */
+function miniFrame(uiTheme: Theme, header: string, body: string[], footer?: string): string[] {
+	const box = uiTheme.boxRound;
+	const rail = (glyph: string) => uiTheme.fg("dim", glyph);
+	const lines = [`${rail(`${box.topLeft}${box.horizontal}`)} ${header}`];
+	for (const row of body) {
+		lines.push(`${rail(box.vertical)} ${row}`);
+	}
+	lines.push(
+		footer ? `${rail(`${box.bottomLeft}${box.horizontal}`)} ${footer}` : rail(`${box.bottomLeft}${box.horizontal}`),
+	);
+	return lines;
+}
+
+/** The `>` composer rows of the mini CLI: the director's message being typed in. */
+function composerRows(uiTheme: Theme, message: string, options: { cursor: boolean; expanded: boolean }): string[] {
+	const promptGlyph = uiTheme.fg("accent", ">");
+	const rawLines = message.split(/\r?\n/).filter(line => line.trim().length > 0);
+	const maxRows = options.expanded ? 6 : 2;
+	const visible = rawLines.slice(0, maxRows).map(line => frameText(line, COMPOSER_LINE_MAX));
+	if (visible.length === 0) visible.push("");
+	if (rawLines.length > maxRows) {
+		visible[visible.length - 1] = `${visible[visible.length - 1]} …`;
+	} else if (options.cursor) {
+		visible[visible.length - 1] = `${visible[visible.length - 1]}${uiTheme.fg("accent", CURSOR_GLYPH)}`;
+	}
+	return visible.map((line, index) =>
+		index === 0 ? `${promptGlyph} ${uiTheme.fg("toolOutput", line)}` : `  ${uiTheme.fg("toolOutput", line)}`,
+	);
+}
+
+/** Render one worker "TV": header + live tool calls + streamed text tail. */
+function tvScreen(
+	uiTheme: Theme,
+	screen: VibeScreenSnapshot,
+	options: RenderResultOptions,
+	settledStatus?: "completed" | "failed" | "cancelled",
+): string[] {
+	const live = screen.state === "running" || screen.state === "starting";
+	const spinnerFrame = live ? options.spinnerFrame : undefined;
+	const icon = formatStatusIcon(
+		settledStatus === "failed" ? "error" : settledStatus === "cancelled" ? "aborted" : stateToIcon(screen.state),
+		uiTheme,
+		spinnerFrame,
+	);
+	const badge = formatBadge(screen.cli, stateToColor(screen.state), uiTheme);
+	const idText =
+		live && options.spinnerFrame !== undefined && shimmerEnabled()
+			? shimmerText(screen.id, uiTheme)
+			: uiTheme.fg(live ? "accent" : "toolOutput", screen.id);
+	const headParts = [icon, badge, idText, uiTheme.fg("dim", settledStatus ?? screen.state)];
+	const turnsLabel = `${screen.turns}t${screen.queued > 0 ? `+${screen.queued}q` : ""}`;
+	headParts.push(uiTheme.fg("muted", turnsLabel));
+	if (screen.turnStartedAt !== undefined) {
+		headParts.push(uiTheme.fg("dim", formatDuration(Date.now() - screen.turnStartedAt)));
+	}
+	if (screen.model) headParts.push(uiTheme.fg("muted", frameText(screen.model, 40)));
+
+	const body: string[] = [];
+	const hook = uiTheme.tree.hook;
+	if (live) {
+		if (screen.turnMessage) {
+			body.push(`${uiTheme.fg("accent", ">")} ${uiTheme.fg("dim", frameText(screen.turnMessage, TV_LINE_MAX))}`);
+		}
+		const traceCap = options.expanded ? TV_TRACE_EXPANDED : TV_TRACE_COLLAPSED;
+		for (const line of screen.trace.slice(-traceCap)) {
+			body.push(`${uiTheme.fg("dim", hook)} ${uiTheme.fg("dim", frameText(line, TV_LINE_MAX))}`);
+		}
+		if (screen.currentTool) {
+			const detail = screen.lastIntent ?? screen.currentToolArgs;
+			const label = `${screen.currentTool}${detail ? `: ${detail}` : ""}`;
+			const painted =
+				options.spinnerFrame !== undefined && shimmerEnabled()
+					? shimmerText(frameText(label, TV_LINE_MAX), uiTheme)
+					: uiTheme.fg("muted", frameText(label, TV_LINE_MAX));
+			body.push(`${uiTheme.fg("accent", hook)} ${painted}`);
+		} else if (screen.lastIntent) {
+			body.push(`${uiTheme.fg("accent", hook)} ${uiTheme.fg("muted", frameText(screen.lastIntent, TV_LINE_MAX))}`);
+		}
+		const outputCap = options.expanded ? TV_OUTPUT_EXPANDED : TV_OUTPUT_COLLAPSED;
+		for (const line of screen.outputTail.slice(-outputCap)) {
+			if (line.trim().length === 0) continue;
+			body.push(`  ${uiTheme.fg("muted", frameText(line, TV_LINE_MAX))}`);
+		}
+	} else if (screen.lastActivity) {
+		body.push(`${uiTheme.fg("dim", hook)} ${uiTheme.fg("muted", frameText(screen.lastActivity, TV_LINE_MAX))}`);
+	}
+	const footer = settledStatus
+		? uiTheme.fg(
+				settledStatus === "completed" ? "success" : settledStatus === "failed" ? "error" : "warning",
+				`turn ${settledStatus} — result delivered`,
+			)
+		: undefined;
+	return miniFrame(uiTheme, headParts.join(" "), body, footer);
+}
+
+/**
+ * Width-aware component over prebuilt lines, or — given a builder — lines
+ * recomputed on every paint. Spinner ticks repaint the tool block WITHOUT
+ * re-invoking renderCall/renderResult, so time-based content (shimmer sweep,
+ * spinner glyph, cursor blink, elapsed turn duration) must be produced inside
+ * a builder that reads the shared mutable `options` at paint time; prebuilt
+ * arrays are for static frames only.
+ */
+function linesComponent(lines: string[] | (() => string[])): Component {
+	return {
+		render(width: number): readonly string[] {
+			const rows = typeof lines === "function" ? lines() : lines;
+			return rows.map(line => truncateToWidth(line, width, Ellipsis.Unicode));
+		},
+		invalidate() {},
+	};
+}
+
+function describeCall(op: VibeOp, args: VibeRenderArgs | undefined): string {
+	switch (op) {
+		case "spawn":
+			return `spawn ${args?.cli ?? "?"}${args?.name ? ` · ${frameText(args.name, 40)}` : ""}`;
+		case "send":
+			return `send → ${args?.session ? frameText(args.session, 40) : "?"}`;
+		case "wait":
+			return args?.sessions?.length
+				? `wait on ${frameText(args.sessions.join(", "), 60)}`
+				: "wait on running sessions";
+		case "kill":
+			return `kill ${args?.session ? frameText(args.session, 40) : "?"}`;
+		case "list":
+			return "sessions";
+	}
+}
+
+/** Build the shared vibe renderer for one tool name. */
+export function createVibeToolRenderer(op: VibeOp) {
+	const composerOp = op === "spawn" || op === "send";
+	return {
+		inline: true,
+		mergeCallAndResult: true,
+		animatedPendingPreview: composerOp,
+		animatedPartialResult: op === "wait",
+
+		renderCall(args: VibeRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
+			const title = uiTheme.fg("muted", `vibe ${describeCall(op, args)}`);
+			if (composerOp) {
+				const message = op === "spawn" ? (args?.prompt ?? "") : (args?.message ?? "");
+				return linesComponent(() => {
+					const cursorOn = ((options.spinnerFrame ?? 0) & 1) === 0;
+					return miniFrame(
+						uiTheme,
+						title,
+						composerRows(uiTheme, message, { cursor: cursorOn, expanded: options.expanded }),
+						uiTheme.fg("dim", op === "spawn" ? "booting CLI…" : "delivering…"),
+					);
+				});
+			}
+			return new Text(renderStatusLine({ icon: "pending", title: `vibe ${describeCall(op, args)}` }, uiTheme), 0, 0);
+		},
+
+		renderResult(
+			result: { content: Array<{ type: string; text?: string }>; details?: VibeToolDetails; isError?: boolean },
+			options: RenderResultOptions,
+			uiTheme: Theme,
+			args?: VibeRenderArgs,
+		): Component {
+			const details = result.details;
+			if (!details || result.isError) {
+				const fallback = result.content.find(part => part.type === "text")?.text ?? "";
+				const header = renderStatusLine(
+					{ icon: result.isError ? "error" : "done", title: `vibe ${describeCall(op, args)}` },
+					uiTheme,
+				);
+				const body = fallback
+					? `\n  ${uiTheme.fg(result.isError ? "error" : "dim", frameText(fallback, TV_LINE_MAX))}`
+					: "";
+				return new Text(`${header}${body}`, 0, 0);
+			}
+
+			if (composerOp) {
+				const message = op === "spawn" ? (args?.prompt ?? "") : (args?.message ?? "");
+				const target =
+					op === "spawn"
+						? `${uiTheme.fg("muted", "vibe spawn")} ${formatBadge(details.spawned?.cli ?? args?.cli ?? "?", "accent", uiTheme)} ${uiTheme.fg("accent", frameText(details.spawned?.id ?? args?.name ?? "", 40))}`
+						: `${uiTheme.fg("muted", "vibe send →")} ${uiTheme.fg("accent", frameText(args?.session ?? "?", 40))}`;
+				const ack =
+					op === "spawn"
+						? uiTheme.fg("success", `turn started${details.spawned ? ` (job ${details.spawned.jobId})` : ""}`)
+						: details.send?.mode === "steered"
+							? uiTheme.fg("success", "steered into the running turn")
+							: details.send?.mode === "queued"
+								? uiTheme.fg("warning", "mid-turn — queued as the next turn")
+								: uiTheme.fg(
+										"success",
+										`turn started${details.send?.jobId ? ` (job ${details.send.jobId})` : ""}`,
+									);
+				const lines = miniFrame(
+					uiTheme,
+					target,
+					composerRows(uiTheme, message, { cursor: false, expanded: options.expanded }),
+					ack,
+				);
+				return linesComponent(lines);
+			}
+
+			if (op === "kill") {
+				const killedNote = details.killed?.cancelledTurn ? " (in-flight turn cancelled)" : "";
+				const header = renderStatusLine(
+					{
+						icon: "done",
+						title: `vibe kill ${frameText(details.killed?.id ?? args?.session ?? "?", 40)}${killedNote}`,
+					},
+					uiTheme,
+				);
+				return new Text(header, 0, 0);
+			}
+
+			// wait/list: the TV wall.
+			const screens = details.screens;
+			if (screens.length === 0) {
+				const fallback = result.content.find(part => part.type === "text")?.text ?? "no sessions";
+				return new Text(
+					renderStatusLine(
+						{ icon: "warning", title: `vibe ${op}`, meta: [uiTheme.fg("dim", frameText(fallback, 60))] },
+						uiTheme,
+					),
+					0,
+					0,
+				);
+			}
+			const waiting = details.wait?.waiting === true;
+			const settledById = new Map(details.wait?.settled.map(entry => [entry.id, entry.status] as const) ?? []);
+			return linesComponent(() => {
+				const running = screens.filter(screen => screen.state === "running" || screen.state === "starting").length;
+				const meta: string[] = [];
+				if (running > 0) meta.push(uiTheme.fg("accent", `${running} on air`));
+				if (settledById.size > 0) meta.push(uiTheme.fg("success", `${settledById.size} settled`));
+				if (details.wait?.timedOut) meta.push(uiTheme.fg("warning", "timed out"));
+				const title =
+					op === "wait"
+						? waiting
+							? "vibe wait — watching the wall"
+							: "vibe wait"
+						: `vibe sessions (${screens.length})`;
+				const header = renderStatusLine(
+					{
+						icon: details.wait?.timedOut ? "warning" : running > 0 ? "info" : "done",
+						spinnerFrame: running > 0 ? options.spinnerFrame : undefined,
+						title,
+						meta,
+					},
+					uiTheme,
+				);
+				const lines = [header];
+				for (const screen of screens) {
+					lines.push(...tvScreen(uiTheme, screen, options, settledById.get(screen.id)));
+				}
+				return lines;
+			});
+		},
+	} satisfies ToolRenderer<VibeRenderArgs, VibeToolDetails>;
+}