substrate-ai 0.2.21 → 0.2.23

package/dist/event-bus-CAvDMst7.js

@@ -0,0 +1,734 @@
+import * as readline from "node:readline";
+import { EventEmitter } from "node:events";
+
+//#region src/tui/ansi.ts
+/**
+* ANSI escape code helpers for TUI rendering.
+*
+* Provides cursor control, color, and screen manipulation utilities.
+*/
+const ANSI = {
+	RESET: "\x1B[0m",
+	BOLD: "\x1B[1m",
+	DIM: "\x1B[2m",
+	BLACK: "\x1B[30m",
+	RED: "\x1B[31m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m",
+	BLUE: "\x1B[34m",
+	MAGENTA: "\x1B[35m",
+	CYAN: "\x1B[36m",
+	WHITE: "\x1B[37m",
+	BRIGHT_BLACK: "\x1B[90m",
+	BRIGHT_RED: "\x1B[91m",
+	BRIGHT_GREEN: "\x1B[92m",
+	BRIGHT_YELLOW: "\x1B[93m",
+	BRIGHT_BLUE: "\x1B[94m",
+	BRIGHT_MAGENTA: "\x1B[95m",
+	BRIGHT_CYAN: "\x1B[96m",
+	BRIGHT_WHITE: "\x1B[97m",
+	BG_BLACK: "\x1B[40m",
+	BG_WHITE: "\x1B[47m",
+	BG_BLUE: "\x1B[44m",
+	BG_BRIGHT_BLACK: "\x1B[100m",
+	HIDE_CURSOR: "\x1B[?25l",
+	SHOW_CURSOR: "\x1B[?25h",
+	CLEAR_SCREEN: "\x1B[2J",
+	HOME: "\x1B[H",
+	CLEAR_LINE: "\x1B[2K",
+	ERASE_DOWN: "\x1B[J",
+	ALT_SCREEN_ENTER: "\x1B[?1049h",
+	ALT_SCREEN_EXIT: "\x1B[?1049l"
+};
+/** Check if color output is supported. */
+function supportsColor(isTTY) {
+	if (process.env.NO_COLOR !== void 0) return false;
+	return isTTY;
+}
+/** Wrap text with an ANSI color code (only if color is enabled). */
+function colorize(text, code, useColor) {
+	if (!useColor) return text;
+	return `${code}${text}${ANSI.RESET}`;
+}
+/** Bold text. */
+function bold(text, useColor) {
+	if (!useColor) return text;
+	return `${ANSI.BOLD}${text}${ANSI.RESET}`;
+}
+/**
+* Get current terminal dimensions.
+* Returns { cols, rows } with fallback defaults if unavailable.
+*/
+function getTerminalSize() {
+	const cols = process.stdout.columns ?? 80;
+	const rows = process.stdout.rows ?? 24;
+	return {
+		cols,
+		rows
+	};
+}
+/**
+* Truncate a string to fit within maxWidth characters.
+* Adds ellipsis if truncated.
+*/
+function truncate(text, maxWidth) {
+	if (maxWidth <= 0) return "";
+	if (text.length <= maxWidth) return text;
+	if (maxWidth <= 3) return text.slice(0, maxWidth);
+	return text.slice(0, maxWidth - 3) + "...";
+}
+/**
+* Pad or truncate a string to exactly `width` characters.
+*/
+function padOrTruncate(text, width, padChar = " ") {
+	if (text.length > width) return truncate(text, width);
+	return text.padEnd(width, padChar);
+}
+
+//#endregion
+//#region src/tui/story-panel.ts
+const COL_KEY_WIDTH = 12;
+const COL_PHASE_WIDTH = 8;
+const COL_STATUS_WIDTH = 30;
+/**
+* Get ANSI color code for a story status.
+*/
+function statusColor(status) {
+	switch (status) {
+		case "pending": return ANSI.BRIGHT_BLACK;
+		case "in_progress": return ANSI.YELLOW;
+		case "succeeded": return ANSI.GREEN;
+		case "failed":
+		case "escalated": return ANSI.RED;
+		default: return ANSI.RESET;
+	}
+}
+/**
+* Get status indicator symbol for a story status.
+*/
+function statusSymbol(status) {
+	switch (status) {
+		case "pending": return "○";
+		case "in_progress": return "◉";
+		case "succeeded": return "✓";
+		case "failed":
+		case "escalated": return "✗";
+		default: return "·";
+	}
+}
+/**
+* Render the story panel header row.
+*/
+function renderStoryPanelHeader(useColor) {
+	const key = padOrTruncate("STORY", COL_KEY_WIDTH);
+	const phase = padOrTruncate("PHASE", COL_PHASE_WIDTH);
+	const status = "STATUS";
+	const header = `  ${key}  ${phase}  ${status}`;
+	return bold(colorize(header, ANSI.BRIGHT_WHITE, useColor), useColor);
+}
+/**
+* Render a single story row.
+*/
+function renderStoryRow(story, isSelected, useColor, width) {
+	const symbol = statusSymbol(story.status);
+	const color = statusColor(story.status);
+	const keyCol = padOrTruncate(story.key, COL_KEY_WIDTH);
+	const phaseCol = padOrTruncate(story.phase, COL_PHASE_WIDTH);
+	const statusCol = padOrTruncate(story.statusLabel, COL_STATUS_WIDTH);
+	const maxWidth = Math.max(width - 2, 10);
+	let row = `${symbol} ${keyCol}  ${phaseCol}  ${statusCol}`;
+	row = row.slice(0, maxWidth);
+	if (useColor) row = `${color}${row}${ANSI.RESET}`;
+	if (isSelected && useColor) row = `${ANSI.BG_BRIGHT_BLACK}${row}${ANSI.RESET}`;
+	else if (isSelected) row = `> ${row.slice(2)}`;
+	return row;
+}
+/**
+* Render the complete story panel.
+*
+* Returns an array of lines to be written to the terminal.
+*/
+function renderStoryPanel(options) {
+	const { stories, selectedIndex, useColor, width } = options;
+	const lines = [];
+	lines.push(bold(colorize("  Story Status", ANSI.CYAN, useColor), useColor));
+	lines.push(renderStoryPanelHeader(useColor));
+	lines.push("  " + "─".repeat(Math.max(width - 4, 20)));
+	if (stories.length === 0) lines.push(colorize("  (no stories)", ANSI.BRIGHT_BLACK, useColor));
+	else for (let i = 0; i < stories.length; i++) {
+		const story = stories[i];
+		if (story !== void 0) lines.push(renderStoryRow(story, i === selectedIndex, useColor, width));
+	}
+	return lines;
+}
+
+//#endregion
+//#region src/tui/log-panel.ts
+/**
+* Format a log entry timestamp to a short HH:MM:SS format.
+*/
+function formatTimestamp(ts) {
+	try {
+		const date = new Date(ts);
+		const hh = date.getHours().toString().padStart(2, "0");
+		const mm = date.getMinutes().toString().padStart(2, "0");
+		const ss = date.getSeconds().toString().padStart(2, "0");
+		return `${hh}:${mm}:${ss}`;
+	} catch {
+		return ts.slice(11, 19);
+	}
+}
+/**
+* Render a single log entry line.
+*/
+function renderLogEntry(entry, useColor, width) {
+	const ts = formatTimestamp(entry.ts);
+	const prefix = `[${ts}] [${entry.key}] `;
+	const maxMsgWidth = Math.max(width - prefix.length - 2, 10);
+	const msg = truncate(entry.msg, maxMsgWidth);
+	const line = `${prefix}${msg}`;
+	if (useColor) {
+		if (entry.level === "warn") return colorize(line, ANSI.YELLOW, useColor);
+		const coloredPrefix = colorize(`[${ts}] `, ANSI.BRIGHT_BLACK, useColor) + colorize(`[${entry.key}] `, ANSI.CYAN, useColor);
+		return `${coloredPrefix}${msg}`;
+	}
+	return line;
+}
+/**
+* Render the complete log panel.
+*
+* Auto-scrolls to show the most recent entries (last `maxLines` entries).
+* Returns an array of lines to be written to the terminal.
+*/
+function renderLogPanel(options) {
+	const { entries, maxLines, useColor, width, filterKey } = options;
+	const lines = [];
+	const title = filterKey !== void 0 ? `  Logs for ${filterKey}` : "  Live Logs";
+	lines.push(bold(colorize(title, ANSI.CYAN, useColor), useColor));
+	lines.push("  " + "─".repeat(Math.max(width - 4, 20)));
+	const filtered = filterKey !== void 0 ? entries.filter((e) => e.key === filterKey) : entries;
+	if (filtered.length === 0) {
+		lines.push(colorize("  (no log entries)", ANSI.BRIGHT_BLACK, useColor));
+		return lines;
+	}
+	const visibleEntries = filtered.slice(-maxLines);
+	for (const entry of visibleEntries) lines.push("  " + renderLogEntry(entry, useColor, width - 2));
+	return lines;
+}
+
+//#endregion
+//#region src/tui/detail-view.ts
+/**
+* Render the full detail view for a story.
+*
+* Returns an array of lines to be written to the terminal.
+*/
+function renderDetailView(options) {
+	const { story, allLogs, maxLogLines, useColor, width, height } = options;
+	const lines = [];
+	const titleBar = `  Story Detail: ${story.key}`;
+	lines.push(bold(colorize(titleBar, ANSI.BRIGHT_WHITE, useColor), useColor));
+	lines.push("  " + "═".repeat(Math.max(width - 4, 20)));
+	lines.push("");
+	const phaseLabel = padOrTruncate("Phase:", 12);
+	const statusLabel = padOrTruncate("Status:", 12);
+	const cyclesLabel = padOrTruncate("Review Cycles:", 12);
+	lines.push(`  ${bold(phaseLabel, useColor)} ${colorize(story.phase, ANSI.CYAN, useColor)}`);
+	lines.push(`  ${bold(statusLabel, useColor)} ${colorize(story.statusLabel, ANSI.WHITE, useColor)}`);
+	lines.push(`  ${bold(cyclesLabel, useColor)} ${story.reviewCycles}`);
+	if (story.escalationReason !== void 0) lines.push(`  ${bold(padOrTruncate("Escalated:", 12), useColor)} ${colorize(story.escalationReason, ANSI.RED, useColor)}`);
+	lines.push("");
+	lines.push("  " + "─".repeat(Math.max(width - 4, 20)));
+	const availableLogLines = Math.max(height - lines.length - 4, 3);
+	const logLines = renderLogPanel({
+		entries: allLogs,
+		maxLines: Math.min(maxLogLines, availableLogLines),
+		useColor,
+		width,
+		filterKey: story.key
+	});
+	lines.push(...logLines);
+	lines.push("");
+	lines.push(colorize("  [Esc] Back to overview", ANSI.BRIGHT_BLACK, useColor));
+	return lines;
+}
+
+//#endregion
+//#region src/tui/help-overlay.ts
+/** All keyboard bindings shown in the help overlay. */
+const KEY_BINDINGS = [
+	{
+		key: "↑ / ↓",
+		description: "Navigate between stories"
+	},
+	{
+		key: "Enter",
+		description: "Drill into selected story detail view"
+	},
+	{
+		key: "Esc",
+		description: "Return to overview from detail view"
+	},
+	{
+		key: "q",
+		description: "Quit TUI (pipeline completes in background)"
+	},
+	{
+		key: "?",
+		description: "Show/hide this help overlay"
+	}
+];
+/**
+* Render the help overlay.
+*
+* Returns an array of lines to be written to the terminal.
+*/
+function renderHelpOverlay(options) {
+	const { useColor, width } = options;
+	const lines = [];
+	const boxWidth = Math.min(56, Math.max(width - 4, 30));
+	const horizontalBorder = "─".repeat(boxWidth - 2);
+	lines.push(colorize(`  ┌${horizontalBorder}┐`, ANSI.CYAN, useColor));
+	lines.push(colorize(`  │${padOrTruncate(" Keyboard Shortcuts", boxWidth - 2)}│`, ANSI.CYAN, useColor));
+	lines.push(colorize(`  ├${horizontalBorder}┤`, ANSI.CYAN, useColor));
+	for (const binding of KEY_BINDINGS) {
+		const keyPart = bold(padOrTruncate(binding.key, 12), useColor);
+		const descPart = padOrTruncate(binding.description, boxWidth - 16);
+		lines.push(useColor ? `${ANSI.CYAN}  │${ANSI.RESET}  ${keyPart}  ${descPart}${ANSI.CYAN}│${ANSI.RESET}` : `  │  ${keyPart}  ${descPart}│`);
+	}
+	lines.push(colorize(`  └${horizontalBorder}┘`, ANSI.CYAN, useColor));
+	lines.push(colorize("  Press ? to close", ANSI.BRIGHT_BLACK, useColor));
+	return lines;
+}
+
+//#endregion
+//#region src/tui/app.ts
+/** Minimum terminal width for TUI to render properly. */
+const MIN_COLS = 80;
+/** Minimum terminal height for TUI to render properly. */
+const MIN_ROWS = 24;
+/** Maximum log entries to keep in memory. */
+const MAX_LOG_ENTRIES = 500;
+function mapPhaseToLabel(phase) {
+	switch (phase) {
+		case "create-story": return "create";
+		case "dev-story": return "dev";
+		case "code-review": return "review";
+		case "fix": return "fix";
+		default: return "wait";
+	}
+}
+function mapPhaseToStatus(phase, eventStatus) {
+	if (eventStatus === "failed") return "failed";
+	if (eventStatus === "in_progress") return "in_progress";
+	if (eventStatus === "complete") {
+		if (phase === "done") return "succeeded";
+		return "in_progress";
+	}
+	return "pending";
+}
+function makeStatusLabel(phase, eventStatus, verdict) {
+	if (eventStatus === "failed") return "failed";
+	if (eventStatus === "in_progress") switch (phase) {
+		case "create": return "creating story...";
+		case "dev": return "implementing...";
+		case "review": return "reviewing...";
+		case "fix": return "fixing issues...";
+		default: return "in progress...";
+	}
+	if (eventStatus === "complete") switch (phase) {
+		case "create": return "story created";
+		case "dev": return "implemented";
+		case "review": return verdict !== void 0 ? `reviewed (${verdict})` : "reviewed";
+		case "fix": return "fixes applied";
+		default: return "complete";
+	}
+	return "queued";
+}
+/**
+* Factory that creates a TUI application instance.
+*
+* @param output - Writable stream for rendering (typically process.stdout)
+* @param input  - Readable stream for keyboard input (typically process.stdin)
+*/
+function createTuiApp(output, input) {
+	const isTTY = output.isTTY === true;
+	const useColor = supportsColor(isTTY);
+	const state = {
+		headerLine: "",
+		storyOrder: [],
+		stories: new Map(),
+		logs: [],
+		selectedIndex: 0,
+		view: "overview",
+		pipelineComplete: false
+	};
+	let exitResolve;
+	const exitPromise = new Promise((resolve) => {
+		exitResolve = resolve;
+	});
+	let rl;
+	function write(text) {
+		try {
+			output.write(text);
+		} catch {}
+	}
+	function checkTerminalSize() {
+		const { cols, rows } = getTerminalSize();
+		if (cols < MIN_COLS || rows < MIN_ROWS) {
+			write(ANSI.CLEAR_SCREEN + ANSI.HOME);
+			write(colorize(`Terminal too small: ${cols}x${rows} (minimum ${MIN_COLS}x${MIN_ROWS})\n`, ANSI.YELLOW, useColor));
+			write("Please resize your terminal.\n");
+			return false;
+		}
+		return true;
+	}
+	function render() {
+		const { cols, rows } = getTerminalSize();
+		if (cols < MIN_COLS || rows < MIN_ROWS) {
+			checkTerminalSize();
+			return;
+		}
+		write(ANSI.CLEAR_SCREEN + ANSI.HOME);
+		const lines = [];
+		if (state.view === "help") renderHelpView(lines, cols, rows);
+		else if (state.view === "detail") renderDetailViewLayout(lines, cols, rows);
+		else renderOverviewLayout(lines, cols, rows);
+		for (const line of lines) write(line + "\n");
+	}
+	function renderOverviewLayout(lines, cols, rows) {
+		lines.push(bold(colorize("  substrate run --tui", ANSI.BRIGHT_WHITE, useColor), useColor));
+		if (state.headerLine) lines.push(colorize(`  ${state.headerLine}`, ANSI.BRIGHT_BLACK, useColor));
+		lines.push("");
+		const storyPanelHeight = Math.max(Math.floor(rows * .4), 6);
+		const storyPanelLines = renderStoryPanel({
+			stories: Array.from(state.storyOrder).map((k) => state.stories.get(k)).filter((s) => s !== void 0),
+			selectedIndex: state.selectedIndex,
+			useColor,
+			width: cols
+		});
+		lines.push(...storyPanelLines.slice(0, storyPanelHeight));
+		lines.push("");
+		lines.push("  " + "─".repeat(Math.max(cols - 4, 20)));
+		lines.push("");
+		const usedLines = lines.length + 3;
+		const logPanelHeight = Math.max(rows - usedLines, 3);
+		const logLines = renderLogPanel({
+			entries: state.logs,
+			maxLines: logPanelHeight,
+			useColor,
+			width: cols
+		});
+		lines.push(...logLines);
+		lines.push("");
+		const footerParts = [
+			colorize("[↑↓] Navigate", ANSI.BRIGHT_BLACK, useColor),
+			colorize("[Enter] Details", ANSI.BRIGHT_BLACK, useColor),
+			colorize("[q] Quit", ANSI.BRIGHT_BLACK, useColor),
+			colorize("[?] Help", ANSI.BRIGHT_BLACK, useColor)
+		];
+		if (state.pipelineComplete) lines.push(colorize("  Pipeline complete. Press q to exit.", ANSI.GREEN, useColor));
+		lines.push("  " + footerParts.join("  "));
+	}
+	function renderDetailViewLayout(lines, cols, rows) {
+		const selectedKey = state.storyOrder[state.selectedIndex];
+		const story = selectedKey !== void 0 ? state.stories.get(selectedKey) : void 0;
+		if (story === void 0) {
+			lines.push("  No story selected. Press Esc to go back.");
+			return;
+		}
+		const detailLines = renderDetailView({
+			story,
+			allLogs: state.logs,
+			maxLogLines: Math.max(rows - 10, 5),
+			useColor,
+			width: cols,
+			height: rows
+		});
+		lines.push(...detailLines);
+	}
+	function renderHelpView(lines, cols, _rows) {
+		lines.push(bold(colorize("  substrate run --tui", ANSI.BRIGHT_WHITE, useColor), useColor));
+		lines.push("");
+		const helpLines = renderHelpOverlay({
+			useColor,
+			width: cols
+		});
+		lines.push(...helpLines);
+	}
+	function setupKeyboard() {
+		if (input.isTTY === true) try {
+			input.setRawMode(true);
+		} catch {}
+		rl = readline.createInterface({
+			input,
+			terminal: false
+		});
+		readline.emitKeypressEvents(input);
+		const stdin = input;
+		const onKeypress = (chunk, key) => {
+			if (key === void 0) return;
+			handleKeypress(key);
+		};
+		stdin.on("keypress", onKeypress);
+		rl.on("close", () => {
+			exit();
+		});
+	}
+	function handleKeypress(key) {
+		if (key.ctrl === true && key.name === "c") {
+			exit();
+			return;
+		}
+		switch (key.name) {
+			case "q":
+				exit();
+				return;
+			case "up":
+				if (state.view === "overview") {
+					state.selectedIndex = Math.max(0, state.selectedIndex - 1);
+					render();
+				}
+				break;
+			case "down":
+				if (state.view === "overview") {
+					state.selectedIndex = Math.min(Math.max(0, state.storyOrder.length - 1), state.selectedIndex + 1);
+					render();
+				}
+				break;
+			case "return":
+			case "enter":
+				if (state.view === "overview" && state.storyOrder.length > 0) {
+					state.view = "detail";
+					render();
+				}
+				break;
+			case "escape":
+				if (state.view === "detail" || state.view === "help") {
+					state.view = "overview";
+					render();
+				}
+				break;
+			case "?":
+				state.view = state.view === "help" ? "overview" : "help";
+				render();
+				break;
+			default:
+				if (key.sequence === "?") {
+					state.view = state.view === "help" ? "overview" : "help";
+					render();
+				}
+				break;
+		}
+	}
+	function onResize() {
+		render();
+	}
+	function init() {
+		write(ANSI.ALT_SCREEN_ENTER);
+		write(ANSI.HIDE_CURSOR);
+		setupKeyboard();
+		const resizeEmitter = typeof output.on === "function" ? output : process.stdout;
+		resizeEmitter.on("resize", onResize);
+		render();
+	}
+	function exit() {
+		cleanup();
+		if (exitResolve !== void 0) {
+			exitResolve();
+			exitResolve = void 0;
+		}
+	}
+	function cleanup() {
+		write(ANSI.SHOW_CURSOR);
+		write(ANSI.ALT_SCREEN_EXIT);
+		const resizeEmitter = typeof output.on === "function" ? output : process.stdout;
+		resizeEmitter.off("resize", onResize);
+		if (rl !== void 0) {
+			try {
+				rl.close();
+			} catch {}
+			rl = void 0;
+		}
+		if (input.isTTY === true) try {
+			input.setRawMode(false);
+		} catch {}
+	}
+	function handleEvent(event) {
+		switch (event.type) {
+			case "pipeline:start":
+				state.headerLine = `${event.stories.length} stories, concurrency ${event.concurrency}, run ${event.run_id.slice(0, 8)}...`;
+				for (const key of event.stories) {
+					state.storyOrder.push(key);
+					state.stories.set(key, {
+						key,
+						phase: "wait",
+						status: "pending",
+						statusLabel: "queued",
+						reviewCycles: 0
+					});
+				}
+				break;
+			case "story:phase": {
+				let story = state.stories.get(event.key);
+				if (story === void 0) {
+					state.storyOrder.push(event.key);
+					story = {
+						key: event.key,
+						phase: "wait",
+						status: "pending",
+						statusLabel: "queued",
+						reviewCycles: 0
+					};
+					state.stories.set(event.key, story);
+				}
+				const phaseLabel = mapPhaseToLabel(event.phase);
+				story.phase = phaseLabel;
+				story.status = mapPhaseToStatus(phaseLabel, event.status);
+				story.statusLabel = makeStatusLabel(phaseLabel, event.status, event.verdict);
+				break;
+			}
+			case "story:done": {
+				let story = state.stories.get(event.key);
+				if (story === void 0) {
+					state.storyOrder.push(event.key);
+					story = {
+						key: event.key,
+						phase: "done",
+						status: event.result === "success" ? "succeeded" : "failed",
+						statusLabel: event.result === "success" ? "SHIP_IT" : "FAILED",
+						reviewCycles: event.review_cycles
+					};
+					state.stories.set(event.key, story);
+				} else {
+					story.phase = event.result === "success" ? "done" : "failed";
+					story.status = event.result === "success" ? "succeeded" : "failed";
+					const cycleWord = event.review_cycles === 1 ? "cycle" : "cycles";
+					story.statusLabel = event.result === "success" ? `SHIP_IT (${event.review_cycles} ${cycleWord})` : "FAILED";
+					story.reviewCycles = event.review_cycles;
+				}
+				break;
+			}
+			case "story:escalation": {
+				let story = state.stories.get(event.key);
+				if (story === void 0) {
+					state.storyOrder.push(event.key);
+					story = {
+						key: event.key,
+						phase: "escalated",
+						status: "escalated",
+						statusLabel: `ESCALATED — ${event.reason}`,
+						reviewCycles: event.cycles,
+						escalationReason: event.reason
+					};
+					state.stories.set(event.key, story);
+				} else {
+					story.phase = "escalated";
+					story.status = "escalated";
+					story.statusLabel = `ESCALATED — ${event.reason}`;
+					story.reviewCycles = event.cycles;
+					story.escalationReason = event.reason;
+				}
+				break;
+			}
+			case "story:warn": {
+				const logEntry = {
+					ts: event.ts,
+					key: event.key,
+					msg: `[WARN] ${event.msg}`,
+					level: "warn"
+				};
+				state.logs.push(logEntry);
+				if (state.logs.length > MAX_LOG_ENTRIES) state.logs.splice(0, state.logs.length - MAX_LOG_ENTRIES);
+				break;
+			}
+			case "story:log": {
+				const logEntry = {
+					ts: event.ts,
+					key: event.key,
+					msg: event.msg,
+					level: "log"
+				};
+				state.logs.push(logEntry);
+				if (state.logs.length > MAX_LOG_ENTRIES) state.logs.splice(0, state.logs.length - MAX_LOG_ENTRIES);
+				break;
+			}
+			case "pipeline:complete":
+				state.pipelineComplete = true;
+				state.completionStats = {
+					succeeded: event.succeeded,
+					failed: event.failed,
+					escalated: event.escalated
+				};
+				setTimeout(() => {
+					if (exitResolve !== void 0) render();
+				}, 500);
+				break;
+			default: break;
+		}
+		render();
+	}
+	init();
+	return {
+		handleEvent,
+		cleanup,
+		waitForExit: () => exitPromise
+	};
+}
+/**
+* Check whether the TUI can run in the current environment.
+*
+* Returns true if stdout is a TTY, false otherwise.
+* If false, the caller should print a warning and use default output.
+*/
+function isTuiCapable() {
+	return process.stdout.isTTY === true;
+}
+/**
+* Print the non-TTY fallback warning message.
+*/
+function printNonTtyWarning() {
+	process.stderr.write("TUI requires an interactive terminal. Falling back to default output.\n");
+}
+
+//#endregion
+//#region src/core/event-bus.ts
+/**
+* Concrete implementation of TypedEventBus backed by Node.js EventEmitter.
+*
+* @example
+* const bus = new TypedEventBusImpl()
+* bus.on('task:complete', ({ taskId, result }) => {
+*   console.log(`Task ${taskId} finished`)
+* })
+* bus.emit('task:complete', { taskId: 'abc', result: { exitCode: 0 } })
+*/
+var TypedEventBusImpl = class {
+	_emitter;
+	constructor() {
+		this._emitter = new EventEmitter();
+		this._emitter.setMaxListeners(100);
+	}
+	emit(event, payload) {
+		this._emitter.emit(event, payload);
+	}
+	on(event, handler) {
+		this._emitter.on(event, handler);
+	}
+	off(event, handler) {
+		this._emitter.off(event, handler);
+	}
+};
+/**
+* Create a new TypedEventBus instance.
+*
+* @example
+* const bus = createEventBus()
+*/
+function createEventBus() {
+	return new TypedEventBusImpl();
+}
+
+//#endregion
+export { createEventBus, createTuiApp, isTuiCapable, printNonTtyWarning };
+//# sourceMappingURL=event-bus-CAvDMst7.js.map