@voybio/ace-swarm 0.1.0

package/dist/tui/provider-discovery.js

@@ -0,0 +1,530 @@
+/**
+ * ACE-TUI Provider Discovery
+ *
+ * Resolves provider/model defaults without mutating system files.
+ * Sources:
+ * - CLI hints
+ * - workspace .ace/llm-profile.json
+ * - workspace .vscode/settings.json
+ * - VS Code user settings.json (platform defaults)
+ * - environment overrides
+ *
+ * Async runtime scanning is exposed separately so `ace doctor --scan` can probe
+ * common local endpoints instead of assuming a hardcoded Ollama host.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { readStoreJsonSync } from "../store/store-snapshot.js";
+export const DEFAULT_OLLAMA_MODEL = "llama3.1:8b";
+export const DEFAULT_LLAMA_CPP_MODEL = "local-model";
+const LOCAL_RUNTIME_PROVIDER_PREFERENCE = ["ollama", "llama.cpp"];
+const PROVIDER_PREFERENCE = [
+    ...LOCAL_RUNTIME_PROVIDER_PREFERENCE,
+    "codex",
+    "gemini",
+    "claude",
+    "copilot",
+];
+const DEFAULT_LOCAL_SCAN_TARGETS = {
+    ollama: ["http://127.0.0.1:11434", "http://localhost:11434"],
+    "llama.cpp": ["http://127.0.0.1:8080", "http://localhost:8080"],
+};
+export function normalizeProvider(input) {
+    if (!input)
+        return undefined;
+    const normalized = input.trim().toLowerCase();
+    if (!normalized)
+        return undefined;
+    if (normalized === "openai")
+        return "codex";
+    if (normalized === "anthropic")
+        return "claude";
+    if (normalized === "google")
+        return "gemini";
+    if (["llamacpp", "llama-cpp", "llama.cpp"].includes(normalized))
+        return "llama.cpp";
+    return normalized;
+}
+export function normalizeLocalBaseUrl(url) {
+    if (!url)
+        return undefined;
+    const trimmed = url.trim();
+    if (!trimmed)
+        return undefined;
+    const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `http://${trimmed}`;
+    return withScheme.endsWith("/") ? withScheme.slice(0, -1) : withScheme;
+}
+export function buildOpenAiCompatibleBaseUrl(baseUrl) {
+    const normalized = normalizeLocalBaseUrl(baseUrl) ?? baseUrl.trim();
+    return normalized.endsWith("/v1") ? normalized : `${normalized}/v1`;
+}
+export function inferProviderFromModel(model) {
+    if (!model)
+        return undefined;
+    const value = model.trim().toLowerCase();
+    if (!value)
+        return undefined;
+    if (value.startsWith("llama.cpp/") || value.startsWith("llamacpp/")) {
+        return "llama.cpp";
+    }
+    if (value.startsWith("ollama/") ||
+        value.includes("llama") ||
+        value.includes("qwen") ||
+        value.includes("mistral") ||
+        value.includes("deepseek") ||
+        value.includes("phi") ||
+        value.includes(":") ||
+        value.includes("mixtral")) {
+        return "ollama";
+    }
+    if (value.startsWith("copilot/")) {
+        return "copilot";
+    }
+    if (value.includes("claude"))
+        return "claude";
+    if (value.includes("gemini"))
+        return "gemini";
+    if (value.includes("gpt") ||
+        value.includes("codex") ||
+        value.startsWith("o1") ||
+        value.startsWith("o3") ||
+        value.startsWith("o4") ||
+        value.startsWith("o5")) {
+        return "codex";
+    }
+    return undefined;
+}
+function defaultModelForProvider(provider) {
+    if (provider === "ollama")
+        return DEFAULT_OLLAMA_MODEL;
+    if (provider === "llama.cpp")
+        return DEFAULT_LLAMA_CPP_MODEL;
+    return `${provider}/default`;
+}
+function looksLikeModel(value) {
+    const v = value.trim().toLowerCase();
+    if (!v)
+        return false;
+    return (v.includes("gpt") ||
+        v.includes("claude") ||
+        v.includes("gemini") ||
+        v.includes("llama") ||
+        v.includes("qwen") ||
+        v.includes("mistral") ||
+        v.includes("deepseek") ||
+        v.includes("codex") ||
+        v.startsWith("copilot/") ||
+        v.includes(":"));
+}
+export function parseJsoncLoose(raw) {
+    let out = "";
+    let inString = false;
+    let escape = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < raw.length; i += 1) {
+        const ch = raw[i];
+        const next = raw[i + 1] ?? "";
+        if (inLineComment) {
+            if (ch === "\n") {
+                inLineComment = false;
+                out += ch;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === "*" && next === "/") {
+                inBlockComment = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            out += ch;
+            if (escape) {
+                escape = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escape = true;
+                continue;
+            }
+            if (ch === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === "\"") {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === "/" && next === "/") {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+        if (ch === "/" && next === "*") {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+        out += ch;
+    }
+    return JSON.parse(out.replace(/,\s*([}\]])/g, "$1"));
+}
+function readJsoncFile(path) {
+    const raw = readFileSync(path, "utf-8");
+    return parseJsoncLoose(raw);
+}
+function readProfile(workspaceRoot) {
+    const storeProfile = readStoreJsonSync(workspaceRoot, "state/runtime/llm_profile") ??
+        readStoreJsonSync(workspaceRoot, "state/runtime/llm-profile");
+    if (storeProfile && typeof storeProfile === "object") {
+        return storeProfile;
+    }
+    const canonicalProfilePath = resolve(workspaceRoot, ".agents", "ACE", ".ace", "llm-profile.json");
+    const legacyProfilePath = resolve(workspaceRoot, ".ace", "llm-profile.json");
+    const profilePath = existsSync(canonicalProfilePath) ? canonicalProfilePath : legacyProfilePath;
+    if (!existsSync(profilePath))
+        return undefined;
+    try {
+        const raw = readFileSync(profilePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function defaultVsCodeUserSettingsPaths() {
+    const home = homedir();
+    return [
+        join(home, "Library", "Application Support", "Code", "User", "settings.json"),
+        join(home, ".config", "Code", "User", "settings.json"),
+        join(home, "AppData", "Roaming", "Code", "User", "settings.json"),
+    ];
+}
+function collectHintsFromSettings(value, source) {
+    const found = [];
+    const visit = (node, keyHint = "") => {
+        if (typeof node === "string") {
+            const provider = normalizeProvider(node);
+            if (provider &&
+                [
+                    "ollama",
+                    "llama.cpp",
+                    "copilot",
+                    "codex",
+                    "claude",
+                    "gemini",
+                    "openai",
+                    "anthropic",
+                    "google",
+                ].includes(provider)) {
+                found.push({ source, provider });
+            }
+            if (looksLikeModel(node)) {
+                found.push({ source, model: node, provider: inferProviderFromModel(node) });
+            }
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node) {
+                if (typeof item === "string") {
+                    if (looksLikeModel(item) || keyHint.toLowerCase().includes("model")) {
+                        found.push({ source, model: item, provider: inferProviderFromModel(item) });
+                    }
+                }
+                else {
+                    visit(item, keyHint);
+                }
+            }
+            return;
+        }
+        if (!node || typeof node !== "object")
+            return;
+        for (const [key, child] of Object.entries(node)) {
+            const lowerKey = key.toLowerCase();
+            if (lowerKey.includes("provider") && typeof child === "string") {
+                found.push({ source, provider: normalizeProvider(child) });
+            }
+            if (lowerKey.includes("model") || lowerKey.includes("allowedmodels")) {
+                if (typeof child === "string" && looksLikeModel(child)) {
+                    found.push({ source, model: child, provider: inferProviderFromModel(child) });
+                }
+                if (Array.isArray(child)) {
+                    for (const item of child) {
+                        if (typeof item === "string" && looksLikeModel(item)) {
+                            found.push({ source, model: item, provider: inferProviderFromModel(item) });
+                        }
+                    }
+                }
+            }
+            visit(child, lowerKey);
+        }
+    };
+    visit(value);
+    return found;
+}
+function sortProviders(providers) {
+    const unique = [...new Set(providers.map((p) => p.trim().toLowerCase()).filter(Boolean))];
+    return unique.sort((a, b) => {
+        const ia = PROVIDER_PREFERENCE.indexOf(a);
+        const ib = PROVIDER_PREFERENCE.indexOf(b);
+        const sa = ia === -1 ? Number.MAX_SAFE_INTEGER : ia;
+        const sb = ib === -1 ? Number.MAX_SAFE_INTEGER : ib;
+        if (sa !== sb)
+            return sa - sb;
+        return a.localeCompare(b);
+    });
+}
+function addModel(modelsByProvider, provider, model) {
+    const trimmedModel = model?.trim();
+    if (!trimmedModel)
+        return;
+    const resolvedProvider = normalizeProvider(provider) ?? inferProviderFromModel(trimmedModel) ?? "ollama";
+    if (!modelsByProvider.has(resolvedProvider)) {
+        modelsByProvider.set(resolvedProvider, new Set());
+    }
+    modelsByProvider.get(resolvedProvider)?.add(trimmedModel);
+}
+function readSettingsCandidates(workspaceRoot) {
+    const candidates = [];
+    const paths = [resolve(workspaceRoot, ".vscode", "settings.json"), ...defaultVsCodeUserSettingsPaths()];
+    for (const path of paths) {
+        if (!existsSync(path))
+            continue;
+        try {
+            candidates.push(...collectHintsFromSettings(readJsoncFile(path), path));
+        }
+        catch {
+            // Ignore malformed or locked settings files.
+        }
+    }
+    return candidates;
+}
+function setProviderBaseUrl(target, provider, baseUrl) {
+    const normalizedProvider = normalizeProvider(provider);
+    const normalizedBaseUrl = normalizeLocalBaseUrl(baseUrl);
+    if (!normalizedProvider || !normalizedBaseUrl)
+        return;
+    target.set(normalizedProvider, normalizedBaseUrl);
+}
+export function discoverProviderContext(options) {
+    const notes = [];
+    const modelsByProvider = new Map();
+    const providerBaseUrls = new Map();
+    const profile = readProfile(options.workspaceRoot);
+    const profileProvider = normalizeProvider(profile?.provider);
+    const profileModel = profile?.model?.trim() || undefined;
+    const profileBaseUrl = normalizeLocalBaseUrl(profile?.base_url);
+    const envProvider = normalizeProvider(process.env.ACE_TUI_PROVIDER ?? process.env.ACE_LLM_PROVIDER ?? process.env.LLM_PROVIDER);
+    const envModel = process.env.ACE_TUI_MODEL?.trim() ||
+        process.env.ACE_MODEL?.trim() ||
+        process.env.LLM_MODEL?.trim() ||
+        undefined;
+    const envGenericBaseUrl = normalizeLocalBaseUrl(process.env.ACE_TUI_BASE_URL ?? process.env.ACE_LLM_BASE_URL ?? process.env.LLM_BASE_URL);
+    const cliProvider = normalizeProvider(options.cliProvider);
+    const cliModel = options.cliModel?.trim() || undefined;
+    const cliBaseUrl = normalizeLocalBaseUrl(options.cliBaseUrl ?? options.cliOllamaUrl);
+    setProviderBaseUrl(providerBaseUrls, "ollama", options.cliOllamaUrl ?? process.env.ACE_TUI_OLLAMA_URL ?? process.env.OLLAMA_HOST);
+    setProviderBaseUrl(providerBaseUrls, "llama.cpp", process.env.LLAMA_CPP_BASE_URL ?? process.env.LLAMACPP_BASE_URL);
+    addModel(modelsByProvider, profileProvider, profileModel);
+    addModel(modelsByProvider, envProvider, envModel);
+    addModel(modelsByProvider, cliProvider, cliModel);
+    const settingHints = readSettingsCandidates(options.workspaceRoot);
+    for (const hint of settingHints) {
+        if (hint.model)
+            addModel(modelsByProvider, hint.provider, hint.model);
+    }
+    const providerHints = [
+        ...settingHints
+            .map((hint) => normalizeProvider(hint.provider))
+            .filter(Boolean),
+        profileProvider,
+        envProvider,
+        cliProvider,
+    ].filter(Boolean);
+    let provider = cliProvider ?? envProvider ?? profileProvider;
+    if (!provider) {
+        provider =
+            inferProviderFromModel(cliModel) ??
+                inferProviderFromModel(envModel) ??
+                inferProviderFromModel(profileModel);
+    }
+    if (!provider) {
+        provider = "ollama";
+        if (settingHints.length > 0) {
+            notes.push("runtime_default=ollama (VS Code model hints are discovery-only)");
+        }
+    }
+    setProviderBaseUrl(providerBaseUrls, profileProvider, profileBaseUrl);
+    setProviderBaseUrl(providerBaseUrls, envProvider, envGenericBaseUrl);
+    setProviderBaseUrl(providerBaseUrls, cliProvider, cliBaseUrl);
+    if (!providerBaseUrls.has(provider) && cliBaseUrl) {
+        providerBaseUrls.set(provider, cliBaseUrl);
+    }
+    if (!providerBaseUrls.has(provider) && envGenericBaseUrl) {
+        providerBaseUrls.set(provider, envGenericBaseUrl);
+    }
+    if (!providerBaseUrls.has(provider) && profileBaseUrl && profileProvider === provider) {
+        providerBaseUrls.set(provider, profileBaseUrl);
+    }
+    if (!modelsByProvider.has(provider)) {
+        modelsByProvider.set(provider, new Set());
+    }
+    let model = cliModel ?? envModel ?? profileModel;
+    if (!model) {
+        const providerModels = [...(modelsByProvider.get(provider) ?? [])];
+        if (providerModels.length > 0) {
+            model = providerModels[0];
+        }
+    }
+    if (!model) {
+        model = defaultModelForProvider(provider);
+    }
+    addModel(modelsByProvider, provider, model);
+    const allProviders = sortProviders([
+        ...modelsByProvider.keys(),
+        ...providerHints,
+        ...providerBaseUrls.keys(),
+        provider,
+    ]);
+    const modelsByProviderObj = {};
+    for (const candidateProvider of allProviders) {
+        modelsByProviderObj[candidateProvider] = [...(modelsByProvider.get(candidateProvider) ?? [])].sort((a, b) => a.localeCompare(b));
+    }
+    const baseUrl = providerBaseUrls.get(provider);
+    const ollamaUrl = providerBaseUrls.get("ollama");
+    notes.push(`provider=${provider}`);
+    notes.push(`model=${model}`);
+    notes.push(`providers_detected=${allProviders.join(",")}`);
+    notes.push(`base_url=${baseUrl ?? "unconfigured"}`);
+    return {
+        provider,
+        model,
+        baseUrl,
+        ollamaUrl,
+        providerBaseUrls: Object.fromEntries(providerBaseUrls.entries()),
+        providers: allProviders,
+        modelsByProvider: modelsByProviderObj,
+        notes,
+    };
+}
+async function fetchJson(url, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            method: "GET",
+            headers: { Accept: "application/json" },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        return await response.json();
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function probeOllama(baseUrl, timeoutMs) {
+    const payload = (await fetchJson(`${baseUrl}/api/tags`, timeoutMs));
+    const models = Array.isArray(payload.models)
+        ? payload.models
+            .map((entry) => entry?.name?.trim())
+            .filter((name) => Boolean(name))
+        : [];
+    return {
+        provider: "ollama",
+        baseUrl,
+        apiBaseUrl: buildOpenAiCompatibleBaseUrl(baseUrl),
+        models,
+        source: "probe",
+        notes: [`ollama_models=${models.length}`],
+    };
+}
+async function probeLlamaCpp(baseUrl, timeoutMs) {
+    const apiBaseUrl = buildOpenAiCompatibleBaseUrl(baseUrl);
+    const payload = (await fetchJson(`${apiBaseUrl}/models`, timeoutMs));
+    const models = Array.isArray(payload.data)
+        ? payload.data
+            .map((entry) => entry?.id?.trim())
+            .filter((name) => Boolean(name))
+        : [];
+    return {
+        provider: "llama.cpp",
+        baseUrl,
+        apiBaseUrl,
+        models,
+        source: "probe",
+        notes: [`llama_cpp_models=${models.length}`],
+    };
+}
+function buildScanAttempts(options) {
+    const attempts = [];
+    const seen = new Set();
+    const preferredProvider = normalizeProvider(options.preferredProvider);
+    const profile = options.workspaceRoot ? readProfile(options.workspaceRoot) : undefined;
+    const profileProvider = normalizeProvider(profile?.provider);
+    const profileBaseUrl = normalizeLocalBaseUrl(profile?.base_url);
+    const addAttempt = (provider, baseUrl, source) => {
+        const normalizedProvider = normalizeProvider(provider);
+        const normalizedBaseUrl = normalizeLocalBaseUrl(baseUrl);
+        if (!normalizedProvider || !normalizedBaseUrl)
+            return;
+        const key = `${normalizedProvider}:${normalizedBaseUrl}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        attempts.push({ provider: normalizedProvider, baseUrl: normalizedBaseUrl, source });
+    };
+    const explicitBaseUrl = normalizeLocalBaseUrl(options.explicitBaseUrl);
+    if (explicitBaseUrl) {
+        const providers = preferredProvider ? [preferredProvider] : [...LOCAL_RUNTIME_PROVIDER_PREFERENCE];
+        for (const provider of providers) {
+            addAttempt(provider, explicitBaseUrl, "explicit_base_url");
+        }
+    }
+    addAttempt(profileProvider ?? preferredProvider ?? undefined, profileBaseUrl, "workspace_profile");
+    addAttempt("ollama", process.env.ACE_TUI_OLLAMA_URL, "ACE_TUI_OLLAMA_URL");
+    addAttempt("ollama", process.env.OLLAMA_HOST, "OLLAMA_HOST");
+    addAttempt("llama.cpp", process.env.LLAMA_CPP_BASE_URL, "LLAMA_CPP_BASE_URL");
+    addAttempt("llama.cpp", process.env.LLAMACPP_BASE_URL, "LLAMACPP_BASE_URL");
+    const providers = preferredProvider && LOCAL_RUNTIME_PROVIDER_PREFERENCE.includes(preferredProvider)
+        ? [preferredProvider]
+        : [...LOCAL_RUNTIME_PROVIDER_PREFERENCE];
+    for (const provider of providers) {
+        for (const baseUrl of DEFAULT_LOCAL_SCAN_TARGETS[provider]) {
+            addAttempt(provider, baseUrl, "default_scan_target");
+        }
+    }
+    return attempts;
+}
+export async function scanLocalModelRuntimes(options = {}) {
+    const timeoutMs = options.timeoutMs ?? 1500;
+    const notes = [];
+    const candidates = [];
+    for (const attempt of buildScanAttempts(options)) {
+        try {
+            const candidate = attempt.provider === "ollama"
+                ? await probeOllama(attempt.baseUrl, timeoutMs)
+                : await probeLlamaCpp(attempt.baseUrl, timeoutMs);
+            if (!candidate)
+                continue;
+            candidates.push({
+                ...candidate,
+                source: attempt.source,
+            });
+            notes.push(`scan_hit:${attempt.provider}:${attempt.baseUrl}`);
+        }
+        catch (error) {
+            notes.push(`scan_miss:${attempt.provider}:${attempt.baseUrl}:${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { candidates, notes };
+}
+//# sourceMappingURL=provider-discovery.js.map

package/dist/tui/renderer.d.ts

@@ -0,0 +1,166 @@
+/**
+ * ACE-TUI ANSI Renderer
+ *
+ * Direct terminal rendering via ANSI escape sequences.
+ * Zero dependencies — uses process.stdout.write() exclusively.
+ * Inspired by arttime's rendering approach.
+ */
+/** Cursor movement */
+export declare const cursor: {
+    readonly to: (x: number, y: number) => string;
+    readonly up: (n?: number) => string;
+    readonly down: (n?: number) => string;
+    readonly right: (n?: number) => string;
+    readonly left: (n?: number) => string;
+    readonly hide: "\u001B[?25l";
+    readonly show: "\u001B[?25h";
+    readonly save: "\u001B7";
+    readonly restore: "\u001B8";
+    readonly home: "\u001B[H";
+};
+/** Screen operations */
+export declare const screen: {
+    readonly clear: "\u001B[2J";
+    readonly clearLine: "\u001B[2K";
+    readonly clearDown: "\u001B[J";
+    readonly clearRight: "\u001B[K";
+    readonly altBuffer: "\u001B[?1049h";
+    readonly mainBuffer: "\u001B[?1049l";
+    readonly enableMouse: "\u001B[?1003h\u001B[?1006h";
+    readonly disableMouse: "\u001B[?1003l\u001B[?1006l";
+};
+/** Style codes */
+export declare const style: {
+    readonly reset: "\u001B[0m";
+    readonly bold: "\u001B[1m";
+    readonly dim: "\u001B[2m";
+    readonly italic: "\u001B[3m";
+    readonly underline: "\u001B[4m";
+    readonly inverse: "\u001B[7m";
+    readonly strikethrough: "\u001B[9m";
+};
+export type ColorLevel = "none" | "basic" | "256" | "truecolor";
+export declare function detectColorLevel(): ColorLevel;
+/** 16-color CGA foreground */
+export declare const fg: {
+    readonly black: "\u001B[30m";
+    readonly red: "\u001B[31m";
+    readonly green: "\u001B[32m";
+    readonly yellow: "\u001B[33m";
+    readonly blue: "\u001B[34m";
+    readonly magenta: "\u001B[35m";
+    readonly cyan: "\u001B[36m";
+    readonly white: "\u001B[37m";
+    readonly gray: "\u001B[90m";
+    readonly brightRed: "\u001B[91m";
+    readonly brightGreen: "\u001B[92m";
+    readonly brightYellow: "\u001B[93m";
+    readonly brightBlue: "\u001B[94m";
+    readonly brightMagenta: "\u001B[95m";
+    readonly brightCyan: "\u001B[96m";
+    readonly brightWhite: "\u001B[97m";
+};
+/** 16-color CGA background */
+export declare const bg: {
+    readonly black: "\u001B[40m";
+    readonly red: "\u001B[41m";
+    readonly green: "\u001B[42m";
+    readonly yellow: "\u001B[43m";
+    readonly blue: "\u001B[44m";
+    readonly magenta: "\u001B[45m";
+    readonly cyan: "\u001B[46m";
+    readonly white: "\u001B[47m";
+    readonly gray: "\u001B[100m";
+    readonly brightBlue: "\u001B[104m";
+    readonly brightCyan: "\u001B[106m";
+};
+/** 256-color codes */
+export declare function fg256(n: number): string;
+export declare function bg256(n: number): string;
+/** 24-bit RGB colors */
+export declare function fgRgb(r: number, g: number, b: number): string;
+export declare function bgRgb(r: number, g: number, b: number): string;
+export declare const box: {
+    readonly topLeft: "┌";
+    readonly topRight: "┐";
+    readonly bottomLeft: "└";
+    readonly bottomRight: "┘";
+    readonly horizontal: "─";
+    readonly vertical: "│";
+    readonly teeRight: "├";
+    readonly teeLeft: "┤";
+    readonly teeDown: "┬";
+    readonly teeUp: "┴";
+    readonly cross: "┼";
+    readonly heavyHorizontal: "━";
+    readonly heavyVertical: "┃";
+    readonly roundTopLeft: "╭";
+    readonly roundTopRight: "╮";
+    readonly roundBottomLeft: "╰";
+    readonly roundBottomRight: "╯";
+};
+export declare const symbols: {
+    readonly check: "✓";
+    readonly cross: "✗";
+    readonly bullet: "●";
+    readonly hollowBullet: "○";
+    readonly arrow: "→";
+    readonly arrowLeft: "←";
+    readonly arrowUp: "↑";
+    readonly arrowDown: "↓";
+    readonly spinner: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    readonly progress: {
+        readonly filled: "█";
+        readonly partial: "▓";
+        readonly empty: "░";
+    };
+    readonly tab: "▎";
+    readonly activeTab: "▌";
+};
+/** Strip ANSI escape codes from a string (arttime: sed -e 's/\x1b\[[0-9;]*m//g') */
+export declare function stripAnsi(text: string): string;
+/** Get visible width of a string (ANSI-aware) */
+export declare function visibleWidth(text: string): number;
+/** Truncate text to fit width, add ellipsis if needed */
+export declare function truncate(text: string, maxWidth: number): string;
+/** Pad text to exact width (ANSI-aware) */
+export declare function padRight(text: string, width: number): string;
+/** Center text in width (ANSI-aware, arttime centering math) */
+export declare function center(text: string, width: number): string;
+/** Write raw string to stdout */
+export declare function write(s: string): void;
+/** Write at specific position */
+export declare function writeAt(x: number, y: number, text: string): void;
+/** Draw a horizontal line */
+export declare function hline(x: number, y: number, width: number, char?: "─"): void;
+/** Draw a vertical line */
+export declare function vline(x: number, y: number, height: number, char?: "│"): void;
+/** Draw a box with optional title */
+export declare function drawBox(x: number, y: number, width: number, height: number, opts?: {
+    title?: string;
+    titleColor?: string;
+    borderColor?: string;
+    rounded?: boolean;
+}): void;
+/** Fill a rectangular region with spaces (clear region) */
+export declare function clearRegion(x: number, y: number, width: number, height: number): void;
+/** Draw a progress bar (arttime-inspired) */
+export declare function progressBar(x: number, y: number, width: number, ratio: number, opts?: {
+    filledColor?: string;
+    emptyColor?: string;
+    showPercent?: boolean;
+}): void;
+/** Draw a spinner frame */
+export declare function spinnerFrame(frame: number): string;
+/** Get terminal dimensions */
+export declare function getTermSize(): {
+    cols: number;
+    rows: number;
+};
+/** Format elapsed time (arttime contextual time display) */
+export declare function formatElapsed(ms: number): string;
+/** Format timestamp as HH:MM:SS */
+export declare function formatTime(date?: Date): string;
+/** Format a number with commas */
+export declare function formatNumber(n: number): string;
+//# sourceMappingURL=renderer.d.ts.map