illusion-code 0.1.0__py3-none-any.whl

illusion/_frontend/src/components/WelcomeBanner.tsx

@@ -0,0 +1,37 @@
+import React from 'react';
+import {Box, Text} from 'ink';
+
+import {useTheme} from '../theme/ThemeContext.js';
+
+// prettier-ignore
+const LOGO = [
+	'████╗██╗  ██╗  ██╗ ██╗██████╗████╗  ████╗  ███╗  ██╗',
+	'╚██╔╝██║  ██║  ██║ ██║██╔═══╝╚██╔╝██║   ██║████╗ ██║',
+	' ██║ ██║  ██║  ██║ ██║██████╗ ██║ ██║   ██║██║██╗██║',
+	' ██║ ██║  ██║  ██║ ██║╚═══██║ ██║ ██║   ██║██║╚████║',
+	'████╗████╗████╗ ████╔╝██████║████╗  ████╔╝ ██║ ╚═██║',
+	'╚═══╝╚═══╝╚═══╝ ╚═══╝ ╚═════╝╚═══╝  ╚═══╝  ╚═╝   ╚═╝',
+];
+
+export function WelcomeBanner({language}: {language?: string}): React.JSX.Element {
+	const theme = useTheme();
+
+	return (
+		<Box flexDirection="column" marginBottom={1}>
+			<Box flexDirection="column">
+				{LOGO.map((line, i) => (
+					<Text key={i} color={theme.colors.primary} bold>{line}</Text>
+				))}
+			</Box>
+			<Box marginTop={1}>
+				<Text color={theme.colors.illusion} bold>{'  Illusion Code · AI Coding Assistant'}</Text>
+			</Box>
+			<Box marginTop={1} flexDirection="column">
+				<Text dimColor>{`  ${theme.icons.pointer} `}<Text color={theme.colors.suggestion}>/help</Text>{' view all commands'}</Text>
+				<Text dimColor>{`  ${theme.icons.pointer} `}<Text color={theme.colors.suggestion}>/model</Text>{' switch model'}</Text>
+				<Text dimColor>{`  ${theme.icons.pointer} `}<Text color={theme.colors.suggestion}>/resume</Text>{' resume session'}</Text>
+				<Text dimColor>{`  ${theme.icons.pointer} `}<Text color={theme.colors.suggestion}>/language</Text>{' switch language'}</Text>
+			</Box>
+		</Box>
+	);
+}

illusion/_frontend/src/hooks/useBackendSession.ts

@@ -0,0 +1,468 @@
+import {useCallback, useEffect, useMemo, useRef, useState} from 'react';
+import {spawn, type ChildProcess} from 'node:child_process';
+import readline from 'node:readline';
+
+import type {
+	BackendEvent,
+	BridgeSessionSnapshot,
+	FrontendConfig,
+	McpServerSnapshot,
+	PendingToolCall,
+	SelectRequestPayload,
+	SwarmNotificationSnapshot,
+	SwarmTeammateSnapshot,
+	TaskSnapshot,
+	TodoItemSnapshot,
+	TranscriptItem,
+} from '../types.js';
+
+const PROTOCOL_PREFIX = 'OHJSON:';
+const ASSISTANT_DELTA_FLUSH_MS = 16;
+const ASSISTANT_DELTA_FLUSH_CHARS = 32;
+
+// Pattern for tool-call-like lines that the model may embed in assistant text.
+// Matches: "  bash (git add ...)" or "read (file_path: ...)"
+const TOOL_CALL_LINE_RE = /^\s{2,}\w[\w-]*\s*\(.*\)\s*$/;
+
+/** Strip lines that look like tool-call previews from assistant text. */
+function stripToolCallLines(text: string): string {
+	const lines = text.split('\n');
+	const filtered = lines.filter((line) => !TOOL_CALL_LINE_RE.test(line));
+	// If stripping removed everything, return original text as fallback
+	return filtered.length > 0 ? filtered.join('\n') : text;
+}
+
+export function useBackendSession(config: FrontendConfig, onExit: (code?: number | null) => void) {
+	const [staticItems, setStaticItems] = useState<TranscriptItem[]>([]);
+	const [clearCount, setClearCount] = useState(0);
+	const pushStatic = useCallback((item: TranscriptItem): void => {
+		setStaticItems((prev) => [...prev, item]);
+	}, []);
+	const [assistantBuffer, setAssistantBuffer] = useState('');
+	const [status, setStatus] = useState<Record<string, unknown>>({});
+	const [tasks, setTasks] = useState<TaskSnapshot[]>([]);
+	const [commands, setCommands] = useState<string[]>([]);
+	const [mcpServers, setMcpServers] = useState<McpServerSnapshot[]>([]);
+	const [bridgeSessions, setBridgeSessions] = useState<BridgeSessionSnapshot[]>([]);
+	const [modal, setModal] = useState<Record<string, unknown> | null>(null);
+	const [selectRequest, setSelectRequest] = useState<SelectRequestPayload | null>(null);
+	const [busy, setBusy] = useState(false);
+	const [ready, setReady] = useState(false);
+	const [showThinking, setShowThinking] = useState(true);
+	const [todoItems, setTodoItems] = useState<TodoItemSnapshot[]>([]);
+	const [pendingToolCalls, setPendingToolCalls] = useState<PendingToolCall[]>([]);
+	const [swarmTeammates, setSwarmTeammates] = useState<SwarmTeammateSnapshot[]>([]);
+	const [swarmNotifications, setSwarmNotifications] = useState<SwarmNotificationSnapshot[]>([]);
+	const [bgAgentLabel, setBgAgentLabel] = useState<string | null>(null);
+	const [commandResult, setCommandResult] = useState<{
+		text: string;
+		type: 'success' | 'error' | 'info';
+	} | null>(null);
+	const childRef = useRef<ChildProcess | null>(null);
+	const sentInitialPrompt = useRef(false);
+
+	// Streaming deltas can arrive one token at a time; updating Ink state for each
+	// delta causes heavy re-rendering/flicker. Buffer and flush at ~30fps.
+	const assistantBufferRef = useRef('');
+	const pendingAssistantDeltaRef = useRef('');
+	const assistantFlushTimerRef = useRef<NodeJS.Timeout | null>(null);
+	const reasoningBufferRef = useRef('');
+	// Raw buffer for thinking tag processing and final message text
+	const rawBufferRef = useRef('');
+	// Flag to prevent double-committing assistant text when tool_started
+	// flushes it before assistant_complete arrives
+	const assistantFlushedForToolRef = useRef(false);
+	// Ref for pendingToolCalls to avoid stale closure in handleEvent
+	const pendingToolCallsRef = useRef<PendingToolCall[]>([]);
+
+	const flushAssistantDelta = (): void => {
+		const pending = pendingAssistantDeltaRef.current;
+		if (!pending) {
+			return;
+		}
+		pendingAssistantDeltaRef.current = '';
+		rawBufferRef.current += pending;
+
+		// Process thinking tags for streaming display
+		let displayText = rawBufferRef.current;
+		if (!showThinking) {
+			displayText = displayText
+				.replace(/<think\b[^>]*>[\s\S]*?<\/think\b[^>]*>/gi, '')
+				.replace(/<\/think\b[^>]*>/gi, '')
+				.replace(/<think\b[^>]*>/gi, '')
+				.replace(/<th(?:i(?:n(?:k)?)?)?\s*$/i, '');
+		} else {
+			displayText = displayText
+				.replace(/<think\b[^>]*>/gi, '')
+				.replace(/<\/think\b[^>]*>/gi, '')
+				.replace(/<th(?:i(?:n(?:k)?)?)?\s*$/i, '');
+		}
+		if (showThinking && reasoningBufferRef.current.trim()) {
+			const reasoning = reasoningBufferRef.current.trim();
+			const text = displayText.trim();
+			displayText = text ? `${reasoning}\n\n${text}` : reasoning;
+		}
+		assistantBufferRef.current = displayText;
+		setAssistantBuffer(displayText);
+	};
+
+	const clearAssistantDelta = (): void => {
+		pendingAssistantDeltaRef.current = '';
+		assistantBufferRef.current = '';
+		rawBufferRef.current = '';
+		if (assistantFlushTimerRef.current) {
+			clearTimeout(assistantFlushTimerRef.current);
+			assistantFlushTimerRef.current = null;
+		}
+		setAssistantBuffer('');
+		reasoningBufferRef.current = '';
+	};
+
+	const sendRequest = (payload: Record<string, unknown>): void => {
+		const child = childRef.current;
+		if (!child || !child.stdin || child.stdin.destroyed) {
+			return;
+		}
+		child.stdin.write(JSON.stringify(payload) + '\n');
+	};
+
+	const clearStaticItems = (): void => {
+		setStaticItems([]);
+		setClearCount((c) => c + 1);
+		clearAssistantDelta();
+	};
+
+	useEffect(() => {
+		const [command, ...args] = config.backend_command;
+		const child = spawn(command, args, {
+			stdio: ['pipe', 'pipe', 'inherit'],
+			env: process.env,
+			detached: true,
+			windowsHide: true,
+		});
+		childRef.current = child;
+
+		const reader = readline.createInterface({input: child.stdout});
+		reader.on('line', (line) => {
+			if (!line.startsWith(PROTOCOL_PREFIX)) {
+				pushStatic({role: 'log', text: line});
+				return;
+			}
+			const event = JSON.parse(line.slice(PROTOCOL_PREFIX.length)) as BackendEvent;
+			handleEvent(event);
+		});
+
+		child.on('exit', (code) => {
+			pushStatic({role: 'system', text: `backend exited with code ${code ?? 0}`});
+			process.exitCode = code ?? 0;
+			onExit(code);
+		});
+
+		// Ensure child processes are killed on parent exit (prevents stale processes)
+		const killChild = (): void => {
+			if (!child.killed) {
+				// Kill process group to ensure Python backend and its children all die
+				try {
+					if (child.pid) {
+						process.kill(-child.pid, 'SIGTERM');
+					}
+				} catch {
+					child.kill('SIGTERM');
+				}
+			}
+			if (assistantFlushTimerRef.current) {
+				clearTimeout(assistantFlushTimerRef.current);
+				assistantFlushTimerRef.current = null;
+			}
+		};
+		process.on('exit', killChild);
+		process.on('SIGINT', killChild);
+		process.on('SIGTERM', killChild);
+
+		return () => {
+			reader.close();
+			killChild();
+			process.removeListener('exit', killChild);
+			process.removeListener('SIGINT', killChild);
+			process.removeListener('SIGTERM', killChild);
+		};
+	}, []);
+
+	const handleEvent = (event: BackendEvent): void => {
+		if (event.type === 'ready') {
+			setReady(true);
+			setStatus(event.state ?? {});
+			const showThinkingFromState = event.state?.show_thinking;
+			if (typeof showThinkingFromState === 'boolean') {
+				setShowThinking(showThinkingFromState);
+			}
+			setTasks(event.tasks ?? []);
+			setCommands(event.commands ?? []);
+			setMcpServers(event.mcp_servers ?? []);
+			setBridgeSessions(event.bridge_sessions ?? []);
+			if (config.initial_prompt && !sentInitialPrompt.current) {
+				sentInitialPrompt.current = true;
+				sendRequest({type: 'submit_line', line: config.initial_prompt});
+				setBusy(true);
+			}
+			return;
+		}
+		if (event.type === 'state_snapshot') {
+			setStatus(event.state ?? {});
+			const showThinkingFromState = event.state?.show_thinking;
+			if (typeof showThinkingFromState === 'boolean') {
+				setShowThinking(showThinkingFromState);
+			}
+			setMcpServers(event.mcp_servers ?? []);
+			setBridgeSessions(event.bridge_sessions ?? []);
+			return;
+		}
+		if (event.type === 'tasks_snapshot') {
+			setTasks(event.tasks ?? []);
+			return;
+		}
+		if (event.type === 'transcript_item' && event.item) {
+			pushStatic(event.item as TranscriptItem);
+			return;
+		}
+		if (event.type === 'assistant_delta') {
+			assistantFlushedForToolRef.current = false;
+			if (event.reasoning) {
+				reasoningBufferRef.current += event.reasoning;
+			}
+			const delta = event.message ?? '';
+			if (!delta) {
+				if (showThinking && reasoningBufferRef.current.trim()) {
+					const display = reasoningBufferRef.current.trim();
+					assistantBufferRef.current = display;
+					setAssistantBuffer(display);
+				}
+				return;
+			}
+			pendingAssistantDeltaRef.current += delta;
+			if (pendingAssistantDeltaRef.current.length >= ASSISTANT_DELTA_FLUSH_CHARS) {
+				flushAssistantDelta();
+				return;
+			}
+			if (!assistantFlushTimerRef.current) {
+				assistantFlushTimerRef.current = setTimeout(() => {
+					assistantFlushTimerRef.current = null;
+					flushAssistantDelta();
+				}, ASSISTANT_DELTA_FLUSH_MS);
+			}
+			return;
+		}
+		if (event.type === 'assistant_complete') {
+			if (assistantFlushTimerRef.current) {
+				clearTimeout(assistantFlushTimerRef.current);
+				assistantFlushTimerRef.current = null;
+			}
+			flushAssistantDelta();
+
+			// Skip if tool_started already committed this text to static
+			if (!assistantFlushedForToolRef.current) {
+				const text = event.message ?? rawBufferRef.current;
+				const reasoning = (event.reasoning ?? reasoningBufferRef.current) || undefined;
+				if (text.trim() || (reasoning ?? '').trim()) {
+					pushStatic({role: 'assistant', text: stripToolCallLines(text), reasoning});
+				}
+			}
+			assistantFlushedForToolRef.current = false;
+
+			clearAssistantDelta();
+			return;
+		}
+		if (event.type === 'line_complete') {
+			// If the line ended without an assistant_complete (e.g. errors), make sure we
+			// don't leave stale streaming text on screen.
+			clearAssistantDelta();
+			pendingToolCallsRef.current = [];
+			setPendingToolCalls([]);
+			setBgAgentLabel(null);
+			setBusy(false);
+			return;
+		}
+		if ((event.type === 'tool_started' || event.type === 'tool_completed') && event.item) {
+			if (event.type === 'tool_started') {
+				// Commit any pending assistant text to static before the tool call appears
+				if (rawBufferRef.current.trim() || pendingAssistantDeltaRef.current || reasoningBufferRef.current.trim()) {
+					if (assistantFlushTimerRef.current) {
+						clearTimeout(assistantFlushTimerRef.current);
+						assistantFlushTimerRef.current = null;
+					}
+					flushAssistantDelta();
+					const text = rawBufferRef.current;
+					const reasoning = reasoningBufferRef.current || undefined;
+					if (text.trim() || (reasoning ?? '').trim()) {
+						pushStatic({
+							role: 'assistant',
+							text: stripToolCallLines(text),
+							reasoning,
+						});
+					}
+					clearAssistantDelta();
+					assistantFlushedForToolRef.current = true;
+				}
+				setBusy(true);
+				// 工具调用全过程保持在 pendingToolCalls 状态（非 Static），
+				// 以便对 ● 做闪烁动画，直到 tool_completed 才推入 staticItems
+				const toolInput = event.item.tool_input ?? event.tool_input;
+				const toolUseId = event.item.tool_use_id ?? event.tool_use_id ?? '';
+				const pendingCall: PendingToolCall = {
+					tool_name: event.item.tool_name ?? event.tool_name ?? 'tool',
+					tool_use_id: toolUseId,
+					tool_input: (toolInput && Object.keys(toolInput).length > 0) ? toolInput : undefined,
+				};
+				pendingToolCallsRef.current = [...pendingToolCallsRef.current, pendingCall];
+				setPendingToolCalls(pendingToolCallsRef.current);
+				return;
+			}
+			// tool_completed: 将工具项和结果一并推入 staticItems
+			if (event.type === 'tool_completed') {
+				const toolUseId = event.item.tool_use_id ?? event.tool_use_id ?? '';
+				const pendingIdx = pendingToolCallsRef.current.findIndex(p => p.tool_use_id === toolUseId);
+				if (pendingIdx !== -1) {
+					const pending = pendingToolCallsRef.current[pendingIdx];
+					pendingToolCallsRef.current = pendingToolCallsRef.current.filter(p => p.tool_use_id !== toolUseId);
+					setPendingToolCalls(pendingToolCallsRef.current);
+					pushStatic({
+						role: 'tool',
+						text: pending.tool_name,
+						tool_name: pending.tool_name,
+						tool_input: pending.tool_input,
+						tool_use_id: pending.tool_use_id || undefined,
+					});
+				}
+				const enrichedItem: TranscriptItem = {
+					...event.item,
+					tool_name: event.item.tool_name ?? event.tool_name ?? undefined,
+					tool_input: event.item.tool_input ?? undefined,
+					tool_use_id: event.item.tool_use_id ?? event.tool_use_id ?? undefined,
+					is_error: event.item.is_error ?? event.is_error ?? undefined,
+				};
+				pushStatic(enrichedItem);
+			}
+			return;
+		}
+		if (event.type === 'tool_input_updated') {
+			// 后端发送了完整的工具参数，更新 pendingToolCalls 中对应项的 tool_input
+			const toolUseId = event.tool_use_id;
+			pendingToolCallsRef.current = pendingToolCallsRef.current.map(p =>
+				p.tool_use_id === toolUseId
+					? {...p, tool_input: event.tool_input ?? undefined}
+					: p,
+			);
+			setPendingToolCalls(pendingToolCallsRef.current);
+			return;
+		}
+		if (event.type === 'clear_transcript') {
+			setStaticItems([]);
+			setClearCount((c) => c + 1);
+			clearAssistantDelta();
+			pendingToolCallsRef.current = [];
+			setPendingToolCalls([]);
+			return;
+		}
+		if (event.type === 'replace_transcript' && event.items) {
+			const newItems = (event.items as TranscriptItem[]).filter((item: TranscriptItem) => {
+				if (item.role === 'user' && item.text.startsWith('/')) {
+					return false;
+				}
+				return true;
+			});
+			setStaticItems(newItems);
+			setClearCount((c) => c + 1);
+			clearAssistantDelta();
+			pendingToolCallsRef.current = [];
+			setPendingToolCalls([]);
+			return;
+		}
+		if (event.type === 'select_request') {
+			const m = event.modal ?? {};
+			setSelectRequest({
+				title: String(m.title ?? 'Select'),
+				command: String(m.command ?? ''),
+				options: event.select_options ?? [],
+			});
+			setBusy(false);
+			return;
+		}
+		if (event.type === 'modal_request') {
+			setModal(event.modal ?? null);
+			return;
+		}
+		if (event.type === 'error') {
+			pushStatic({role: 'system', text: `error: ${event.message ?? 'unknown error'}`});
+			clearAssistantDelta();
+			setBusy(false);
+			return;
+		}
+		if (event.type === 'todo_update') {
+			if (event.todo_items != null) {
+				setTodoItems(event.todo_items);
+			}
+			return;
+		}
+		if (event.type === 'swarm_status') {
+			if (event.swarm_teammates != null) {
+				setSwarmTeammates(event.swarm_teammates);
+			}
+			if (event.swarm_notifications != null) {
+				setSwarmNotifications((prev) => [...prev, ...event.swarm_notifications!].slice(-20));
+			}
+			return;
+		}
+		if (event.type === 'plan_mode_change') {
+			if (event.plan_mode != null) {
+				setStatus((s) => ({...s, permission_mode: event.plan_mode}));
+			}
+			return;
+		}
+		if (event.type === 'command_result' && event.command_result_data) {
+			setCommandResult({
+				text: event.command_result_data.message,
+				type: event.command_result_data.type || 'info',
+			});
+			return;
+		}
+		if (event.type === 'bg_agent_status') {
+			setBgAgentLabel(event.message ?? null);
+			return;
+		}
+		if (event.type === 'shutdown') {
+			onExit(0);
+		}
+	};
+
+	return useMemo(
+		() => ({
+			staticItems,
+			assistantBuffer,
+			clearCount,
+			showThinking,
+			status,
+			tasks,
+			commands,
+			mcpServers,
+			bridgeSessions,
+			modal,
+			selectRequest,
+			busy,
+			ready,
+			todoItems,
+			pendingToolCalls,
+			swarmTeammates,
+			swarmNotifications,
+			bgAgentLabel,
+			commandResult,
+			setCommandResult,
+			setModal,
+			setSelectRequest,
+			setBusy,
+			sendRequest,
+			clearStaticItems,
+			pushStatic,
+		}),
+		[assistantBuffer, bridgeSessions, busy, clearCount, commandResult, commands, mcpServers, modal, pendingToolCalls, ready, selectRequest, showThinking, staticItems, status, swarmNotifications, swarmTeammates, tasks, todoItems, bgAgentLabel]
+	);
+}

illusion/_frontend/src/hooks/useTerminalSize.ts

@@ -0,0 +1,9 @@
+import {useStdout} from 'ink';
+
+export function useTerminalSize(): {columns: number; rows: number} {
+	const {stdout} = useStdout();
+	return {
+		columns: stdout?.columns ?? 80,
+		rows: stdout?.rows ?? 24,
+	};
+}

illusion/_frontend/src/i18n.ts

@@ -0,0 +1,78 @@
+export type UiLanguage = 'zh-CN' | 'en';
+
+type Dict = Record<string, string>;
+
+const ZH: Dict = {
+	connecting: '正在连接后端...',
+	send: '发送',
+	commands: '命令',
+	exit: '退出',
+	exitProgram: '退出程序',
+	stopCurrentTask: '停止当前任务',
+	permissionMode: '权限模式',
+	language: '语言',
+	langZh: '简体中文',
+	langEn: 'English',
+	newline: '换行',
+	allow: '允许',
+	alwaysAllow: '总是允许',
+	deny: '拒绝',
+	welcomeSub: 'AI 编码助手',
+	statusReady: '就绪',
+	statusThinking: '思考中...',
+	statusExecuting: '执行指令中...',
+	statusToolPrefix: '执行工具',
+	spinnerVerbs: '酝酿,生发,铺陈,点染,贯通,渲染,独照,澄明',
+	spinnerToolAction: '正在执行',
+	longTextHint: '多段需求或长文本建议写入文档后命 illusion code 读取',
+	clearInput: '清空输入',
+	taskStopped: '当前任务已停止。',
+	reasoning: '思考过程',
+	assistantReply: '助手回复',
+	bgAgentWaiting: '等待后台代理完成',
+	bgAgentResuming: '后台代理已完成，继续执行',
+};
+
+const EN: Dict = {
+	connecting: 'Connecting to backend...',
+	send: 'send',
+	commands: 'commands',
+	exit: 'exit',
+	exitProgram: 'exit program',
+	stopCurrentTask: 'stop current task',
+	permissionMode: 'Permission Mode',
+	language: 'Language',
+	langZh: '简体中文',
+	langEn: 'English',
+	newline: 'newline',
+	allow: 'Allow',
+	alwaysAllow: 'Always Allow',
+	deny: 'Deny',
+	welcomeSub: 'An AI-powered coding assistant',
+	statusReady: 'Ready',
+	statusThinking: 'Thinking...',
+	statusExecuting: 'Executing command...',
+	statusToolPrefix: 'Running tool',
+	spinnerVerbs: 'Thinking,Processing,Analyzing,Reasoning,Generating,Deliberating,Crafting,Refining,Computing,Synthesizing',
+	spinnerToolAction: 'Running',
+	longTextHint: 'For complex or long text, write to doc and let illusion code read it',
+	clearInput: 'clear input',
+	taskStopped: 'Current task stopped.',
+	reasoning: 'Thinking',
+	assistantReply: 'Response',
+	bgAgentWaiting: 'Waiting for background agent',
+	bgAgentResuming: 'Background agent completed, resuming',
+};
+
+const ALL: Record<UiLanguage, Dict> = {
+	'zh-CN': ZH,
+	en: EN,
+};
+
+export function normalizeLanguage(raw: unknown): UiLanguage {
+	return raw === 'en' ? 'en' : 'zh-CN';
+}
+
+export function t(lang: UiLanguage, key: keyof typeof ZH): string {
+	return ALL[lang][key] ?? ZH[key];
+}

illusion/_frontend/src/index.tsx

@@ -0,0 +1,42 @@
+import React from 'react';
+import {render} from 'ink';
+
+import {App} from './App.js';
+import type {FrontendConfig} from './types.js';
+
+const config = JSON.parse(process.env.ILLUSION_FRONTEND_CONFIG ?? '{}') as FrontendConfig;
+
+// Restore terminal cursor visibility on exit (Ink hides it by default)
+const restoreCursor = (): void => {
+	process.stdout.write('\x1B[?25h');
+};
+process.on('exit', restoreCursor);
+// SIGINT 由 App 组件中的 useInput 处理，不再强制退出
+// 仅在无法恢复时作为安全网退出
+process.on('SIGTERM', () => {
+	restoreCursor();
+	process.exit(143);
+});
+
+// --- Suppress resize events ---
+// ink's eraseLines(N) + output pattern causes visible flicker on every resize.
+// But ink recalculates layout on EVERY React re-render (reading stdout.columns),
+// not just on resize events. So we can safely suppress resize events entirely.
+//
+// Layout still updates correctly when:
+// - User types (PromptInput state change → React re-render → layout recalc)
+// - Spinner ticks during busy state (32ms interval → React re-render)
+// - Backend sends events (status changes → React re-render)
+//
+// The only effect: terminal content doesn't reflow on resize until the next
+// React re-render. This is acceptable because idle content (StatusBar, hints)
+// is short and reflows on the next user interaction.
+const _origEmit = process.stdout.emit.bind(process.stdout);
+process.stdout.emit = function (event: string, ...args: unknown[]) {
+	if (event === 'resize') {
+		return false;
+	}
+	return _origEmit(event, ...args);
+} as typeof process.stdout.emit;
+
+render(<App config={config} />);

illusion/_frontend/src/theme/ThemeContext.tsx

@@ -0,0 +1,19 @@
+import React, {createContext, useContext} from 'react';
+
+import {type ThemeConfig, defaultTheme} from './builtinThemes.js';
+
+export type {ThemeConfig};
+
+const ThemeContext = createContext<ThemeConfig>(defaultTheme);
+
+export function ThemeProvider({children}: {children: React.ReactNode}): React.JSX.Element {
+	return (
+		<ThemeContext.Provider value={defaultTheme}>
+			{children}
+		</ThemeContext.Provider>
+	);
+}
+
+export function useTheme(): ThemeConfig {
+	return useContext(ThemeContext);
+}