amness 0.0.0-stage → 0.1.2

package/dist/cli/tui/session.js

@@ -0,0 +1,103 @@
+// Conversation persistence per project, plus undo/rewind of the file changes each turn made.
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+export const newSession = (cwd, model) => ({
+    id: new Date().toISOString().replace(/[-:T]/g, "").slice(0, 14) + "-" + Math.random().toString(36).slice(2, 6),
+    created: new Date().toISOString(), updated: new Date().toISOString(), title: "", cwd, model, messages: [], turns: [], usage: { prompt: 0, completion: 0, calls: 0, series: [] },
+});
+export class SessionStore {
+    dir;
+    constructor(cwd) { this.dir = join(cwd, ".amness", "chats"); }
+    file(id) { return join(this.dir, id.replace(/[^\w-]/g, "") + ".json"); }
+    save(s) { mkdirSync(this.dir, { recursive: true }); s.updated = new Date().toISOString(); writeFileSync(this.file(s.id), JSON.stringify(s)); }
+    load(id) { try {
+        return JSON.parse(readFileSync(this.file(id), "utf8"));
+    }
+    catch {
+        return undefined;
+    } }
+    list() {
+        if (!existsSync(this.dir))
+            return [];
+        return readdirSync(this.dir).filter((f) => f.endsWith(".json")).flatMap((f) => {
+            try {
+                const s = JSON.parse(readFileSync(join(this.dir, f), "utf8"));
+                return s.turns.length ? [{ id: s.id, title: s.title, updated: s.updated, turns: s.turns.length, model: s.model }] : [];
+            }
+            catch {
+                return [];
+            }
+        }).sort((a, b) => b.updated.localeCompare(a.updated));
+    }
+    latest() { const l = this.list()[0]; return l ? this.load(l.id) : undefined; }
+    remove(id) { rmSync(this.file(id), { force: true }); }
+}
+/** Record the pre-edit content for `path` the first time this turn touches it. */
+export function snapshot(turn, path, before) {
+    if (turn && before !== undefined && !(path in turn.snaps))
+        turn.snaps[path] = before;
+}
+/**
+ * Roll the conversation back to just before turn `idx`: truncate messages, drop later turns, and restore every file those turns changed
+ * (the earliest snapshot wins). Never touches paths outside `cwd`.
+ */
+export function rewind(s, cwd, idx) {
+    const root = resolve(cwd), restored = [], removed = [], skipped = [];
+    const target = s.turns[idx];
+    if (!target)
+        return { restored, removed, skipped };
+    const earliest = new Map();
+    for (const t of s.turns.slice(idx))
+        for (const [p, before] of Object.entries(t.snaps))
+            if (!earliest.has(p))
+                earliest.set(p, before);
+    for (const [p, before] of earliest) {
+        const abs = resolve(root, p);
+        if (abs !== root && !abs.startsWith(root + sep)) {
+            skipped.push(p);
+            continue;
+        }
+        if (before === null) {
+            if (existsSync(abs) && statSync(abs).isFile()) {
+                rmSync(abs);
+                removed.push(p);
+            }
+        }
+        else {
+            mkdirSync(dirname(abs), { recursive: true });
+            writeFileSync(abs, before);
+            restored.push(p);
+        }
+    }
+    s.messages = s.messages.slice(0, target.at);
+    s.turns = s.turns.slice(0, idx);
+    return { restored, removed, skipped };
+}
+/** Like `rewind`, but first puts the working tree back to the earliest shell snapshot in the turns being undone (undoing what commands did), and reports what could not be undone. */
+export async function rewindFull(s, cwd, idx, snaps) {
+    const undone = s.turns.slice(idx), tree = undone.find((t) => t.shell?.tree)?.shell?.tree, irreversible = undone.flatMap((t) => t.shell?.irreversible ?? []);
+    let treeResult, treeError;
+    if (tree && snaps) {
+        try {
+            treeResult = await snaps.restore(tree);
+        }
+        catch (e) {
+            treeError = e.message;
+        }
+    }
+    return { ...rewind(s, cwd, idx), tree: treeResult, irreversible, treeError };
+}
+/** A new conversation that continues from the end of turn `idx` (0-based) of `s`. The original is untouched. */
+export function forkSession(s, idx) {
+    const keep = s.turns.slice(0, idx + 1), end = s.turns[idx + 1]?.at ?? s.messages.length, f = newSession(s.cwd, s.model);
+    return { ...f, title: (s.title || "(untitled)").replace(/ \(branch \d+\)$/, "") + ` (branch ${Math.random().toString(36).slice(2, 5)})`, messages: JSON.parse(JSON.stringify(s.messages.slice(0, end))), turns: JSON.parse(JSON.stringify(keep)), usage: { ...s.usage, series: [...(s.usage.series ?? [])] }, parent: { id: s.id, turn: idx } };
+}
+/** Every conversation connected to `id` by branching (its ancestors, descendants and siblings), `id` itself included. */
+export function relatives(all, id) {
+    const parentOf = new Map(all.map((s) => [s.id, s.parent?.id])), root = (x) => { const seen = new Set(); while (parentOf.get(x) && !seen.has(x)) {
+        seen.add(x);
+        x = parentOf.get(x);
+    } return x; };
+    const r = root(id);
+    return all.filter((s) => root(s.id) === r).map((s) => s.id);
+}

package/dist/cli/tui/sidebar.d.ts

@@ -0,0 +1,84 @@
+import { type Cell } from "./ansi.ts";
+import type { Theme } from "./themes.ts";
+export type SidebarData = {
+    title: string;
+    model: string;
+    provider: string;
+    api?: string;
+    branch?: string;
+    cwd: string;
+    mode: string;
+    effort?: string;
+    ctxPct: number | null;
+    ctxUsed: number;
+    ctxMax: number;
+    series: number[];
+    map: {
+        label: string;
+        pct: number;
+        color: number;
+    }[];
+    usage: {
+        prompt: number;
+        completion: number;
+        calls: number;
+        cached: number;
+        reasoning: number;
+    };
+    cost: number | null;
+    todos: {
+        content: string;
+        status: string;
+    }[];
+    changes: {
+        path: string;
+        added: number;
+        removed: number;
+        created: boolean;
+        blockId: number;
+    }[];
+    run?: {
+        phase: string;
+        step: number;
+        max: number;
+        elapsedMs: number;
+        frame: number;
+        live: {
+            label: string;
+            ms: number;
+            agent?: string;
+        }[];
+        done: {
+            label: string;
+            ok: boolean;
+            ms: number;
+        }[];
+    };
+    sandbox?: string;
+    /** one line per plugin status (see Plugin.status) */ pluginStatus?: string[];
+    /** the token cap for the current/last turn: tokens counted (cached input at a tenth), the cap, and whether usage was estimated */ budget?: {
+        used: number;
+        max: number;
+    };
+    procs?: {
+        id: string;
+        name: string;
+        status: string;
+        secs: number;
+    }[];
+    tools: number;
+    mcp: number;
+    memory: number;
+    running: boolean;
+    elapsedMs: number;
+    tip?: string;
+};
+export type SideHit = {
+    row: number;
+    kind: "change" | "todos";
+    blockId?: number;
+};
+export declare function renderSidebar(d: SidebarData, t: Theme, width: number, height: number): {
+    rows: Cell[][];
+    hits: SideHit[];
+};

package/dist/cli/tui/sidebar.js

@@ -0,0 +1,114 @@
+// The right-hand panel: what is going on in this session at a glance.
+import { A, mix, parseAnsi } from "./ansi.js";
+import { BOLD, F, ITAL, fit, split } from "./rich.js";
+import { cellWidth, clipWidth } from "./text.js";
+import { brandOfModel } from "./brand.js";
+import { fmtCost, fmtTokens } from "./pricing.js";
+const BARS = "▁▂▃▄▅▆▇█";
+export function renderSidebar(d, t, width, height) {
+    const inner = width - 4, out = [], hits = [], bg = t.surface;
+    const push = (s = "") => out.push(fit("  " + s, width - 1, bg));
+    const head = (title, right = "") => { if (out.length > 1)
+        push(); push(right ? split(F(t.faint, BOLD(title)), right, inner, bg) : F(t.faint, BOLD(title))); };
+    const brand = brandOfModel(d.model, d.provider, t);
+    push();
+    if (d.run) {
+        const r = d.run, SPIN = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏", stages = [["model", "think"], ["tools", "act"], ["verify", "verify"]];
+        head("RUN", F(t.dim, `${(r.elapsedMs / 1000).toFixed(0)}s`));
+        push(stages.map(([k, label], i) => (k === r.phase || (r.phase === "compact" && k === "model") ? BOLD(F(t.accent, "● " + label)) : F(t.faint, "○ " + label)) + (i < 2 ? F(t.border, " ─ ") : "")).join(""));
+        const lbl = `step ${r.step + 1}/${r.max}`, bw = Math.max(6, Math.min(24, inner - cellWidth(lbl) - 2)), f = Math.max(1, Math.round(((r.step + 1) / Math.max(1, r.max)) * bw));
+        push(F(r.step + 1 >= r.max - 2 ? t.warn : t.accent2, "▰".repeat(f)) + F(t.border, "▱".repeat(bw - f)) + F(t.dim, "  " + lbl));
+        for (const x of r.live.slice(0, 5))
+            push(F(t.accent2, SPIN[r.frame % SPIN.length]) + " " + F(t.text, clipWidth(x.label, inner - 9)) + F(t.faint, ` ${fmtMs(x.ms)}`));
+        for (const x of r.done.slice(-4).reverse())
+            push(F(x.ok ? t.ok : t.err, x.ok ? "✓" : "✗") + " " + F(t.dim, clipWidth(x.label, inner - 9)) + F(t.faint, x.ms >= 50 ? ` ${fmtMs(x.ms)}` : ""));
+    }
+    head("SESSION");
+    for (const l of wrap(d.title || "New conversation", inner, 2))
+        push(BOLD(F(t.text, l)));
+    push(F(brand.color, brand.icon) + " " + F(t.text, clipWidth(d.model, inner - 4)));
+    push(F(t.faint, [d.api ? `${d.api} api` : "", d.effort ? `effort ${d.effort}` : ""].filter(Boolean).join(" · ") || " "));
+    push(F(t.dim, "⎇ " + (d.branch ?? "no git") + "  ") + F(t.faint, tail(d.cwd, Math.max(6, inner - 4 - (d.branch?.length ?? 6)))));
+    head("CONTEXT", d.ctxPct === null ? "" : F(pctColor(d.ctxPct, t), `${d.ctxPct}%`));
+    const bw = inner, filled = Math.round(((d.ctxPct ?? 0) / 100) * bw);
+    push(F(pctColor(d.ctxPct ?? 0, t), "▰".repeat(filled)) + F(t.border, "▱".repeat(Math.max(0, bw - filled))));
+    push(F(t.dim, `${fmtTokens(d.ctxUsed)} / ${fmtTokens(d.ctxMax)} tokens`));
+    if (d.series.length > 1) {
+        const v = d.series.slice(-inner), mx = Math.max(1, ...v);
+        push(F(t.accent2, v.map((x) => BARS[Math.min(7, Math.round((x / mx) * 7))]).join("")) + F(t.faint, "  per request"));
+    }
+    const mapRow = d.map.filter((m) => m.pct > 0).slice(0, 3).map((m) => F(m.color, "■") + F(t.dim, ` ${m.label} ${m.pct}%`)).join("  ");
+    if (mapRow)
+        for (const l of wrapPlain(mapRow, inner))
+            push(l);
+    head("USAGE");
+    push(F(t.dim, "in ") + F(t.text, fmtTokens(d.usage.prompt)) + F(t.dim, "  out ") + F(t.text, fmtTokens(d.usage.completion)) + F(t.dim, "  ") + F(t.faint, `${d.usage.calls} req`));
+    if (d.budget && Number.isFinite(d.budget.max) && d.budget.used > 0) {
+        const pct = Math.min(100, Math.round((d.budget.used / d.budget.max) * 100));
+        push(F(t.dim, "budget ") + F(pct >= 90 ? t.err : pct >= 75 ? t.warn : t.text, `${pct}%`) + F(t.faint, ` of ${fmtTokens(d.budget.max)} this turn`));
+    }
+    if (d.usage.cached)
+        push(F(t.dim, "cache ") + F(t.ok, `${Math.round((d.usage.cached / Math.max(1, d.usage.prompt)) * 100)}%`) + (d.usage.reasoning ? F(t.dim, "  reasoning ") + F(t.text, fmtTokens(d.usage.reasoning)) : ""));
+    push(F(t.dim, "cost ") + (d.cost === null ? F(t.faint, "n/a") : BOLD(F(t.text, "≈ " + fmtCost(d.cost)))));
+    if (d.todos.length) {
+        const done = d.todos.filter((x) => x.status === "done").length;
+        head("TODOS", F(t.dim, `${done}/${d.todos.length}`));
+        for (const x of d.todos.slice(0, 7))
+            push((x.status === "done" ? F(t.ok, "✓ ") + F(t.faint, clipWidth(x.content, inner - 2)) : x.status === "in_progress" ? F(t.warn, "▶ ") + BOLD(F(t.text, clipWidth(x.content, inner - 2))) : F(t.faint, "○ ") + F(t.dim, clipWidth(x.content, inner - 2))));
+        if (d.todos.length > 7)
+            push(F(t.faint, `+${d.todos.length - 7} more`));
+    }
+    if (d.changes.length) {
+        head("CHANGES", F(t.dim, String(d.changes.length)));
+        for (const c of d.changes.slice(0, 8)) {
+            const name = c.path.split("/").pop() ?? c.path, dir = c.path.includes("/") ? c.path.slice(0, c.path.length - name.length) : "", stat = F(t.addFg, `+${c.added}`) + " " + F(t.delFg, `−${c.removed}`);
+            hits.push({ row: out.length, kind: "change", blockId: c.blockId });
+            push(split(F(c.created ? t.ok : t.warn, c.created ? "A " : "M ") + F(t.text, clipWidth(name, inner - 14)) + F(t.faint, " " + clipWidth(dir, 8)), stat, inner, bg));
+        }
+        if (d.changes.length > 8)
+            push(F(t.faint, `+${d.changes.length - 8} more files`));
+    }
+    if (d.procs?.length) {
+        head("PROCESSES");
+        for (const p of d.procs.slice(0, 5))
+            push((p.status === "running" ? F(t.ok, "● ") : F(t.faint, "○ ")) + F(t.text, clipWidth(`${p.id} ${p.name}`, inner - 10)) + F(t.faint, ` ${p.status === "running" ? p.secs + "s" : p.status}`));
+    }
+    head("WORKSPACE");
+    if (d.sandbox && d.sandbox !== "off")
+        push(F(t.ok, "⛨ ") + F(t.dim, `sandbox ${d.sandbox}`));
+    for (const s of d.pluginStatus ?? [])
+        push(F(t.accent2, "◇ ") + F(t.dim, clipWidth(s, inner - 3)));
+    push(F(t.dim, `${d.tools} tools`) + (d.mcp ? F(t.faint, ` · ${d.mcp} mcp`) : "") + (d.memory ? F(t.faint, ` · ${d.memory} notes`) : ""));
+    if (d.tip) {
+        push();
+        for (const l of wrap(d.tip, inner, 3))
+            push(F(t.faint, ITAL(l)));
+    }
+    const rows = out.slice(0, height).map((r) => parseAnsi(r));
+    while (rows.length < height)
+        rows.push(parseAnsi(fit("", width - 1, bg)));
+    return { rows, hits };
+}
+const tail = (s, w) => (cellWidth(s) <= w ? s : "…" + s.slice(-(w - 1)));
+const fmtMs = (ms) => (ms < 1000 ? `${Math.round(ms)}ms` : `${(ms / 1000).toFixed(1)}s`);
+const pctColor = (p, t) => (p > 85 ? t.err : p > 60 ? t.warn : t.ok);
+function wrap(s, w, maxLines) {
+    const words = s.split(/\s+/), lines = [""];
+    for (const word of words) {
+        const last = lines[lines.length - 1];
+        if (cellWidth(last + " " + word) <= w)
+            lines[lines.length - 1] = (last ? last + " " : "") + word;
+        else
+            lines.push(word);
+    }
+    const cut = lines.slice(0, maxLines);
+    if (lines.length > maxLines)
+        cut[maxLines - 1] = clipWidth(cut[maxLines - 1], w - 1) + "…";
+    return cut.map((l) => clipWidth(l, w));
+}
+const wrapPlain = (s, w) => (cellWidth(s.replace(/\x1b\[[0-9;]*m/g, "")) <= w ? [s] : s.split("  ").reduce((acc, part) => { const cur = acc[acc.length - 1]; if (cur !== undefined && cellWidth((cur + "  " + part).replace(/\x1b\[[0-9;]*m/g, "")) <= w)
+    acc[acc.length - 1] = cur + "  " + part;
+else
+    acc.push(part); return acc; }, []));
+void A;
+void mix;

package/dist/cli/tui/text.d.ts

@@ -0,0 +1,15 @@
+export declare const strip: (s: string) => string;
+/** Columns a single code point occupies. */
+export declare function cpWidth(cp: number): number;
+/** Display width of a string (ANSI codes ignored). */
+export declare function cellWidth(s: string): number;
+/** Cut a plain string to at most `max` columns. */
+export declare function clipWidth(s: string, max: number): string;
+/**
+ * Word-wrap one logical line (may contain ANSI codes) to `width` columns. Continuation lines get `indent` spaces.
+ * Words longer than the width are hard-cut. Styles active at a break are re-opened is NOT attempted; each wrapped
+ * row ends with a reset so colours never bleed, and the next row restarts plain (callers style before wrapping short spans).
+ */
+export declare function wrapAnsi(line: string, width: number, indent?: number): string[];
+/** Cut an ANSI string to at most `max` columns, keeping escape codes intact and closing any open style. */
+export declare function clipAnsi(line: string, max: number): string;

package/dist/cli/tui/text.js

@@ -0,0 +1,94 @@
+// Terminal text primitives: ANSI stripping, display width (wide chars / emoji), and ANSI-aware wrapping.
+export const strip = (s) => s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+/** Columns a single code point occupies. */
+export function cpWidth(cp) {
+    if (cp === 0 || cp < 32 || (cp >= 0x7f && cp < 0xa0))
+        return 0;
+    if ((cp >= 0x300 && cp <= 0x36f) || (cp >= 0x200b && cp <= 0x200f) || (cp >= 0xfe00 && cp <= 0xfe0f) || (cp >= 0x20d0 && cp <= 0x20ff) || cp === 0x200d)
+        return 0;
+    if ((cp >= 0x1100 && cp <= 0x115f) || (cp >= 0x2e80 && cp <= 0xa4cf) || (cp >= 0xac00 && cp <= 0xd7a3) || (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe6f) || (cp >= 0xff00 && cp <= 0xff60) || (cp >= 0xffe0 && cp <= 0xffe6) || (cp >= 0x1f300 && cp <= 0x1f64f) ||
+        (cp >= 0x1f680 && cp <= 0x1f6ff) || (cp >= 0x1f900 && cp <= 0x1f9ff) || (cp >= 0x20000 && cp <= 0x3fffd))
+        return 2;
+    return 1;
+}
+/** Display width of a string (ANSI codes ignored). */
+export function cellWidth(s) {
+    let w = 0;
+    for (const ch of strip(s))
+        w += cpWidth(ch.codePointAt(0));
+    return w;
+}
+/** Cut a plain string to at most `max` columns. */
+export function clipWidth(s, max) {
+    let w = 0, out = "";
+    for (const ch of s) {
+        const cw = cpWidth(ch.codePointAt(0));
+        if (w + cw > max)
+            break;
+        out += ch;
+        w += cw;
+    }
+    return out;
+}
+/**
+ * Word-wrap one logical line (may contain ANSI codes) to `width` columns. Continuation lines get `indent` spaces.
+ * Words longer than the width are hard-cut. Styles active at a break are re-opened is NOT attempted; each wrapped
+ * row ends with a reset so colours never bleed, and the next row restarts plain (callers style before wrapping short spans).
+ */
+export function wrapAnsi(line, width, indent = 0) {
+    width = Math.max(4, width);
+    if (cellWidth(line) <= width)
+        return [line];
+    const reset = "\x1b[0m", hasAnsi = line.includes("\x1b");
+    const rows = [];
+    let cur = "", vis = 0, lastSpace = -1, lastSpaceVis = 0;
+    const pad = " ".repeat(indent);
+    for (const tok of line.match(/\x1b\[[0-9;?]*[A-Za-z]|[\s\S]/gu) ?? []) {
+        if (tok[0] === "\x1b" && tok.length > 1) {
+            cur += tok;
+            continue;
+        }
+        const w = cpWidth(tok.codePointAt(0));
+        if (vis + w > width) {
+            if (lastSpace > 0) {
+                rows.push(cur.slice(0, lastSpace).replace(/\s+$/, "") + (hasAnsi ? reset : ""));
+                cur = pad + cur.slice(lastSpace + 1);
+                vis = cellWidth(cur);
+            }
+            else {
+                rows.push(cur + (hasAnsi ? reset : ""));
+                cur = pad;
+                vis = indent;
+            }
+            lastSpace = -1;
+        }
+        if (tok === " ") {
+            lastSpace = cur.length;
+            lastSpaceVis = vis;
+        }
+        cur += tok;
+        vis += w;
+    }
+    void lastSpaceVis;
+    rows.push(cur);
+    return rows;
+}
+/** Cut an ANSI string to at most `max` columns, keeping escape codes intact and closing any open style. */
+export function clipAnsi(line, max) {
+    if (cellWidth(line) <= max)
+        return line;
+    let out = "", w = 0;
+    for (const tok of line.match(/\x1b\[[0-9;?]*[A-Za-z]|[\s\S]/gu) ?? []) {
+        if (tok[0] === "\x1b" && tok.length > 1) {
+            out += tok;
+            continue;
+        }
+        const cw = cpWidth(tok.codePointAt(0));
+        if (w + cw > max - 1)
+            break;
+        out += tok;
+        w += cw;
+    }
+    return out + "…" + (line.includes("\x1b") ? "\x1b[0m" : "");
+}

package/dist/cli/tui/theme.d.ts

@@ -0,0 +1,59 @@
+export type RGB = [number, number, number];
+export declare function detectLevel(env?: Record<string, string | undefined>, tty?: boolean): 0 | 1 | 2 | 3;
+export declare let level: 0 | 2 | 1 | 3;
+/** Tests (and `--color` style flags) can override detection. */
+export declare const setLevel: (l: 0 | 1 | 2 | 3) => void;
+/** Foreground colour; resets only the foreground so bold/dim keep working around it. */
+export declare function fg(c: RGB, s: string): string;
+export declare const bold: (s: string) => string;
+export declare const dimmed: (s: string) => string;
+export declare const lerp: (a: RGB, b: RGB, t: number) => RGB;
+/** Colour at position t∈[0,1] along a multi-stop gradient. */
+export declare function at(stops: RGB[], t: number): RGB;
+/** Paint each character along a gradient (a single colour at low colour depth, so it stays readable). */
+export declare function gradient(text: string, stops: RGB[], phase?: number): string;
+export declare const palette: {
+    brand: RGB[];
+    claude: RGB;
+    openai: RGB;
+    local: RGB;
+    other: RGB;
+    read: RGB;
+    edit: RGB;
+    shell: RGB;
+    web: RGB;
+    memory: RGB;
+    plan: RGB;
+    explore: RGB;
+    generic: RGB;
+    ok: RGB;
+    warn: RGB;
+    err: RGB;
+    muted: RGB;
+    gauge: RGB[];
+};
+export declare const toolColor: (name: string) => RGB;
+/** Provider/model identity: a glyph and an accent colour. */
+export declare function brandOf(model: string, provider?: string): {
+    icon: string;
+    color: RGB;
+};
+/** ▰▰▰▱▱▱▱▱ context gauge. Filled cells shift green → amber → red the fuller the window gets. */
+export declare function gauge(pct: number, width?: number): string;
+export declare const gaugeColor: (pct: number) => RGB;
+/** Tiny bar chart of the last `width` values. */
+export declare function sparkline(values: number[], width?: number, color?: RGB): string;
+/** A moving highlight sweeping across `text` (the "thinking" shimmer). Plain bold when colours are limited. */
+export declare function shimmer(text: string, frame: number, base?: RGB, hi?: RGB): string;
+/** Stacked horizontal bar from weighted segments (for the context map). */
+export declare function stackedBar(parts: {
+    label: string;
+    value: number;
+    color: RGB;
+}[], width?: number): {
+    bar: string;
+    legend: string[];
+};
+/** Pixel mascot + half-block wordmark, painted along the brand gradient. */
+export declare function logo(version: string): string[];
+export declare const TIPS: string[];

package/dist/cli/tui/theme.js

@@ -0,0 +1,148 @@
+export function detectLevel(env = process.env, tty = !!process.stdout.isTTY) {
+    if (env.NO_COLOR)
+        return 0;
+    const f = env.FORCE_COLOR;
+    if (f !== undefined && f !== "")
+        return f === "0" || f === "false" ? 0 : f === "2" ? 2 : f === "3" ? 3 : 1;
+    if (!tty)
+        return 0;
+    if (/truecolor|24bit/i.test(env.COLORTERM ?? "") || /^(iTerm\.app|vscode|WezTerm|Hyper|ghostty)$/i.test(env.TERM_PROGRAM ?? "") || /kitty|alacritty/i.test(env.TERM ?? ""))
+        return 3; // Apple Terminal is 256-colour only
+    if (/256/.test(env.TERM ?? ""))
+        return 2;
+    return 1;
+}
+export let level = detectLevel();
+/** Tests (and `--color` style flags) can override detection. */
+export const setLevel = (l) => { level = l; };
+const to256 = ([r, g, b]) => {
+    if (Math.abs(r - g) < 10 && Math.abs(g - b) < 10) {
+        const v = Math.round(((r + g + b) / 3 - 8) / 10);
+        return v < 0 ? 16 : v > 23 ? 231 : 232 + v;
+    } // greys
+    const c = (x) => Math.round((x / 255) * 5);
+    return 16 + 36 * c(r) + 6 * c(g) + c(b);
+};
+const to16 = ([r, g, b]) => {
+    const bright = Math.max(r, g, b) > 200, idx = (r > 127 ? 1 : 0) | (g > 127 ? 2 : 0) | (b > 127 ? 4 : 0);
+    return (bright ? 90 : 30) + (idx === 0 && !bright ? 7 : idx);
+};
+/** Foreground colour; resets only the foreground so bold/dim keep working around it. */
+export function fg(c, s) {
+    if (!level || !s)
+        return s;
+    return level === 3 ? `\x1b[38;2;${c[0]};${c[1]};${c[2]}m${s}\x1b[39m` : level === 2 ? `\x1b[38;5;${to256(c)}m${s}\x1b[39m` : `\x1b[${to16(c)}m${s}\x1b[39m`;
+}
+export const bold = (s) => (level ? `\x1b[1m${s}\x1b[22m` : s);
+export const dimmed = (s) => (level ? `\x1b[2m${s}\x1b[22m` : s);
+export const lerp = (a, b, t) => [Math.round(a[0] + (b[0] - a[0]) * t), Math.round(a[1] + (b[1] - a[1]) * t), Math.round(a[2] + (b[2] - a[2]) * t)];
+/** Colour at position t∈[0,1] along a multi-stop gradient. */
+export function at(stops, t) {
+    if (stops.length === 1)
+        return stops[0];
+    const x = Math.max(0, Math.min(1, t)) * (stops.length - 1), i = Math.min(stops.length - 2, Math.floor(x));
+    return lerp(stops[i], stops[i + 1], x - i);
+}
+/** Paint each character along a gradient (a single colour at low colour depth, so it stays readable). */
+export function gradient(text, stops, phase = 0) {
+    if (level < 2)
+        return fg(stops[Math.floor(stops.length / 2)], text);
+    const chars = [...text], n = Math.max(1, chars.length - 1);
+    return chars.map((ch, i) => (ch === " " ? ch : fg(at(stops, ((i / n) + phase) % 1), ch))).join("");
+}
+export const palette = {
+    brand: [[124, 92, 255], [0, 180, 255], [0, 229, 160]], // violet → blue → mint
+    claude: [217, 119, 87], openai: [16, 163, 127], local: [154, 165, 177], other: [138, 180, 248],
+    read: [91, 157, 255], edit: [255, 180, 84], shell: [199, 146, 234], web: [77, 208, 225],
+    memory: [126, 231, 135], plan: [255, 121, 198], explore: [255, 158, 100], generic: [160, 174, 192],
+    ok: [86, 211, 100], warn: [255, 196, 0], err: [255, 85, 85], muted: [110, 118, 129],
+    gauge: [[63, 220, 140], [255, 200, 60], [255, 85, 85]],
+};
+const CATEGORY = {
+    read_file: palette.read, list_files: palette.read, grep: palette.read, memory_search: palette.read,
+    write_file: palette.edit, edit_file: palette.edit, sh: palette.shell, web_search: palette.web, fetch_url: palette.web,
+    memory_save: palette.memory, memory_forget: palette.memory, todo_write: palette.plan, exit_plan_mode: palette.plan, task: palette.explore,
+};
+export const toolColor = (name) => CATEGORY[name] ?? (name.includes("__") ? palette.web : palette.generic);
+/** Provider/model identity: a glyph and an accent colour. */
+export function brandOf(model, provider = "") {
+    if (/claude|fable|mythos/i.test(model) || provider === "anthropic")
+        return { icon: "✻", color: palette.claude };
+    if (/gpt|o[134]-|openai|chatgpt/i.test(model) || provider === "openai")
+        return { icon: "◈", color: palette.openai };
+    if (/llama|qwen|mistral|gemma|phi|deepseek|ollama/i.test(model) || provider === "ollama")
+        return { icon: "⬢", color: palette.local };
+    return { icon: "◆", color: palette.other };
+}
+// ---------------------------------------------------------------- token meters
+/** ▰▰▰▱▱▱▱▱ context gauge. Filled cells shift green → amber → red the fuller the window gets. */
+export function gauge(pct, width = 10) {
+    const p = Math.max(0, Math.min(100, pct)), filled = Math.round((p / 100) * width);
+    let s = "";
+    for (let i = 0; i < width; i++) {
+        if (i < filled)
+            s += level >= 2 ? fg(at(palette.gauge, (i + 0.5) / width), "▰") : fg(p > 85 ? palette.err : p > 60 ? palette.warn : palette.ok, "▰"); // a cell's colour is its place on the bar, so a low gauge stays green
+        else
+            s += fg(palette.muted, "▱");
+    }
+    return s;
+}
+export const gaugeColor = (pct) => (pct > 85 ? palette.err : pct > 60 ? palette.warn : palette.ok);
+const BARS = "▁▂▃▄▅▆▇█";
+/** Tiny bar chart of the last `width` values. */
+export function sparkline(values, width = 12, color = palette.brand[1]) {
+    const v = values.slice(-width), max = Math.max(1, ...v);
+    return v.map((x) => fg(level >= 2 ? at(palette.brand, x / max) : color, BARS[Math.min(7, Math.round((x / max) * 7))])).join("");
+}
+/** A moving highlight sweeping across `text` (the "thinking" shimmer). Plain bold when colours are limited. */
+export function shimmer(text, frame, base = palette.brand[0], hi = [255, 255, 255]) {
+    if (level < 2)
+        return bold(text);
+    const chars = [...text], pos = (frame * 0.9) % (chars.length + 8) - 4;
+    return chars.map((ch, i) => fg(lerp(base, hi, Math.max(0, 1 - Math.abs(i - pos) / 3)), ch)).join("");
+}
+/** Stacked horizontal bar from weighted segments (for the context map). */
+export function stackedBar(parts, width = 40) {
+    const total = Math.max(1, parts.reduce((n, p) => n + p.value, 0));
+    const cells = parts.map((p) => Math.round((p.value / total) * width));
+    let diff = width - cells.reduce((a, b) => a + b, 0);
+    for (let i = 0; diff !== 0 && i < cells.length * 2; i++) {
+        const k = i % cells.length;
+        if (diff > 0) {
+            cells[k]++;
+            diff--;
+        }
+        else if (cells[k] > 0) {
+            cells[k]--;
+            diff++;
+        }
+    }
+    return {
+        bar: parts.map((p, i) => fg(p.color, "█".repeat(cells[i]))).join(""),
+        legend: parts.filter((p) => p.value > 0).map((p) => `${fg(p.color, "■")} ${p.label} ${Math.round((p.value / total) * 100)}%`),
+    };
+}
+// ---------------------------------------------------------------- logo
+/** Pixel mascot + half-block wordmark, painted along the brand gradient. */
+export function logo(version) {
+    const eyes = fg(palette.brand[2], "◖ ◗");
+    const wm1 = "▄▀█ █▀▄▀█ █▄ █ █▀▀ █▀ █▀", wm2 = "█▀█ █ ▀ █ █ ▀█ ██▄ ▄█ ▄█";
+    const g = (s, p = 0) => gradient(s, palette.brand, p);
+    return [
+        `${g(" ▗▄▄▄▄▄▖", 0)}   ${g(wm1, 0)}`,
+        `${g(" █", 0.05)} ${eyes} ${g("█", 0.2)}   ${g(wm2, 0)}`,
+        `${g(" ▝▀▀▀▀▀▘", 0.1)}   ${fg(palette.muted, `v${version} · reliable agents for any model`)}`,
+    ];
+}
+export const TIPS = [
+    "Shift+Tab cycles permissions: ask → accept edits → plan",
+    "Ctrl+P opens the command palette; Alt+M switches model",
+    "Type @ to mention a file; its contents are attached for you",
+    "Esc Esc rewinds the conversation and restores your files",
+    "Keep typing while it works; Enter steers the agent mid-task",
+    "/tokens shows what is eating your context window",
+    "/plan makes it read-only until you approve a plan",
+    "#note saves a memory; !ls runs a command right now",
+    "Drop a markdown file in .amness/commands/ to add your own /command",
+    "/verify npm test makes \"done\" mean the tests actually pass",
+];