@vascend/talos 0.1.0

package/dist/tui/status-line.js

@@ -0,0 +1,213 @@
+import { tr } from "./i18n.js";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { formatCost, formatTokenCount } from "./cost-tracker.js";
+import { activeActivity } from "../vascend/activity-status.js";
+import { fitLine, oneLine, terminalWidth, wrapText } from "./terminal-text.js";
+// Modello, provider, workspace, branch e modalita' vivono nella testata fissa.
+// La riga inferiore resta una telemetria operativa e non ripete gli stessi dati.
+export const DEFAULT_ORDER = ["usage", "ctx", "cost", "bg", "improve", "regno"];
+// Glyph di spinner per le attivita' "vive" nella status line. La status line
+// si ridisegna a ogni frame dello spinner: ruotando in base al tempo si ottiene
+// un indicatore animato senza alcun timer dedicato.
+const SPIN = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+function spinGlyph() {
+    return SPIN[Math.floor(Date.now() / 90) % SPIN.length];
+}
+// Cronometro compatto mm:ss (o ss s) da un istante di inizio.
+function elapsed(since) {
+    const s = Math.max(0, Math.floor((Date.now() - since) / 1000));
+    if (s < 60)
+        return `${s}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m${String(s % 60).padStart(2, "0")}s`;
+}
+function visibleLength(value) {
+    return terminalWidth(value);
+}
+function shortModel(model) {
+    const slash = model.lastIndexOf("/");
+    return (slash >= 0 ? model.slice(slash + 1) : model).replace(/-\d{8}$/, "");
+}
+function fmtTokens(n) {
+    if (n >= 1_000_000) {
+        const v = n / 1_000_000;
+        return `${Number.isInteger(v) ? v : v.toFixed(1)}M`;
+    }
+    return n >= 1000 ? `${Math.round(n / 1000)}k` : `${n}`;
+}
+// Trova il ".git" piu' vicino RISALENDO dai parent: cosi' la status line mostra
+// il ramo del repo che CONTIENE il cwd anche quando si lavora in una sottodir,
+// e segue il progetto seguito (config.cwd) e non il path di lancio. Restituisce
+// il path del .git (dir o file) oppure null se nessun repo lo contiene.
+function findGitEntry(start) {
+    let cur = resolve(start);
+    for (;;) {
+        const g = join(cur, ".git");
+        if (existsSync(g))
+            return g;
+        const parent = dirname(cur);
+        if (parent === cur)
+            return null; // raggiunta la radice del filesystem
+        cur = parent;
+    }
+}
+// Branch git da .git/HEAD (nessun subprocess), con cache breve.
+let gitCache = null;
+function gitBranch(cwd) {
+    const now = Date.now();
+    if (gitCache && gitCache.cwd === cwd && now - gitCache.at < 4000)
+        return gitCache.branch;
+    let branch = null;
+    try {
+        const dir = findGitEntry(cwd);
+        if (dir) {
+            let headFile = join(dir, "HEAD");
+            if (!existsSync(headFile)) {
+                // ".git" e' un FILE (worktree/submodule): punta al gitdir reale.
+                const m = /gitdir:\s*(.+)/.exec(readFileSync(dir, "utf8"));
+                if (m && m[1])
+                    headFile = join(m[1].trim(), "HEAD");
+            }
+            if (existsSync(headFile)) {
+                const txt = readFileSync(headFile, "utf8").trim();
+                const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(txt);
+                branch = ref && ref[1] ? ref[1] : txt.slice(0, 7);
+            }
+        }
+    }
+    catch {
+        branch = null;
+    }
+    gitCache = { cwd, branch, at: now };
+    return branch;
+}
+// Registry dei segmenti built-in: id -> renderer.
+export const BUILTIN_SEGMENTS = {
+    model: (d, t) => t.accent("◇ ") + t.silver(shortModel(d.model)) + (d.fast ? t.accent(" fast") : ""),
+    provider: (d, t) => (d.provider ? t.muted(d.provider) : null),
+    dir: (d, t) => t.muted(basename(d.cwd) || d.cwd),
+    git: (d, t) => { const b = gitBranch(d.cwd); return b ? t.dark("⎇ ") + t.muted(b) : null; },
+    branch: (d, t) => BUILTIN_SEGMENTS["git"](d, t),
+    effort: (d, t) => (d.effort ? t.muted(`effort ${d.effort}`) : null),
+    vibe: (d, t) => (d.vibeMode ? t.accent("~ ") + t.muted(d.vibeMode) : null),
+    ctx: (d, t) => {
+        if (d.contextTokens === undefined || !d.contextWindow)
+            return null;
+        const pct = Math.round((d.contextTokens / d.contextWindow) * 100);
+        return t.muted(`ctx~ ${formatTokenCount(d.contextTokens)}/${fmtTokens(d.contextWindow)}`) + t.dark(` ${pct}%`);
+    },
+    regno: (d, t) => {
+        if (!d.regno || !d.regno.total)
+            return null;
+        const r = d.regno;
+        const head = r.castles > 1 ? `◆ ${r.castles} gruppi · ${r.done}/${r.total}` : `◆ ${r.done}/${r.total}`;
+        return t.silver(head) + t.dark(" Ctrl+G");
+    },
+    // Task shell in background (Ctrl+B): mostra quanti sono in esecuzione sul
+    // totale. Nascosto quando non ci sono task. Live: si aggiorna a ogni frame
+    // perche' StatusData.bg viene ricalcolato dal backgroundManager.
+    bg: (d, t) => {
+        const b = d.bg;
+        if (!b || !b.total)
+            return null;
+        const head = b.running > 0
+            ? t.accent("⚙ ") + t.silver(`${b.running}/${b.total} bg`)
+            : t.dark("⚙ ") + t.muted(`${b.total} bg`);
+        return head + t.dark(" /bg");
+    },
+    time: (_d, t) => {
+        const dt = new Date();
+        const hh = String(dt.getHours()).padStart(2, "0");
+        const mm = String(dt.getMinutes()).padStart(2, "0");
+        return t.dark(`${hh}:${mm}`);
+    },
+    // Costo accumulato di sessione (USD). Mostra il totale, e tra parentesi il
+    // costo del modello attualmente selezionato se differisce dal totale (cioe'
+    // sono stati usati piu' modelli).
+    cost: (d, t) => {
+        const c = d.cost;
+        if (!c || !c.anyPriced || c.totalCost <= 0)
+            return null;
+        const head = t.accent("$ ") + t.silver(formatCost(c.totalCost).slice(1));
+        const cur = c.current;
+        if (cur && cur.priced && c.perModel.length > 1 && cur.cost > 0) {
+            return head + t.dark(` (${formatCost(cur.cost)} cur)`);
+        }
+        return head;
+    },
+    // Indicatore di AUTO-MIGLIORAMENTO attivo. Compare SOLO quando un'attivita'
+    // "improve" e' viva (accesa dal tool self_improve_deep mentre esplora). Mostra
+    // uno spinner animato, l'etichetta e da quanto e' in corso. Sparisce a fine.
+    improve: (_d, t) => {
+        const a = activeActivity("improve");
+        if (!a)
+            return null;
+        const label = a.label || "auto-miglioramento";
+        const head = t.accent(spinGlyph() + " ") + t.silver(label);
+        return head + t.dark(` ${elapsed(a.since)}`);
+    },
+    // Token accumulati di sessione (input/output) su tutti i modelli.
+    usage: (d, t) => {
+        const c = d.cost;
+        if (!c || (c.totalPromptTokens === 0 && c.totalOutputTokens === 0))
+            return null;
+        const cache = c.totalCacheReadTokens + c.totalCacheWriteTokens;
+        let line = t.muted(`API nuovo ${formatTokenCount(c.totalInputTokens)}`);
+        if (cache > 0)
+            line += t.dark(` · cache ${formatTokenCount(cache)}`);
+        return line + t.dark(` · out ${formatTokenCount(c.totalOutputTokens)}`);
+    },
+};
+export function buildStatusLine(d, theme, opts = {}) {
+    // Override totale dall'estensione.
+    if (opts.render) {
+        const s = opts.render(d, theme);
+        return s == null ? "" : fitLine("  " + s, Math.max(0, d.width - 1));
+    }
+    const order = opts.order && opts.order.length ? opts.order : DEFAULT_ORDER;
+    const reg = { ...BUILTIN_SEGMENTS, ...(opts.custom ?? {}) };
+    const segs = order
+        .map((id) => { try {
+        return reg[id]?.(d, theme) ?? null;
+    }
+    catch {
+        return null;
+    } })
+        .filter((x) => Boolean(x));
+    if (!segs.length)
+        return "";
+    const sep = theme.dark("  ·  ");
+    // Se non entra, scarta dalla CODA (i segmenti meno importanti sono a destra),
+    // ma tieni sempre il primo.
+    const vis = [...segs];
+    while (vis.length > 1 && visibleLength("  " + vis.join(sep)) > d.width - 2)
+        vis.pop();
+    return fitLine("  " + vis.join(sep), Math.max(0, d.width - 1));
+}
+// Identita' e contesto su due righe; i permessi non vengono sacrificati
+// ai nomi lunghi. Modello ed effort restano nel footer operativo.
+export function buildTerminalHeader(d, theme) {
+    const width = Math.max(0, d.width - 3);
+    const project = oneLine(basename(d.cwd) || d.cwd);
+    const labels = {
+        normal: tr("Conferma azioni", "Ask before actions"),
+        acceptEdits: tr("Modifiche automatiche", "Automatic edits"),
+        auto: tr("Senza conferme", "No confirmations"),
+    };
+    const mode = labels[d.permissions ?? "normal"] ?? tr("Conferma azioni", "Ask before actions");
+    const brand = theme.accent(theme.bold("TALOS"));
+    const permission = d.permissions === "auto"
+        ? theme.yellow(mode) : theme.muted(mode);
+    const gap = width - terminalWidth("TALOS") - terminalWidth(mode);
+    const identity = gap >= 2 ? [brand + " ".repeat(gap) + permission] : [brand, permission];
+    const chat = d.sessionLabel ? `  ·  Chat: ${oneLine(d.sessionLabel)}` : "";
+    const context = theme.muted(tr("Progetto  ", "Project  ")) + theme.silver(project) + theme.muted(chat);
+    return [...identity, context].map((line) => "  " + fitLine(line, width));
+}
+export function buildTerminalWelcome(width, theme) {
+    const lines = [
+        { text: tr("Suggerimento: /help guida · /chats chat recenti", "Tip: /help commands · /chats recent chats"), paint: theme.muted },
+    ];
+    return "\n" + lines.flatMap(({ text, paint }) => wrapText(text, Math.max(2, width - 3), true).map((line) => "  " + paint(line))).join("\n") + "\n\n";
+}

package/dist/tui/system-language.d.ts

@@ -0,0 +1,8 @@
+import { type Language } from "./locales.js";
+interface SystemLanguageOptions {
+    readonly platform?: NodeJS.Platform;
+    readonly readNative?: () => readonly string[];
+    readonly intlLocale?: () => string;
+}
+export declare function systemLanguage(env: NodeJS.ProcessEnv, options?: SystemLanguageOptions): Language;
+export {};

package/dist/tui/system-language.js

@@ -0,0 +1,41 @@
+import { execFileSync } from "node:child_process";
+import { detectLanguage } from "./locales.js";
+// Read display-language preferences, not the Windows regional number/date
+// format. A bounded, hidden subprocess runs once at startup, never per frame.
+function nativeLanguages(platform) {
+    try {
+        if (platform === "win32") {
+            const script = "$override = Get-WinUILanguageOverride; if ($override) { $override.Name }; (Get-WinUserLanguageList).LanguageTag; (Get-UICulture).Name";
+            return execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { encoding: "utf8", timeout: 2000, windowsHide: true, stdio: ["ignore", "pipe", "ignore"] }).trim().split(/\s+/);
+        }
+        if (platform === "darwin") {
+            return execFileSync("defaults", ["read", "-g", "AppleLanguages"], { encoding: "utf8", timeout: 1500, stdio: ["ignore", "pipe", "ignore"] }).match(/[a-z]{2,3}(?:-[A-Za-z0-9]+)*/g) ?? [];
+        }
+    }
+    catch { /* Minimal shells and unavailable native APIs use the locale fallback. */ }
+    return [];
+}
+export function systemLanguage(env, options = {}) {
+    const explicit = env["LC_ALL"] || env["LC_MESSAGES"] || env["LANGUAGE"];
+    if (explicit)
+        return detectLanguage(explicit.split(":"));
+    const platform = options.platform ?? process.platform;
+    // Unix shells expose display language through LANG; Windows/macOS can
+    // distinguish it from regional formatting through their native preferences.
+    if (platform !== "win32" && platform !== "darwin" && env["LANG"])
+        return detectLanguage([env["LANG"]]);
+    try {
+        const native = (options.readNative ?? (() => nativeLanguages(platform)))().filter(value => value.trim());
+        if (native.length)
+            return detectLanguage(native);
+    }
+    catch { /* Fall through to the process locale. */ }
+    if (env["LANG"])
+        return detectLanguage([env["LANG"]]);
+    try {
+        return detectLanguage([(options.intlLocale ?? (() => Intl.DateTimeFormat().resolvedOptions().locale))()]);
+    }
+    catch {
+        return "en";
+    }
+}

package/dist/tui/task-labels.d.ts

@@ -0,0 +1,2 @@
+import type { VascendTaskStatus } from "../vascend/runtime.js";
+export declare const TASK_STATUS_LABELS: Readonly<Record<VascendTaskStatus, string>>;

package/dist/tui/task-labels.js

@@ -0,0 +1,7 @@
+import { tr } from "./i18n.js";
+export const TASK_STATUS_LABELS = {
+    get pending() { return tr("da fare", "pending"); },
+    get running() { return tr("in corso", "running"); },
+    get completed() { return tr("completata", "completed"); },
+    get failed() { return tr("fallita", "failed"); },
+};

package/dist/tui/term-bg.d.ts

@@ -0,0 +1,4 @@
+import type { ThemeMode } from "./theme.js";
+export declare function backgroundModeFromRgb(r: string, g: string, b: string): ThemeMode;
+export declare function parseOsc11(response: string): ThemeMode | null;
+export declare function queryBackgroundMode(timeoutMs?: number): Promise<ThemeMode | null>;

package/dist/tui/term-bg.js

@@ -0,0 +1,67 @@
+import { stdin, stdout } from "node:process";
+// Rilevamento del background reale del terminale via query OSC 11. Piu' preciso
+// dell'euristica su COLORFGBG/env: si chiede al terminale il colore di sfondo
+// (`ESC ] 11 ; ? BEL`) e si calcola la luminanza dalla risposta
+// (`ESC ] 11 ; rgb:RRRR/GGGG/BBBB`). Va chiamato quando nessun altro sta
+// leggendo stdin (es. all'avvio, prima dell'editor di input).
+// Luminanza relativa -> dark/light. I componenti possono essere a 2 o 4 cifre
+// esadecimali per canale; si usa il byte alto.
+export function backgroundModeFromRgb(r, g, b) {
+    const norm = (h) => parseInt(h.slice(0, 2).padEnd(2, h.slice(0, 1) || "0"), 16) / 255;
+    const lum = 0.2126 * norm(r) + 0.7152 * norm(g) + 0.0722 * norm(b);
+    return lum > 0.5 ? "light" : "dark";
+}
+export function parseOsc11(response) {
+    const m = /\x1b\]11;rgb:([0-9a-fA-F]+)\/([0-9a-fA-F]+)\/([0-9a-fA-F]+)/.exec(response);
+    if (!m)
+        return null;
+    return backgroundModeFromRgb(m[1] ?? "0", m[2] ?? "0", m[3] ?? "0");
+}
+// Interroga il terminale e ritorna dark/light, o null se non TTY / nessuna
+// risposta entro il timeout (terminale che non supporta OSC 11).
+export function queryBackgroundMode(timeoutMs = 200) {
+    if (!stdout.isTTY || !stdin.isTTY || typeof stdin.setRawMode !== "function") {
+        return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+        const wasRaw = stdin.isRaw;
+        const wasPaused = stdin.isPaused();
+        let buf = "";
+        let done = false;
+        const cleanup = () => {
+            clearTimeout(timer);
+            stdin.off("data", onData);
+            try {
+                stdin.setRawMode(Boolean(wasRaw));
+            }
+            catch {
+                // best effort
+            }
+            if (wasPaused)
+                stdin.pause();
+        };
+        const finish = (mode) => {
+            if (done)
+                return;
+            done = true;
+            cleanup();
+            resolve(mode);
+        };
+        const onData = (chunk) => {
+            buf += chunk.toString("latin1");
+            const mode = parseOsc11(buf);
+            if (mode)
+                finish(mode);
+        };
+        const timer = setTimeout(() => finish(null), timeoutMs);
+        try {
+            stdin.setRawMode(true);
+        }
+        catch {
+            // best effort
+        }
+        stdin.resume();
+        stdin.on("data", onData);
+        stdout.write("\x1b]11;?\x07");
+    });
+}

package/dist/tui/terminal-screen.d.ts

@@ -0,0 +1,12 @@
+export interface ScreenKey {
+    readonly name?: string;
+    readonly ctrl?: boolean;
+    readonly meta?: boolean;
+    readonly shift?: boolean;
+}
+export interface TerminalScreen {
+    render(width: number, height: number): readonly string[];
+    key(text: string, key: ScreenKey): "close" | void;
+    scroll(delta: number): void;
+    paste?(text: string): void;
+}

package/dist/tui/terminal-screen.js

@@ -0,0 +1 @@
+export {};

package/dist/tui/terminal-text.d.ts

@@ -0,0 +1,7 @@
+export declare function plainText(value: string): string;
+export declare function terminalWidth(value: string): number;
+export declare function exceedsTerminalWidth(value: string, width: number): boolean;
+export declare function fitLine(value: string, width: number, ellipsis?: boolean): string;
+export declare function padLine(value: string, width: number): string;
+export declare function wrapText(value: string, width: number, wordWrap?: boolean): string[];
+export declare function oneLine(value: string): string;

package/dist/tui/terminal-text.js

@@ -0,0 +1,123 @@
+import { stripVTControlCharacters } from "node:util";
+// Misure in celle, condivise dai pannelli. Il testo dei tool non puo' inviare
+// comandi al terminale; colori e collegamenti sono aggiunti solo dal renderer.
+export function plainText(value) {
+    return stripVTControlCharacters(value).replace(/\r\n?/g, "\n")
+        .replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, "").replace(/\t/g, "    ");
+}
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+const printableAscii = /^[\x20-\x7e]*$/;
+const ansi = /\x1b\[[0-9;]*m|\x1b\][\s\S]*?(?:\x07|\x1b\\)/g;
+function cellWidth(s) {
+    const cp = s.codePointAt(0) ?? 0;
+    if (/^[\p{Mark}\p{Cf}]+$/u.test(s) || cp < 32)
+        return 0;
+    if (/\p{Extended_Pictographic}|\p{Regional_Indicator}/u.test(s))
+        return 2;
+    return cp >= 0x1100 && (cp <= 0x115f || cp === 0x2329 || cp === 0x232a ||
+        (cp >= 0x2e80 && cp <= 0xa4cf && cp !== 0x303f) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe10 && cp <= 0xfe19) || (cp >= 0xfe30 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) || (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x20000 && cp <= 0x3fffd)) ? 2 : 1;
+}
+export function terminalWidth(value) {
+    const clean = plainText(value);
+    if (printableAscii.test(clean))
+        return clean.length;
+    let width = 0;
+    for (const { segment } of graphemes.segment(clean))
+        width += cellWidth(segment);
+    return width;
+}
+// Le anteprime devono fermare la segmentazione appena superano il viewport,
+// non misurare anche megabyte di contenuto che non saranno visualizzati.
+export function exceedsTerminalWidth(value, width) {
+    const clean = plainText(value);
+    if (printableAscii.test(clean))
+        return clean.length > 0 && clean.length > width;
+    let used = 0;
+    for (const { segment } of graphemes.segment(clean)) {
+        used += cellWidth(segment);
+        if (used > width)
+            return true;
+    }
+    return false;
+}
+export function fitLine(value, width, ellipsis = true) {
+    const max = Math.max(0, Math.floor(width));
+    if (!max)
+        return "";
+    if (printableAscii.test(value)) {
+        if (value.length <= max)
+            return value;
+        return value.slice(0, Math.max(0, max - (ellipsis ? 1 : 0)))
+            + (ellipsis ? "…" : "") + "\x1b[0m\x1b]8;;\x1b\\";
+    }
+    if (!exceedsTerminalWidth(value, max))
+        return value;
+    const limit = Math.max(0, max - (ellipsis ? 1 : 0));
+    let used = 0;
+    let out = "";
+    // SGR e OSC sono atomici: non spezzare una sequenza a meta'.
+    const parts = value.split(new RegExp(`(${ansi.source})`, "g"));
+    outer: for (const part of parts) {
+        if (part.startsWith("\x1b")) {
+            out += part;
+            continue;
+        }
+        for (const { segment } of graphemes.segment(part)) {
+            const size = cellWidth(segment);
+            if (used + size > limit)
+                break outer;
+            out += segment;
+            used += size;
+        }
+    }
+    return out + (ellipsis ? "…" : "") + "\x1b[0m\x1b]8;;\x1b\\";
+}
+export function padLine(value, width) {
+    const fitted = fitLine(value, width);
+    return fitted + " ".repeat(Math.max(0, width - terminalWidth(fitted)));
+}
+export function wrapText(value, width, wordWrap = false) {
+    const max = Math.max(2, width);
+    const lines = [];
+    for (const line of plainText(value).split("\n")) {
+        if (!wordWrap && printableAscii.test(line)) {
+            const chunk = Math.max(1, Math.floor(max));
+            if (!line.length)
+                lines.push("");
+            for (let i = 0; i < line.length; i += chunk)
+                lines.push(line.slice(i, i + chunk));
+            continue;
+        }
+        let row = "";
+        let used = 0;
+        for (const { segment } of graphemes.segment(line)) {
+            const size = cellWidth(segment);
+            if (used + size > max) {
+                const split = wordWrap ? row.lastIndexOf(" ") : -1;
+                if (split > 0 && terminalWidth(row.slice(split + 1) + segment) <= max) {
+                    lines.push(row.slice(0, split).trimEnd());
+                    row = row.slice(split + 1);
+                    used = terminalWidth(row);
+                }
+                else {
+                    lines.push(row);
+                    row = "";
+                    used = 0;
+                }
+                if (wordWrap && !row && segment === " ")
+                    continue;
+            }
+            row += segment;
+            used += size;
+        }
+        lines.push(row);
+    }
+    return lines;
+}
+export function oneLine(value) {
+    return plainText(value).replace(/\s+/g, " ").trim();
+}

package/dist/tui/theme.d.ts

@@ -0,0 +1,25 @@
+export declare const THEME_TOKENS: readonly ["accent", "border", "borderAccent", "borderMuted", "success", "error", "warning", "muted", "dim", "text", "thinkingText", "selectedBg", "userMessageBg", "userMessageText", "attachmentRef", "customMessageBg", "customMessageText", "customMessageLabel", "toolPendingBg", "toolSuccessBg", "toolErrorBg", "toolTitle", "toolOutput", "mdHeading", "mdLink", "mdLinkUrl", "mdCode", "mdCodeBlock", "mdCodeBlockBorder", "mdQuote", "mdQuoteBorder", "mdHr", "mdListBullet", "toolDiffAdded", "toolDiffAddedBg", "toolDiffRemoved", "toolDiffRemovedBg", "toolDiffContext", "toolDiffContextBg", "toolDiffHeaderBg", "toolDiffBorder", "syntaxComment", "syntaxKeyword", "syntaxFunction", "syntaxVariable", "syntaxString", "syntaxNumber", "syntaxType", "syntaxOperator", "syntaxPunctuation", "thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh", "thinkingXhigh", "bashMode"];
+export type ThemeToken = (typeof THEME_TOKENS)[number];
+export type ThemeMode = "dark" | "light";
+export interface ThemeSpec {
+    readonly name: string;
+    readonly mode: ThemeMode;
+    readonly vars: Readonly<Record<string, string | number>>;
+    readonly colors: Readonly<Record<ThemeToken, string | number>>;
+}
+export declare const VASCEND_DARK: ThemeSpec;
+export declare const VASCEND_LIGHT: ThemeSpec;
+export declare const VASCEND_LIME: ThemeSpec;
+export declare const BUILTIN_THEMES: readonly ThemeSpec[];
+export declare function ansiFor(spec: ThemeSpec, value: string | number, background?: boolean): string;
+export declare function tokenAnsi(spec: ThemeSpec, token: ThemeToken, background?: boolean): string;
+export declare function painter(spec: ThemeSpec): (token: ThemeToken, s: string, background?: boolean) => string;
+export declare function parseThemeFile(path: string): ThemeSpec | null;
+export interface LoadedThemes {
+    readonly themes: readonly ThemeSpec[];
+    readonly paths: Readonly<Record<string, string>>;
+}
+export declare function loadThemes(cwd: string, env: NodeJS.ProcessEnv, projectTrusted?: boolean, extraDirs?: readonly string[]): LoadedThemes;
+export declare function findTheme(themes: readonly ThemeSpec[], name: string): ThemeSpec | undefined;
+export declare function detectTerminalMode(env: NodeJS.ProcessEnv): ThemeMode;
+export declare function defaultThemeName(env: NodeJS.ProcessEnv): string;