miladyai 2.0.0-alpha.27

package/dist/tui/index.js

@@ -0,0 +1,370 @@
+import { loadMiladyConfig, saveMiladyConfig } from "../config/config.js";
+import { DEFAULT_MODELS_DIR, ensureModel } from "../runtime/embedding-manager-support.js";
+import { EMBEDDING_PRESETS } from "../runtime/embedding-presets.js";
+import { MiladyEmbeddingManager } from "../runtime/embedding-manager.js";
+import { getEmbeddingState } from "../runtime/embedding-state.js";
+import { ElizaTUIBridge } from "./eliza-tui-bridge.js";
+import { resolveTuiModelSpec } from "./model-spec.js";
+import { MiladyTUI } from "./tui-app.js";
+import process from "node:process";
+import path from "node:path";
+import { stringToUuid } from "@elizaos/core";
+import fs from "node:fs";
+import { createPiCredentialProvider, getPiModel, parseModelSpec, registerPiAiModelHandler } from "@elizaos/plugin-pi-ai";
+import { Text } from "@mariozechner/pi-tui";
+
+//#region src/tui/index.ts
+function formatDownloadSize(mb) {
+	return mb >= 1e3 ? `${(mb / 1e3).toFixed(1)}GB` : `${mb}MB`;
+}
+function isModelDownloaded(filename) {
+	return fs.existsSync(path.join(DEFAULT_MODELS_DIR, filename));
+}
+const VALID_TIERS = new Set([
+	"fallback",
+	"standard",
+	"performance"
+]);
+function getEmbeddingOptions() {
+	const state = getEmbeddingState();
+	if (!state) return [];
+	return [
+		"fallback",
+		"standard",
+		"performance"
+	].map((tier) => {
+		const preset = EMBEDDING_PRESETS[tier];
+		return {
+			tier,
+			label: preset.label,
+			dimensions: preset.dimensions,
+			downloaded: isModelDownloaded(preset.model),
+			active: state.preset?.tier === tier
+		};
+	});
+}
+async function switchEmbeddingTier(tier, tui) {
+	const state = getEmbeddingState();
+	if (!state) {
+		tui.addToChatContainer(new Text("Embedding manager not available.", 1, 0));
+		return;
+	}
+	const preset = EMBEDDING_PRESETS[tier];
+	if (state.preset?.tier === tier) {
+		tui.addToChatContainer(new Text(`Already using ${preset.label} (${preset.model})`, 1, 0));
+		return;
+	}
+	if (preset.dimensions !== state.dimensions) tui.addToChatContainer(new Text(`⚠ Dimensions changing (${state.dimensions} → ${preset.dimensions}). Existing memory embeddings will be re-indexed on next access.`, 1, 0));
+	if (!isModelDownloaded(preset.model)) {
+		tui.addToChatContainer(new Text(`Downloading ${preset.model} (${formatDownloadSize(preset.downloadSizeMB)})…`, 1, 0));
+		try {
+			await ensureModel(DEFAULT_MODELS_DIR, preset.modelRepo, preset.model);
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : String(err);
+			tui.addToChatContainer(new Text(`Download failed: ${msg}`, 1, 0));
+			return;
+		}
+	}
+	try {
+		await state.manager.dispose();
+	} catch {}
+	state.manager = new MiladyEmbeddingManager({
+		model: preset.model,
+		modelRepo: preset.modelRepo,
+		dimensions: preset.dimensions,
+		gpuLayers: preset.gpuLayers
+	});
+	state.preset = preset;
+	state.dimensions = preset.dimensions;
+	try {
+		const cfg = loadMiladyConfig();
+		cfg.embedding = {
+			...cfg.embedding,
+			model: preset.model,
+			modelRepo: preset.modelRepo,
+			dimensions: preset.dimensions,
+			gpuLayers: preset.gpuLayers
+		};
+		saveMiladyConfig(cfg);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		tui.addToChatContainer(new Text(`Warning: could not save config: ${msg}`, 1, 0));
+	}
+	tui.addToChatContainer(new Text(`Switched embedding model to ${preset.label} (${preset.model}, ${preset.dimensions} dims)`, 1, 0));
+}
+function createApiModeRuntimeStub(agentName) {
+	const noopAsync = async () => {};
+	return {
+		agentId: stringToUuid(`milady-tui-api:${agentName}`),
+		character: { name: agentName },
+		getSetting: () => void 0,
+		setSetting: () => {},
+		registerEvent: () => {},
+		ensureWorldExists: noopAsync,
+		ensureRoomExists: noopAsync,
+		ensureConnection: noopAsync,
+		stop: noopAsync
+	};
+}
+async function launchTUI(runtime, options = {}) {
+	const apiMode = Boolean(options.apiBaseUrl);
+	const piCreds = await createPiCredentialProvider();
+	const miladyConfig = loadMiladyConfig();
+	const fallbackAgentName = miladyConfig.agents?.list?.[0]?.name ?? "milady";
+	if (!runtime && !apiMode) throw new Error("Runtime is required when API mode is not configured");
+	const runtimeRef = runtime ?? createApiModeRuntimeStub(fallbackAgentName);
+	const configPrimaryModel = miladyConfig.agents?.defaults?.model?.primary;
+	const configEnv = miladyConfig.env;
+	const configPiAiModelSpec = configEnv?.vars?.PI_AI_MODEL_SPEC ?? (typeof configEnv?.PI_AI_MODEL_SPEC === "string" ? configEnv.PI_AI_MODEL_SPEC : void 0);
+	const runtimeModelProvider = runtimeRef.getSetting("MODEL_PROVIDER");
+	const { provider, id } = parseModelSpec(resolveTuiModelSpec({
+		modelOverride: options.modelOverride,
+		configPrimaryModelSpec: configPrimaryModel,
+		configPiAiModelSpec,
+		runtimeModelSpec: runtimeModelProvider,
+		piDefaultModelSpec: await piCreds.getDefaultModelSpec(),
+		hasCredentials: (provider) => piCreds.hasCredentials(provider)
+	}));
+	const largeModel = getPiModel(provider, id);
+	const smallModel = largeModel;
+	const tui = new MiladyTUI({
+		runtime: runtimeRef,
+		apiBaseUrl: options.apiBaseUrl,
+		modelRegistry: { authStorage: {
+			getApiKey: (provider) => piCreds.getApiKey(provider),
+			get: async (_provider) => void 0
+		} }
+	});
+	const bridge = new ElizaTUIBridge(runtimeRef, tui, {
+		apiBaseUrl: options.apiBaseUrl,
+		apiToken: options.apiToken
+	});
+	const controller = apiMode ? null : registerPiAiModelHandler(runtimeRef, {
+		largeModel,
+		smallModel,
+		onStreamEvent: (event) => bridge.onStreamEvent(event),
+		getAbortSignal: () => bridge.getAbortSignal(),
+		priority: 2e4,
+		getApiKey: (p) => piCreds.getApiKey(p)
+	});
+	if (controller) tui.getStatusBar().update({
+		modelId: controller.getLargeModel().id,
+		modelProvider: controller.getLargeModel().provider
+	});
+	else tui.getStatusBar().update({
+		modelId: "backend",
+		modelProvider: "api"
+	});
+	const switchModel = (model) => {
+		if (!controller) {
+			tui.addToChatContainer(new Text("Model switching is managed by the connected API runtime in API mode.", 1, 0));
+			return;
+		}
+		controller.setLargeModel(model);
+		controller.setSmallModel(model);
+		runtimeRef.setSetting("MODEL_PROVIDER", `${model.provider}/${model.id}`);
+		tui.getStatusBar().update({
+			modelId: model.id,
+			modelProvider: model.provider
+		});
+		if (!piCreds.hasCredentials(model.provider)) tui.addToChatContainer(new Text(`Warning: no credentials found for provider "${model.provider}" (neither Milady env nor pi auth). Model calls may fail.`, 1, 0));
+		tui.addToChatContainer(new Text(`Switched model to ${model.provider}/${model.id}`, 1, 0));
+	};
+	tui.setOnSubmit(async (text) => {
+		if (text.startsWith("/")) {
+			const [cmdRaw, ...args] = text.slice(1).trim().split(/\s+/);
+			const cmd = (cmdRaw ?? "").toLowerCase();
+			const argText = args.join(" ").trim();
+			try {
+				if (cmd === "model" || cmd === "models") {
+					if (apiMode) {
+						tui.addToChatContainer(new Text("Model selection is managed by the connected API runtime in API mode.", 1, 0));
+						return;
+					}
+					if (!argText) {
+						tui.openModelSelector();
+						return;
+					}
+					const { provider: p, id: m } = parseModelSpec(argText);
+					switchModel(getPiModel(p, m));
+					return;
+				}
+				if (cmd === "embeddings") {
+					if (apiMode) {
+						tui.addToChatContainer(new Text("Embedding controls are only available in local runtime mode.", 1, 0));
+						return;
+					}
+					if (!argText) {
+						tui.openEmbeddings();
+						return;
+					}
+					const tier = argText.toLowerCase();
+					if (!VALID_TIERS.has(tier)) {
+						tui.addToChatContainer(new Text(`Unknown tier "${argText}". Use: fallback, standard, or performance`, 1, 0));
+						return;
+					}
+					await switchEmbeddingTier(tier, tui);
+					return;
+				}
+				if (cmd === "knowledge" || cmd === "ctx") {
+					if (apiMode) {
+						tui.addToChatContainer(new Text("Knowledge enrichment settings are managed by the connected API runtime in API mode.", 1, 0));
+						return;
+					}
+					const cfg = loadMiladyConfig();
+					const ctxEnabled = cfg.knowledge?.contextualEnrichment === true;
+					if (!argText) {
+						const embState = getEmbeddingState();
+						const embModel = embState?.preset ? `${embState.preset.model} (local, ${embState.preset.dimensions}d)` : "unknown";
+						if (ctxEnabled) {
+							const lm = controller?.getLargeModel();
+							const cloudModel = lm ? `${lm.provider}/${lm.id} (via pi-ai)` : "unknown (controller unavailable)";
+							tui.addToChatContainer(new Text([
+								"Knowledge Enrichment: ON",
+								`  Cloud model: ${cloudModel}`,
+								`  Embedding model: ${embModel}`,
+								`  Docs path: ${cfg.knowledge?.docsPath ?? "./docs"}`
+							].join("\n"), 1, 0));
+						} else tui.addToChatContainer(new Text([
+							"Knowledge Enrichment: OFF",
+							`  Embedding model: ${embModel}`,
+							"  Enable with: /knowledge on"
+						].join("\n"), 1, 0));
+						return;
+					}
+					const action = argText.toLowerCase();
+					if (action === "on") {
+						if (ctxEnabled) {
+							tui.addToChatContainer(new Text("Knowledge enrichment is already enabled.", 1, 0));
+							return;
+						}
+						cfg.knowledge = {
+							...cfg.knowledge,
+							contextualEnrichment: true
+						};
+						try {
+							saveMiladyConfig(cfg);
+						} catch (err) {
+							const msg = err instanceof Error ? err.message : String(err);
+							tui.addToChatContainer(new Text(`Could not save config: ${msg}`, 1, 0));
+							return;
+						}
+						runtimeRef.setSetting("CTX_KNOWLEDGE_ENABLED", "true");
+						tui.addToChatContainer(new Text("Knowledge enrichment enabled. Takes effect on next document ingestion.\nDocument text will be sent to your cloud provider for enrichment; embeddings stay local.", 1, 0));
+						return;
+					}
+					if (action === "off") {
+						if (!ctxEnabled) {
+							tui.addToChatContainer(new Text("Knowledge enrichment is already disabled.", 1, 0));
+							return;
+						}
+						cfg.knowledge = {
+							...cfg.knowledge,
+							contextualEnrichment: false
+						};
+						try {
+							saveMiladyConfig(cfg);
+						} catch (err) {
+							const msg = err instanceof Error ? err.message : String(err);
+							tui.addToChatContainer(new Text(`Could not save config: ${msg}`, 1, 0));
+							return;
+						}
+						runtimeRef.setSetting("CTX_KNOWLEDGE_ENABLED", null);
+						tui.addToChatContainer(new Text("Knowledge enrichment disabled. Existing enriched chunks are not affected.", 1, 0));
+						return;
+					}
+					tui.addToChatContainer(new Text("Usage: /knowledge [on|off] — toggle contextual enrichment", 1, 0));
+					return;
+				}
+				if (cmd === "help") {
+					tui.addToChatContainer(new Text([
+						"Commands:",
+						"  /model            open model selector",
+						"  /model <p/id>     switch model (e.g. anthropic/claude-sonnet-4-20250514)",
+						"  /embeddings       open embedding model popup",
+						"  /embeddings <t>   switch embedding (fallback|standard|performance)",
+						"  /knowledge       show knowledge enrichment status",
+						"  /knowledge on    enable contextual enrichment (cloud LLM + local embeddings)",
+						"  /knowledge off   disable contextual enrichment",
+						"  /clear            clear chat",
+						"  /settings         open settings panel",
+						"  /plugins          open plugin manager",
+						"  /exit             quit"
+					].join("\n"), 1, 0));
+					return;
+				}
+				if (cmd === "clear") {
+					tui.clearChat();
+					return;
+				}
+				if (cmd === "settings") {
+					tui.openSettings();
+					return;
+				}
+				if (cmd === "plugins") {
+					tui.openPlugins();
+					return;
+				}
+				if (cmd === "exit" || cmd === "quit") {
+					bridge.dispose();
+					await tui.stop();
+					await runtimeRef.stop();
+					process.exit(0);
+				}
+				tui.addToChatContainer(new Text(`Unknown command: /${cmd}. Try /help`, 1, 0));
+				return;
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				tui.addToChatContainer(new Text(`Command error: ${msg}`, 1, 0));
+				return;
+			}
+		}
+		await bridge.handleUserInput(text);
+	});
+	tui.setOnToggleToolExpand((expanded) => bridge.setToolOutputExpanded(expanded));
+	tui.setOnToggleThinking((enabled) => bridge.setShowThinking(enabled));
+	tui.setOnCtrlC(() => {
+		if (bridge.getIsProcessing()) {
+			bridge.abortInFlight();
+			return;
+		}
+		(async () => {
+			try {
+				bridge.dispose();
+				await tui.stop();
+			} finally {
+				await runtimeRef.stop();
+				process.exit(0);
+			}
+		})();
+	});
+	if (!apiMode && controller) {
+		tui.setModelSelectorHandlers({
+			getCurrentModel: () => controller.getLargeModel(),
+			hasCredentials: (provider) => piCreds.hasCredentials(provider),
+			onSelectModel: (model) => {
+				try {
+					switchModel(model);
+				} catch (err) {
+					const msg = err instanceof Error ? err.message : String(err);
+					tui.addToChatContainer(new Text(`Model switch error: ${msg}`, 1, 0));
+				}
+			}
+		});
+		tui.setEmbeddingHandlers({
+			getOptions: () => getEmbeddingOptions(),
+			onSelectTier: async (tier) => {
+				await switchEmbeddingTier(tier, tui);
+			}
+		});
+	}
+	await bridge.initialize();
+	try {
+		await tui.start();
+	} finally {
+		bridge.dispose();
+	}
+}
+
+//#endregion
+export { launchTUI };

package/dist/tui/modal-presets.js

@@ -0,0 +1,33 @@
+//#region src/tui/modal-presets.ts
+/**
+* Shared popup sizing presets for a consistent overlay rhythm.
+*/
+const MODAL_PRESETS = {
+	compact: {
+		anchor: "center",
+		width: "50%",
+		maxHeight: "50%",
+		margin: 2
+	},
+	standard: {
+		anchor: "center",
+		width: "60%",
+		maxHeight: "70%",
+		margin: 2
+	},
+	wide: {
+		anchor: "center",
+		width: "80%",
+		maxHeight: "85%",
+		margin: 2
+	},
+	xwide: {
+		anchor: "center",
+		width: "90%",
+		maxHeight: "80%",
+		margin: 2
+	}
+};
+
+//#endregion
+export { MODAL_PRESETS };

package/dist/tui/model-spec.js

@@ -0,0 +1,46 @@
+import { DEFAULT_PI_MODEL_SPEC, parseModelSpec } from "@elizaos/plugin-pi-ai";
+
+//#region src/tui/model-spec.ts
+function toValidModelSpec(spec) {
+	if (!spec) return void 0;
+	const normalized = spec.trim();
+	if (!normalized) return void 0;
+	try {
+		parseModelSpec(normalized);
+		return normalized;
+	} catch {
+		return;
+	}
+}
+/**
+* Select the model spec used by the TUI pi-ai bridge.
+*
+* Priority:
+* 1) explicit CLI override (--model)
+* 2) milady config primary model (agents.defaults.model.primary)
+* 3) milady config PI_AI_MODEL_SPEC
+* 4) runtime MODEL_PROVIDER
+* 5) pi settings default (settings.json)
+* 6) built-in safe default
+*
+* Candidate specs are only used when credentials exist for the provider.
+*/
+function resolveTuiModelSpec(params) {
+	const defaultSpec = toValidModelSpec(params.piDefaultModelSpec) ?? DEFAULT_PI_MODEL_SPEC;
+	const candidates = [
+		params.modelOverride,
+		params.configPrimaryModelSpec,
+		params.configPiAiModelSpec,
+		params.runtimeModelSpec
+	];
+	for (const candidate of candidates) {
+		const spec = toValidModelSpec(candidate);
+		if (!spec) continue;
+		const { provider } = parseModelSpec(spec);
+		if (params.hasCredentials(provider)) return spec;
+	}
+	return defaultSpec;
+}
+
+//#endregion
+export { resolveTuiModelSpec };

package/dist/tui/sse-parser.js

@@ -0,0 +1,78 @@
+//#region src/tui/sse-parser.ts
+/**
+* Find the next SSE event boundary in the buffer.
+* Supports both LF (\n\n) and CRLF (\r\n\r\n) framing.
+*/
+function findSseEventBreak(buffer) {
+	const lfBreak = buffer.indexOf("\n\n");
+	const crlfBreak = buffer.indexOf("\r\n\r\n");
+	if (lfBreak === -1 && crlfBreak === -1) return null;
+	if (lfBreak === -1) return {
+		index: crlfBreak,
+		length: 4
+	};
+	if (crlfBreak === -1) return {
+		index: lfBreak,
+		length: 2
+	};
+	return lfBreak < crlfBreak ? {
+		index: lfBreak,
+		length: 2
+	} : {
+		index: crlfBreak,
+		length: 4
+	};
+}
+/**
+* Split a chunk buffer into complete SSE raw events + the remaining tail.
+*/
+function drainSseEvents(buffer) {
+	const events = [];
+	let remaining = buffer;
+	let eventBreak = findSseEventBreak(remaining);
+	while (eventBreak) {
+		events.push(remaining.slice(0, eventBreak.index));
+		remaining = remaining.slice(eventBreak.index + eventBreak.length);
+		eventBreak = findSseEventBreak(remaining);
+	}
+	return {
+		events,
+		remaining
+	};
+}
+/**
+* Extract `data:` payloads from one raw SSE event block.
+*/
+function extractSseDataPayloads(rawEvent) {
+	const payloads = [];
+	for (const line of rawEvent.split(/\r?\n/)) {
+		if (!line.startsWith("data:")) continue;
+		const payload = line.slice(5).trim();
+		if (!payload) continue;
+		payloads.push(payload);
+	}
+	return payloads;
+}
+/**
+* Parse JSON payload for conversation streaming events.
+*/
+function parseConversationStreamPayload(payload) {
+	let parsed;
+	try {
+		parsed = JSON.parse(payload);
+	} catch {
+		return null;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+	const record = parsed;
+	return {
+		type: typeof record.type === "string" ? record.type : void 0,
+		text: typeof record.text === "string" ? record.text : void 0,
+		fullText: typeof record.fullText === "string" ? record.fullText : void 0,
+		agentName: typeof record.agentName === "string" ? record.agentName : void 0,
+		message: typeof record.message === "string" ? record.message : void 0
+	};
+}
+
+//#endregion
+export { drainSseEvents, extractSseDataPayloads, parseConversationStreamPayload };

package/dist/tui/theme.js

@@ -0,0 +1,110 @@
+import chalk from "chalk";
+import { highlight, supportsLanguage } from "cli-highlight";
+
+//#region src/tui/theme.ts
+const ACCENT = "#E879F9";
+const ACCENT_DIM = "#A855F7";
+const MUTED = "#808080";
+const DIM = "#666666";
+const SUCCESS = "#b5bd68";
+const ERROR = "#cc6666";
+const WARNING = "#FBBF24";
+const INFO = "#60A5FA";
+const USER_MSG_BG = "#2D1B3D";
+const TOOL_PENDING_BG = "#282832";
+const TOOL_SUCCESS_BG = "#283228";
+const TOOL_ERROR_BG = "#3c2828";
+const MD_HEADING = "#f0c674";
+const MD_LINK = "#81a2be";
+const MD_CODE = ACCENT;
+const MD_CODE_BLOCK = SUCCESS;
+const SYN_COMMENT = "#6A9955";
+const SYN_KEYWORD = "#C586C0";
+const SYN_FUNCTION = "#DCDCAA";
+const SYN_VARIABLE = "#9CDCFE";
+const SYN_STRING = "#CE9178";
+const SYN_NUMBER = "#B5CEA8";
+const SYN_TYPE = "#4EC9B0";
+const SYN_OPERATOR = "#D4D4D4";
+const SYN_PUNCTUATION = "#808080";
+const hex = (value) => chalk.hex(value);
+const bg = (value) => chalk.bgHex(value);
+/** cli-highlight theme mapped to Milady's palette. */
+const cliHighlightTheme = {
+	keyword: (s) => hex(SYN_KEYWORD)(s),
+	built_in: (s) => hex(SYN_TYPE)(s),
+	literal: (s) => hex(SYN_NUMBER)(s),
+	number: (s) => hex(SYN_NUMBER)(s),
+	string: (s) => hex(SYN_STRING)(s),
+	comment: (s) => hex(SYN_COMMENT)(s),
+	function: (s) => hex(SYN_FUNCTION)(s),
+	title: (s) => hex(SYN_FUNCTION)(s),
+	class: (s) => hex(SYN_TYPE)(s),
+	type: (s) => hex(SYN_TYPE)(s),
+	attr: (s) => hex(SYN_VARIABLE)(s),
+	variable: (s) => hex(SYN_VARIABLE)(s),
+	params: (s) => hex(SYN_VARIABLE)(s),
+	operator: (s) => hex(SYN_OPERATOR)(s),
+	punctuation: (s) => hex(SYN_PUNCTUATION)(s)
+};
+const miladySelectListTheme = {
+	selectedPrefix: (text) => hex(ACCENT)(text),
+	selectedText: (text) => chalk.bold(hex(ACCENT)(text)),
+	description: (text) => hex(MUTED)(text),
+	scrollInfo: (text) => hex(MUTED)(text),
+	noMatch: (text) => hex(MUTED)(text)
+};
+const miladyEditorTheme = {
+	borderColor: (text) => hex(DIM)(text),
+	selectList: miladySelectListTheme
+};
+const miladyMarkdownTheme = {
+	heading: (text) => chalk.bold(hex(MD_HEADING)(text)),
+	link: (text) => hex(MD_LINK)(text),
+	linkUrl: (text) => hex(DIM)(text),
+	code: (text) => hex(MD_CODE)(text),
+	codeBlock: (text) => hex(MD_CODE_BLOCK)(text),
+	codeBlockBorder: (text) => hex(MUTED)(text),
+	quote: (text) => hex(MUTED)(text),
+	quoteBorder: (text) => hex(MUTED)(text),
+	hr: (text) => hex(MUTED)(text),
+	listBullet: (text) => hex(ACCENT_DIM)(text),
+	bold: (text) => chalk.bold(text),
+	italic: (text) => chalk.italic(hex(ACCENT_DIM)(text)),
+	strikethrough: (text) => chalk.strikethrough(text),
+	underline: (text) => chalk.underline(text),
+	highlightCode: (code, lang) => {
+		const validLang = lang && supportsLanguage(lang) ? lang : void 0;
+		try {
+			return highlight(code, {
+				language: validLang,
+				ignoreIllegals: true,
+				theme: cliHighlightTheme
+			}).split("\n");
+		} catch {
+			return code.split("\n").map((line) => hex(MD_CODE_BLOCK)(line));
+		}
+	}
+};
+const tuiTheme = {
+	accent: (text) => hex(ACCENT)(text),
+	accentDim: (text) => hex(ACCENT_DIM)(text),
+	muted: (text) => hex(MUTED)(text),
+	dim: (text) => hex(DIM)(text),
+	success: (text) => hex(SUCCESS)(text),
+	error: (text) => hex(ERROR)(text),
+	warning: (text) => hex(WARNING)(text),
+	info: (text) => hex(INFO)(text),
+	bold: (text) => chalk.bold(text),
+	italic: (text) => chalk.italic(text),
+	userMsgBg: (text) => bg(USER_MSG_BG)(text),
+	toolPendingBg: (text) => bg(TOOL_PENDING_BG)(text),
+	toolSuccessBg: (text) => bg(TOOL_SUCCESS_BG)(text),
+	toolErrorBg: (text) => bg(TOOL_ERROR_BG)(text),
+	markdown: miladyMarkdownTheme,
+	editor: miladyEditorTheme,
+	selectList: miladySelectListTheme
+};
+
+//#endregion
+export { miladyMarkdownTheme, tuiTheme };

package/dist/tui/titlebar-spinner.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+
+//#region src/tui/titlebar-spinner.ts
+const BRAILLE_FRAMES = [
+	"⠋",
+	"⠙",
+	"⠹",
+	"⠸",
+	"⠼",
+	"⠴",
+	"⠦",
+	"⠧",
+	"⠇",
+	"⠏"
+];
+/**
+* Lightweight titlebar spinner used by the Milady TUI while a request is in
+* flight.
+*/
+var TitlebarSpinner = class {
+	constructor(options) {
+		this.options = options;
+		this.timer = null;
+		this.frameIndex = 0;
+		this.baseTitle = getDefaultTitle();
+	}
+	setBaseTitle(title) {
+		this.baseTitle = title.trim() || getDefaultTitle();
+		if (!this.timer) this.applyTitle(this.baseTitle);
+	}
+	start() {
+		this.stop();
+		const intervalMs = this.options.intervalMs ?? 80;
+		this.timer = setInterval(() => {
+			const frame = BRAILLE_FRAMES[this.frameIndex % BRAILLE_FRAMES.length] ?? "⠋";
+			this.applyTitle(`${frame} ${this.baseTitle}`);
+			this.frameIndex += 1;
+		}, intervalMs);
+	}
+	stop() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+		this.frameIndex = 0;
+		this.applyTitle(this.baseTitle);
+	}
+	dispose() {
+		this.stop();
+	}
+	applyTitle(title) {
+		try {
+			this.options.setTitle(title);
+		} catch {}
+	}
+};
+function getDefaultTitle() {
+	return `milady - ${path.basename(process.cwd())}`;
+}
+
+//#endregion
+export { TitlebarSpinner };