@alisio/alisio-code 0.1.0-alpha.10

package/dist/tui/state.js

@@ -0,0 +1,566 @@
+const trimZero = (value) => value.replace(/\.0$/, "");
+export function formatTokens(n) {
+    if (!Number.isFinite(n) || n < 0)
+        return "0";
+    if (n < 1000)
+        return String(Math.round(n));
+    if (n < 1_000_000) {
+        const k = n / 1000;
+        return `${k < 100 ? trimZero(k.toFixed(1)) : Math.round(k)}k`;
+    }
+    return `${trimZero((n / 1_000_000).toFixed(1))}M`;
+}
+/** Prefixes every model with its owning provider so identical model ids are never ambiguous. */
+export function providerModelItems(provider, models, current) {
+    return models.map((model) => ({
+        value: model.id,
+        label: `${provider} · ${model.name ?? model.id}${model.id === current ? " (current)" : ""}`,
+        ...(model.contextWindow
+            ? { description: `${model.id} · ${formatTokens(model.contextWindow)} context` }
+            : model.name
+                ? { description: model.id }
+                : {}),
+    }));
+}
+/** Text markers remain meaningful without color: [x] active, [ ] inactive, [!] failed, [*] pending. */
+/** Group headings are derived from the primary category (or "General") of each plugin. */
+export function pluginCatalogItems(entries) {
+    const marker = (entry) => entry.status === "active"
+        ? "[x]"
+        : entry.status === "inactive"
+            ? "[ ]"
+            : entry.status === "failed"
+                ? "[!]"
+                : "[*]";
+    const grouped = new Map();
+    for (const entry of entries) {
+        const primary = entry.categories[0] ?? "General";
+        grouped.set(primary, [...(grouped.get(primary) ?? []), entry]);
+    }
+    return [...grouped].flatMap(([title, group]) => group.map((entry, index) => ({
+        value: entry.id,
+        label: `${index === 0 ? `${title} · ` : ""}${marker(entry)} ${entry.name} · ${entry.builtin ? "built-in" : entry.source}`,
+        description: `${entry.status}${entry.categories.length ? ` · ${entry.categories.join(", ")}` : ""} · ${entry.description}`,
+    })));
+}
+export const pluginToggleNeedsConfirmation = (entry) => !entry.builtin;
+const mcpSourceTitle = (kind) => ({
+    global: "User",
+    project: "Project",
+    explicit: "Explicit",
+    builtin: "Built-in",
+    plugin: "Plugin",
+})[kind];
+/** Group headings are generated only for sources that actually registered servers. */
+export function mcpServerItems(entries) {
+    const marker = (status) => ({
+        disabled: "[ ]",
+        disconnected: "[-]",
+        connecting: "[…]",
+        connected: "[x]",
+        failed: "[!]",
+        "needs-authentication": "[?]",
+        "restart-required": "[*]",
+    })[status];
+    const grouped = new Map();
+    for (const entry of entries) {
+        const title = mcpSourceTitle(entry.source.kind);
+        grouped.set(title, [...(grouped.get(title) ?? []), entry]);
+    }
+    return [...grouped].flatMap(([title, servers]) => servers.map((entry, index) => ({
+        value: entry.name,
+        label: `${index === 0 ? `${title} · ` : ""}${marker(entry.status)} ${entry.displayName}`,
+        description: `configured ${entry.enabled ? "enabled" : "disabled"} · permission ${entry.runtimePermission} · ${entry.status}${entry.status === "connected" ? ` · ${entry.counts.tools} tool${entry.counts.tools === 1 ? "" : "s"} loaded` : " · 0 tools loaded"}`,
+    })));
+}
+export function mcpToolItems(tools) {
+    return tools.map((tool) => {
+        const flags = [
+            tool.annotations?.readOnly === true ? "read-only" : undefined,
+            tool.annotations?.destructive === true ? "destructive" : undefined,
+            tool.annotations?.openWorld === true ? "open-world" : undefined,
+        ].filter(Boolean);
+        return {
+            value: tool.effectiveName ?? tool.name,
+            label: tool.title
+                ? `${tool.title} · ${tool.name}${tool.effectiveName && tool.effectiveName !== tool.name ? ` → ${tool.effectiveName}` : ""}`
+                : tool.effectiveName && tool.effectiveName !== tool.name
+                    ? `${tool.name} → ${tool.effectiveName}`
+                    : tool.name,
+            description: [...flags, tool.description].filter(Boolean).join(" · ") || "No description",
+        };
+    });
+}
+/** Builds one filterable list while retaining provider/profile ownership in each opaque value. */
+export function configuredProviderModelItems(catalogs, current) {
+    const items = [];
+    for (const catalog of catalogs) {
+        if (catalog.unavailable) {
+            items.push({
+                value: JSON.stringify({ profile: catalog.profile }),
+                label: `${catalog.title} · unavailable`,
+                description: `${catalog.provider} · catalog refresh failed`,
+                unavailable: true,
+            });
+            continue;
+        }
+        const models = catalog.models.length
+            ? catalog.models
+            : catalog.configuredModel
+                ? [{ id: catalog.configuredModel }]
+                : [];
+        for (const model of models)
+            items.push({
+                value: JSON.stringify({
+                    profile: catalog.profile,
+                    provider: catalog.provider,
+                    model: model.id,
+                }),
+                label: `${catalog.title} · ${model.name ?? model.id}${catalog.provider === current?.provider && model.id === current.model ? " (current)" : ""}`,
+                description: `${model.id.startsWith(`${catalog.provider}/`) ? model.id : `${catalog.provider}/${model.id}`}${model.contextWindow ? ` · ${formatTokens(model.contextWindow)} context` : ""}`,
+                unavailable: false,
+            });
+    }
+    return items;
+}
+export function contextLevel(pct, compactionAt = 85) {
+    // Warning band starts a quarter below the auto-compaction point; danger is exactly there.
+    const warn = Math.max(0, compactionAt - 25);
+    return pct < warn ? "ok" : pct < compactionAt ? "warn" : "danger";
+}
+export function contextPercent(used, total) {
+    return total && total > 0 ? (used / total) * 100 : undefined;
+}
+export function formatContext(used, total, estimated, basis) {
+    const prefix = `${estimated ? "~" : ""}${formatTokens(used)} / `;
+    // Honest unknown: the model window could not be known, so the bar shows `?` instead of a
+    // fabricated total or percentage.
+    if (basis === "unknown")
+        return `${prefix}?`;
+    const pct = contextPercent(used, total);
+    if (pct === undefined || !total)
+        return `${prefix}unknown`;
+    return `${prefix}${formatTokens(total)} (${Math.round(pct)}%)`;
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${Math.max(0, Math.round(ms))}ms`;
+    if (ms < 60_000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const total = Math.floor(ms / 1000);
+    return `${Math.floor(total / 60)}m${String(total % 60).padStart(2, "0")}s`;
+}
+export const textWidth = (text) => [...text].length;
+export function truncatePlain(text, width) {
+    if (width <= 0)
+        return "";
+    const chars = [...text];
+    return chars.length <= width ? text : `${chars.slice(0, width - 1).join("")}…`;
+}
+export function shortenPath(path, home, max = 40) {
+    let display = home && (path === home || path.startsWith(`${home}/`)) ? `~${path.slice(home.length)}` : path;
+    if (textWidth(display) <= max)
+        return display;
+    const parts = display.split("/").filter(Boolean);
+    display = "";
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const next = `${parts[i]}${display ? `/${display}` : ""}`;
+        if (textWidth(`…/${next}`) > max && display)
+            break;
+        display = next;
+    }
+    return truncatePlain(`…/${display}`, max);
+}
+/** Host (and port) only: never path, query, user info or credentials. */
+export function hostOf(baseURL) {
+    try {
+        return new URL(baseURL).host || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export const shortId = (id) => id.slice(0, 8);
+/** Keeps segments in order, dropping the lowest priority ones until the line fits. */
+export function fitSegments(segments, width, separator) {
+    const kept = [...segments];
+    const total = () => kept.reduce((sum, s) => sum + textWidth(s.text), 0) +
+        Math.max(0, kept.length - 1) * textWidth(separator);
+    while (kept.length > 1 && total() > width) {
+        let lowest = 0;
+        for (let i = 1; i < kept.length; i++)
+            if ((kept[i]?.priority ?? 0) < (kept[lowest]?.priority ?? 0))
+                lowest = i;
+        kept.splice(lowest, 1);
+    }
+    const only = kept[0];
+    if (kept.length === 1 && only && textWidth(only.text) > width)
+        kept[0] = { ...only, text: truncatePlain(only.text, width) };
+    return kept;
+}
+export const COMMANDS = [
+    { name: "help", description: "Show commands and keys" },
+    { name: "connect", description: "Configure a provider and choose its active model" },
+    {
+        name: "model",
+        description: "Switch provider and model",
+        aliases: ["models"],
+    },
+    { name: "compact", description: "Summarize older history", argumentHint: "[focus]" },
+    { name: "stats", description: "Session statistics" },
+    { name: "clear", description: "Start a new session", aliases: ["new"] },
+    { name: "sessions", description: "List recent sessions" },
+    { name: "resume", description: "Resume a session by ID or prefix", argumentHint: "<id>" },
+    { name: "tools", description: "List tools and permission state" },
+    {
+        name: "plugins",
+        description: "Browse and manage project plugins",
+        aliases: ["plugin"],
+    },
+    {
+        name: "skills",
+        description: "Browse and manage effective skills",
+        aliases: ["skill"],
+    },
+    { name: "mcp", description: "Browse and manage MCP servers" },
+    { name: "copy", description: "Copy the last assistant response to the clipboard" },
+    {
+        name: "ask",
+        description: "Ask the agent to turn your question into a multiple-choice ask_user_question",
+        argumentHint: "<question>",
+    },
+    { name: "exit", description: "Exit Alisio", aliases: ["quit"] },
+];
+/** Every TUI slash name (commands, aliases and routing prefixes); templates cannot take them. */
+export function reservedCommandNames() {
+    return [...COMMANDS.flatMap((c) => [c.name, ...(c.aliases ?? [])]), "command"];
+}
+export function resolveCommand(name) {
+    const lower = name.toLowerCase();
+    return COMMANDS.find((c) => c.name === lower || c.aliases?.includes(lower))?.name;
+}
+export function parseCommand(input) {
+    const match = /^\/([A-Za-z][\w:.-]*)(?:\s+([\s\S]*))?$/.exec(input.trim());
+    if (!match?.[1])
+        return undefined;
+    return { name: match[1], args: (match[2] ?? "").trim() };
+}
+function parseArgs(args) {
+    try {
+        const value = JSON.parse(args);
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const oneLine = (text) => text.replace(/\s+/g, " ").trim();
+export function summarizeToolArgs(name, args) {
+    const input = parseArgs(args);
+    if (!input)
+        return truncatePlain(oneLine(args), 120);
+    const str = (key) => (typeof input[key] === "string" ? input[key] : "");
+    let text;
+    if (name === "run_process") {
+        const rest = Array.isArray(input.args) ? input.args.map(String) : [];
+        text = [str("command"), ...rest].join(" ");
+    }
+    else if (name === "search_text")
+        text = `"${str("pattern")}"${str("path") ? ` in ${str("path")}` : ""}`;
+    else {
+        const key = ["path", "command", "name", "query", "pattern", "url", "title"].find((k) => str(k));
+        text = key ? str(key) : Object.keys(input).length ? JSON.stringify(input) : "";
+    }
+    return truncatePlain(oneLine(text), 120);
+}
+const splitLines = (text) => {
+    const lines = text.split(/\r?\n/);
+    if (lines.length > 1 && lines.at(-1) === "")
+        lines.pop();
+    return lines;
+};
+function diffLines(before, after) {
+    if (before.length * after.length > 250_000)
+        return [
+            ...before.map((text) => ({ sign: "-", text })),
+            ...after.map((text) => ({ sign: "+", text })),
+        ];
+    const n = before.length, m = after.length;
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--)
+        for (let j = m - 1; j >= 0; j--)
+            lcs[i][j] =
+                before[i] === after[j]
+                    ? (lcs[i + 1]?.[j + 1] ?? 0) + 1
+                    : Math.max(lcs[i + 1]?.[j] ?? 0, lcs[i]?.[j + 1] ?? 0);
+    const out = [];
+    let i = 0, j = 0;
+    while (i < n || j < m) {
+        if (i < n && j < m && before[i] === after[j]) {
+            i++;
+            j++;
+        }
+        else if (j >= m || (i < n && (lcs[i + 1]?.[j] ?? 0) >= (lcs[i]?.[j + 1] ?? 0)))
+            out.push({ sign: "-", text: before[i++] ?? "" });
+        else
+            out.push({ sign: "+", text: after[j++] ?? "" });
+    }
+    return out;
+}
+export function editSummary(name, args) {
+    if (name !== "edit_file" && name !== "write_file")
+        return undefined;
+    const input = parseArgs(args);
+    if (!input)
+        return undefined;
+    const path = typeof input.path === "string" ? input.path : "";
+    const lines = name === "write_file"
+        ? splitLines(String(input.content ?? "")).map((text) => ({ sign: "+", text }))
+        : diffLines(splitLines(String(input.oldText ?? "")), splitLines(String(input.newText ?? "")));
+    return {
+        path,
+        added: lines.filter((l) => l.sign === "+").length,
+        removed: lines.filter((l) => l.sign === "-").length,
+        lines,
+    };
+}
+export function initialViewState(model, now = Date.now()) {
+    return {
+        items: [],
+        streaming: false,
+        compacting: false,
+        model,
+        stats: {
+            input: 0,
+            output: 0,
+            cached: 0,
+            turns: 0,
+            runs: 0,
+            tools: {},
+            models: [model],
+            startedAt: now,
+        },
+    };
+}
+export function addItem(state, item) {
+    return { ...state, items: [...state.items, item] };
+}
+const withModel = (stats, model) => typeof model === "string" && model && !stats.models.includes(model)
+    ? { ...stats, models: [...stats.models, model] }
+    : stats;
+function appendAssistant(state, field, delta) {
+    const last = state.items.at(-1);
+    if (last?.kind === "assistant" && !last.done)
+        return {
+            ...state,
+            items: [...state.items.slice(0, -1), { ...last, [field]: last[field] + delta }],
+        };
+    return addItem(state, {
+        kind: "assistant",
+        text: field === "text" ? delta : "",
+        reasoning: field === "reasoning" ? delta : "",
+        done: false,
+    });
+}
+function updateTool(state, id, update) {
+    const index = state.items.findLastIndex((i) => i.kind === "tool" && i.id === id);
+    const item = state.items[index];
+    if (index < 0 || item?.kind !== "tool")
+        return state;
+    const items = [...state.items];
+    items[index] = { ...item, ...update };
+    return { ...state, items };
+}
+export function reduceEvent(state, event) {
+    const d = (event.data ?? {});
+    const at = Date.parse(event.timestamp);
+    switch (event.type) {
+        case "run_started":
+            return {
+                ...state,
+                streaming: true,
+                runStartedAt: at,
+                stats: withModel({ ...state.stats, runs: state.stats.runs + 1 }, d.model),
+            };
+        case "text_delta":
+            return appendAssistant(state, "text", String(d.delta ?? ""));
+        case "reasoning_delta":
+            return appendAssistant(state, "reasoning", String(d.delta ?? ""));
+        case "turn_completed": {
+            const usage = d.usage;
+            const last = state.items.at(-1);
+            const items = last?.kind === "assistant" && !last.done
+                ? [...state.items.slice(0, -1), { ...last, done: true }]
+                : state.items;
+            const stats = withModel({ ...state.stats, turns: state.stats.turns + 1 }, d.model);
+            if (!usage)
+                return { ...state, items, stats };
+            return {
+                ...state,
+                items,
+                context: { used: (usage.input ?? 0) + (usage.output ?? 0), estimated: false },
+                stats: {
+                    ...stats,
+                    input: stats.input + (usage.input ?? 0),
+                    output: stats.output + (usage.output ?? 0),
+                    cached: stats.cached + (usage.cachedInput ?? 0),
+                },
+            };
+        }
+        case "tool_started":
+            return addItem(state, {
+                kind: "tool",
+                id: String(d.id ?? ""),
+                name: String(d.name ?? "tool"),
+                args: typeof d.arguments === "string" ? d.arguments : "",
+                summary: summarizeToolArgs(String(d.name ?? ""), typeof d.arguments === "string" ? d.arguments : ""),
+                status: "running",
+            });
+        case "approval_requested":
+            return updateTool(state, d.id, { status: "approval" });
+        case "approval_resolved":
+            return updateTool(state, d.id, { status: "running" });
+        case "tool_completed": {
+            const name = String(d.name ?? "tool");
+            const current = state.stats.tools[name] ?? { calls: 0, errors: 0 };
+            const next = updateTool(state, d.id, {
+                status: d.isError ? "error" : "ok",
+                ...(typeof d.durationMs === "number" ? { durationMs: d.durationMs } : {}),
+                ...(typeof d.preview === "string" ? { preview: d.preview } : {}),
+            });
+            return {
+                ...next,
+                stats: {
+                    ...next.stats,
+                    tools: {
+                        ...next.stats.tools,
+                        [name]: { calls: current.calls + 1, errors: current.errors + (d.isError ? 1 : 0) },
+                    },
+                },
+            };
+        }
+        case "run_completed":
+        case "run_failed":
+        case "run_cancelled": {
+            const ended = {
+                ...state,
+                streaming: false,
+                compacting: false,
+                stats: {
+                    ...state.stats,
+                    ...(state.runStartedAt !== undefined ? { lastRunMs: at - state.runStartedAt } : {}),
+                },
+            };
+            if (event.type === "run_failed")
+                return addItem(ended, { kind: "error", text: String(d.error ?? "Run failed") });
+            if (event.type === "run_cancelled") {
+                const reason = String(d.error ?? "cancelled");
+                return addItem(ended, {
+                    kind: "notice",
+                    text: reason.startsWith("Interrupted") ? reason : `Interrupted: ${reason}`,
+                });
+            }
+            return ended;
+        }
+        case "compaction_started":
+            return { ...state, compacting: true };
+        case "compaction_completed": {
+            const reports = Object.values((d.plugins ?? {}))
+                .map((r) => (typeof r?.summary === "string" ? r.summary : ""))
+                .filter(Boolean);
+            const checkpoint = typeof d.summarizedTokens === "number" && typeof d.checkpointTokens === "number"
+                ? ` · checkpoint ~${formatTokens(d.summarizedTokens)} → ~${formatTokens(d.checkpointTokens)} tokens`
+                : "";
+            const partial = d.partial
+                ? " · partial: the summary was cut by max output tokens; consider raising compaction.maxOutputTokens"
+                : "";
+            return addItem({
+                ...state,
+                compacting: false,
+                context: { used: Number(d.after ?? 0), estimated: true },
+            }, {
+                kind: "notice",
+                text: [
+                    `Context compacted (${String(d.reason ?? "manual")}): ${String(d.replaced ?? 0)} messages summarized, ~${formatTokens(Number(d.before ?? 0))} → ~${formatTokens(Number(d.after ?? 0))} tokens${checkpoint}${partial}`,
+                    ...reports,
+                ].join("\n"),
+            });
+        }
+        case "plugin_hook_failed":
+            return addItem(state, {
+                kind: "notice",
+                text: `Plugin ${String(d.source ?? "?")} ${String(d.hook ?? "hook")} failed: ${String(d.error ?? "unknown error")} (continued without it)`,
+            });
+        case "session_context_injected":
+            return addItem(state, {
+                kind: "notice",
+                text: `Context injected by ${(d.sources ?? ["plugin"]).join(", ")} (~${formatTokens(Number(d.tokens ?? 0))} tokens)`,
+            });
+        case "compaction_skipped":
+            return addItem({ ...state, compacting: false }, { kind: "notice", text: `Compaction skipped: ${String(d.detail ?? "nothing to compact")}` });
+        case "compaction_failed":
+            return addItem({ ...state, compacting: false }, { kind: "error", text: `Compaction failed: ${String(d.error ?? "unknown error")}` });
+        case "response_truncated":
+            return addItem(state, {
+                kind: "notice",
+                text: "Response cut by max output tokens — the answer may be incomplete. Raise limits.maxOutputTokens to allow longer answers.",
+            });
+        case "model_changed":
+            return {
+                ...state,
+                model: String(d.model ?? state.model),
+                stats: withModel(state.stats, d.model),
+                items: [
+                    ...state.items,
+                    {
+                        kind: "notice",
+                        text: `Model: ${String(d.previous ?? "?")} → ${String(d.model ?? "?")}`,
+                    },
+                ],
+            };
+        default:
+            return state;
+    }
+}
+export function lastAssistantText(items) {
+    for (let i = items.length - 1; i >= 0; i--) {
+        const item = items[i];
+        if (item?.kind === "assistant" && item.text.trim())
+            return item.text;
+    }
+    return undefined;
+}
+/** Rebuilds transcript items from persisted history (used by /resume). */
+export function itemsFromHistory(messages) {
+    const items = [];
+    const results = new Map();
+    for (const m of messages)
+        if (m.role === "tool")
+            results.set(m.callId, m);
+    for (const m of messages) {
+        if (m.role === "user")
+            items.push(m.summary ? { kind: "info", text: m.text } : { kind: "user", text: m.display ?? m.text });
+        else if (m.role === "assistant") {
+            if (m.text)
+                items.push({ kind: "assistant", text: m.text, reasoning: "", done: true });
+            for (const c of m.calls) {
+                const r = results.get(c.id);
+                items.push({
+                    kind: "tool",
+                    id: c.id,
+                    name: c.name,
+                    args: c.arguments,
+                    summary: summarizeToolArgs(c.name, c.arguments),
+                    status: r?.result.isError ? "error" : "ok",
+                    preview: r?.result.content
+                        .map((x) => x.text)
+                        .join("\n")
+                        .slice(0, 2_000),
+                });
+            }
+        }
+    }
+    return items;
+}

package/dist/tui/theme.d.ts

@@ -0,0 +1,23 @@
+import type { EditorTheme, ImageTheme, MarkdownTheme, SelectListTheme } from "@earendil-works/pi-tui";
+import type { Level } from "./state.ts";
+export declare const style: {
+    bold: (text: string) => string;
+    dim: (text: string) => string;
+    italic: (text: string) => string;
+    underline: (text: string) => string;
+    strike: (text: string) => string;
+    red: (text: string) => string;
+    green: (text: string) => string;
+    yellow: (text: string) => string;
+    blue: (text: string) => string;
+    magenta: (text: string) => string;
+    cyan: (text: string) => string;
+    gray: (text: string) => string;
+    brightCyan: (text: string) => string;
+    userBg: (text: string) => string;
+};
+export declare const levelColor: (level: Level) => (text: string) => string;
+export declare const markdownTheme: MarkdownTheme;
+export declare const selectListTheme: SelectListTheme;
+export declare const editorTheme: EditorTheme;
+export declare const imageTheme: ImageTheme;

package/dist/tui/theme.js

@@ -0,0 +1,49 @@
+const enabled = !process.env.NO_COLOR;
+const sgr = (open, close) => (text) => enabled ? `\x1b[${open}m${text}\x1b[${close}m` : text;
+export const style = {
+    bold: sgr(1, 22),
+    dim: sgr(2, 22),
+    italic: sgr(3, 23),
+    underline: sgr(4, 24),
+    strike: sgr(9, 29),
+    red: sgr(31, 39),
+    green: sgr(32, 39),
+    yellow: sgr(33, 39),
+    blue: sgr(34, 39),
+    magenta: sgr(35, 39),
+    cyan: sgr(36, 39),
+    gray: sgr(90, 39),
+    brightCyan: sgr(96, 39),
+    userBg: sgr("48;5;236", 49),
+};
+export const levelColor = (level) => level === "ok" ? style.green : level === "warn" ? style.yellow : style.red;
+export const markdownTheme = {
+    heading: (t) => style.bold(style.cyan(t)),
+    link: (t) => style.underline(style.blue(t)),
+    linkUrl: (t) => style.dim(t),
+    code: (t) => style.yellow(t),
+    codeBlock: (t) => style.green(t),
+    codeBlockBorder: (t) => style.dim(t),
+    quote: (t) => style.italic(style.gray(t)),
+    quoteBorder: (t) => style.dim(t),
+    hr: (t) => style.dim(t),
+    listBullet: (t) => style.cyan(t),
+    bold: (t) => style.bold(t),
+    italic: (t) => style.italic(t),
+    strikethrough: (t) => style.strike(t),
+    underline: (t) => style.underline(t),
+};
+export const selectListTheme = {
+    selectedPrefix: (t) => style.cyan(t),
+    selectedText: (t) => style.bold(style.cyan(t)),
+    description: (t) => style.gray(t),
+    scrollInfo: (t) => style.dim(t),
+    noMatch: (t) => style.yellow(t),
+};
+export const editorTheme = {
+    borderColor: (t) => style.gray(t),
+    selectList: selectListTheme,
+};
+export const imageTheme = {
+    fallbackColor: (t) => style.gray(t),
+};

package/dist/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Reads the package version at runtime so --version, doctor, plugin metadata and MCP client
+ * metadata stay in sync with the published package without a build-time constant to update.
+ * The manifest is resolved relative to the module (`src/version.ts` → `../package.json` in the
+ * source tree; `dist/version.js` → `../package.json` of the installed package). Standalone
+ * binaries inject the version at build time via ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
+ */
+export declare function loadVersion(fromHere: string): string;

package/dist/version.js

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Fallback used when neither the build-time injection nor the package manifest is readable
+ * (e.g. an unpackaged embed). Keep it a development marker, never a publish literal, so it
+ * cannot silently desync from the published package.
+ */
+const FALLBACK = "dev";
+/**
+ * Reads the package version at runtime so --version, doctor, plugin metadata and MCP client
+ * metadata stay in sync with the published package without a build-time constant to update.
+ * The manifest is resolved relative to the module (`src/version.ts` → `../package.json` in the
+ * source tree; `dist/version.js` → `../package.json` of the installed package). Standalone
+ * binaries inject the version at build time via ALISIO_PACKAGE_VERSION (scripts/binary-build.ts).
+ */
+export function loadVersion(fromHere) {
+    if (process.env.ALISIO_PACKAGE_VERSION)
+        return process.env.ALISIO_PACKAGE_VERSION;
+    try {
+        const manifest = join(dirname(fileURLToPath(fromHere)), "..", "package.json");
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        return typeof parsed.version === "string" && parsed.version ? parsed.version : FALLBACK;
+    }
+    catch {
+        return FALLBACK;
+    }
+}