@zenera/cli 1.1.24 → 1.1.26

package/dist/tui/links.js

@@ -0,0 +1,142 @@
+import { pathToFileURL } from 'node:url';
+/** Exactly the trees the file tools reach, under the same containment rule. */
+export function mountsOf(files) {
+    const names = [...(files.mount ? [files.mount] : []), ...files.mounts.map((m) => m.at)];
+    return {
+        names: names.sort((a, b) => b.length - a.length),
+        resolve: (path) => {
+            try {
+                return files.within(path);
+            }
+            catch {
+                return undefined;
+            }
+        },
+    };
+}
+const FILE = 'file://';
+/** Prose punctuation that ends a sentence, not a path. */
+const TRAILING = /[.,;:!?'"]+$/;
+/** The host `file:` url a mounted path names, or nothing. */
+export function mountUrl(token, mounts) {
+    let path = token;
+    let fragment = '';
+    if (path.startsWith(FILE)) {
+        path = path.slice(FILE.length);
+        const cut = path.search(/[?#]/);
+        if (cut >= 0) {
+            fragment = path.slice(cut);
+            path = path.slice(0, cut);
+        }
+        try {
+            path = decodeURIComponent(path);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // `within` also takes relative paths and `/`; only a mount name counts here.
+    if (!mounts.names.some((n) => path === n || path.startsWith(`${n}/`))) {
+        return undefined;
+    }
+    const host = mounts.resolve(path);
+    return host ? pathToFileURL(host).href + fragment : undefined;
+}
+const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, (c) => `\\${c}`);
+/** Every spelling of a mounted path in running text. */
+function pattern(mounts) {
+    const names = mounts.names.map(escaped).join('|');
+    return new RegExp(`(?<![\\w/.:-])(?:${FILE})?(?:${names})(?![\\w-]|\\.\\w)(?:/[^\\s<>"'\`()[\\]{}|\\\\^]*)?`, 'g');
+}
+/** Each mounted path in `text`, without the punctuation that follows it. */
+function* matches(text, mounts) {
+    if (mounts.names.length === 0) {
+        return;
+    }
+    for (const m of text.matchAll(pattern(mounts))) {
+        const token = m[0].replace(TRAILING, '');
+        if (token) {
+            yield { at: m.index, token };
+        }
+    }
+}
+/**
+ * The same spans with the same text, mounted paths carrying a host `href`.
+ *
+ * Only `href` changes, so every width measured from `span.text` still holds.
+ */
+export function linkSpans(spans, mounts) {
+    const out = [];
+    for (const span of spans) {
+        if (span.href) {
+            const url = mountUrl(span.href, mounts);
+            out.push(url ? { ...span, href: url } : span);
+            continue;
+        }
+        let from = 0;
+        for (const { at, token } of matches(span.text, mounts)) {
+            const url = mountUrl(token, mounts);
+            if (!url) {
+                continue;
+            }
+            if (at > from) {
+                out.push({ ...span, text: span.text.slice(from, at) });
+            }
+            out.push({ ...span, text: token, href: url });
+            from = at + token.length;
+        }
+        if (from === 0) {
+            out.push(span);
+        }
+        else if (from < span.text.length) {
+            out.push({ ...span, text: span.text.slice(from) });
+        }
+    }
+    return out;
+}
+/** A block whose prose and cells link their mounted paths; a fence is left alone. */
+export function linkBlock(block, mounts) {
+    return {
+        ...block,
+        ...(block.spans ? { spans: linkSpans(block.spans, mounts) } : {}),
+        ...(block.cells
+            ? { cells: block.cells.map((row) => row.map((cell) => linkSpans(cell, mounts))) }
+            : {}),
+    };
+}
+/** For a terminal with no hyperlinks: every `file:///<mount>/…` url, rewritten to the host. */
+export function hostUrls(text, mounts) {
+    let out = '';
+    let from = 0;
+    for (const { at, token } of matches(text, mounts)) {
+        const url = token.startsWith(FILE) ? mountUrl(token, mounts) : undefined;
+        if (!url) {
+            continue;
+        }
+        out += text.slice(from, at) + url;
+        from = at + token.length;
+    }
+    return out + text.slice(from);
+}
+/** `text` as an OSC 8 hyperlink to `href`. */
+export function hyperlink(href, text) {
+    return `\u001b]8;;${href}\u001b\\${text}\u001b]8;;\u001b\\`;
+}
+/** Whether this terminal turns OSC 8 into a link; an unknown one is assumed not to. */
+export function hyperlinks(env = process.env) {
+    const forced = env.FORCE_HYPERLINK;
+    if (forced !== undefined && forced !== '') {
+        return forced !== '0' && forced !== 'false';
+    }
+    if (env.WT_SESSION || env.KITTY_WINDOW_ID || env.KONSOLE_VERSION) {
+        return true;
+    }
+    if (['iTerm.app', 'vscode', 'WezTerm', 'ghostty'].includes(env.TERM_PROGRAM ?? '')) {
+        return true;
+    }
+    if (env.TERM === 'xterm-kitty' || env.TERM === 'xterm-ghostty') {
+        return true;
+    }
+    return Number(env.VTE_VERSION ?? 0) >= 5000;
+}
+//# sourceMappingURL=links.js.map

package/dist/tui/models.d.ts

@@ -0,0 +1,35 @@
+import { type Balance, type Catalog, type CatalogEntry } from '../catalog.ts';
+import type { Provider } from '../keys.ts';
+export interface ProviderRow {
+    provider: Provider;
+    /** where its credential came from — `environment`, `keyring` — or '' for none */
+    credential: string;
+    /** what the cached listing holds, read without asking anyone */
+    models: number;
+    origin: Catalog['origin'];
+    fetchedAt: string;
+}
+/** What asking a model one question found out. */
+export interface Verdict {
+    state: 'live' | 'dead' | 'blocked' | 'unknown';
+    ms?: number;
+    detail?: string;
+    fix?: string;
+    dimensions?: number;
+}
+export interface BrowseOptions {
+    providers: readonly ProviderRow[];
+    /** opens straight into this provider's listing */
+    initial?: Provider;
+    theme?: string;
+    load(provider: Provider, refresh: boolean): Promise<Catalog>;
+    /** what the account has left to spend, for providers that say */
+    balance?(provider: Provider): Promise<Balance | undefined>;
+    test(entry: CatalogEntry): Promise<Verdict>;
+}
+/**
+ * Runs the browser until the person picks a model or leaves. Resolves to the
+ * picked entry, or undefined when nothing was picked.
+ */
+export declare function browse(options: BrowseOptions): Promise<CatalogEntry | undefined>;
+//# sourceMappingURL=models.d.ts.map

package/dist/tui/models.js

@@ -0,0 +1,447 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// ---------------------------------------------------------------------------
+// zen models browse
+//
+// The catalog as something to walk rather than something to grep: providers,
+// then what one of them serves, then one model in full — with a key to ask it
+// a real question and a key to take it.
+//
+// Drawn on STDERR, like the banner and every other piece of narration, so the
+// one thing that reaches stdout is the ref picked at the end. That is what
+// makes `ref=$(zen models browse)` work the way `zen models pick` does: the
+// person sees the interface, the shell sees the answer.
+//
+// Nothing here knows how to list or probe a model. Both arrive as callbacks
+// from commands/models.ts, which already owns credentials and the catalog, so
+// this file is layout and keys and nothing else.
+// ---------------------------------------------------------------------------
+import { Box, render, Text, useApp, useInput, useStdout } from 'ink';
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { byGroup, isPartner, matches, perMillion, } from "../catalog.js";
+import { ago } from "../term.js";
+import { resolveTheme } from "./theme.js";
+import { clip, scrollTop, wrap } from "./wrap.js";
+const ROLES = ['chat', 'embedding', 'image', 'audio'];
+const message = (err) => (err instanceof Error ? err.message : String(err));
+const thousands = (n) => n === undefined ? '' : n >= 1000 ? `${Math.round(n / 1000)}k` : String(n);
+const ms = (n) => (n < 1000 ? `${n}ms` : `${(n / 1000).toFixed(1)}s`);
+const money = (n) => {
+    const abs = Math.abs(n);
+    return `${n < 0 ? '-' : ''}$${abs !== 0 && abs < 0.01 ? abs.toFixed(4) : abs.toFixed(2)}`;
+};
+/** The balance as one line; `short` for the providers screen. */
+function account(b, short) {
+    const parts = [];
+    if (b.credits !== undefined) {
+        parts.push(`balance ${money(b.credits)}`);
+    }
+    if (b.cap && !short) {
+        const reset = b.cap.reset ? ` ${b.cap.reset}` : '';
+        parts.push(`key cap ${money(b.cap.remaining)} left of ${money(b.cap.limit)}${reset}`);
+    }
+    if (b.free && !short) {
+        parts.push(`free ${b.free.remaining}/${b.free.limit} requests left today`);
+    }
+    return parts.join(' · ');
+}
+function freshness(origin, fetchedAt) {
+    switch (origin) {
+        case 'curated':
+            return 'built-in list';
+        case 'stale':
+            return `stale, ${ago(fetchedAt)}`;
+        case 'live':
+            return 'fetched now';
+        default:
+            return `cached ${ago(fetchedAt)}`;
+    }
+}
+function said(verdict, theme) {
+    if (verdict === undefined) {
+        return undefined;
+    }
+    if (verdict === 'asking') {
+        return { text: '… asking', color: theme.warn };
+    }
+    switch (verdict.state) {
+        case 'live':
+            return {
+                text: `✓ answers ${verdict.ms === undefined ? '' : ms(verdict.ms)}`.trim(),
+                color: theme.code.color,
+            };
+        case 'blocked':
+            return { text: '! blocked', color: theme.warn };
+        case 'dead':
+            return { text: '✗ refused', color: theme.line.error.color };
+        default:
+            return { text: '? no answer', color: theme.chrome.color };
+    }
+}
+/** One row, never wrapped: a wrapped row is a row the frame did not budget for. */
+function Row({ children, ...style }) {
+    return (_jsx(Text, { wrap: "truncate-end", ...style, children: children }));
+}
+function Keys({ theme, text }) {
+    return _jsx(Row, { color: theme.chrome.color, children: text });
+}
+function Browser({ options, theme, onPick }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [size, setSize] = useState({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+    useEffect(() => {
+        const resized = () => setSize({ columns: stdout.columns || 80, rows: stdout.rows || 24 });
+        stdout.on('resize', resized);
+        return () => {
+            stdout.off('resize', resized);
+        };
+    }, [stdout]);
+    const start = options.providers.findIndex((p) => p.provider === options.initial);
+    const [screen, setScreen] = useState(start >= 0 ? 'models' : 'providers');
+    const [at, setAt] = useState(Math.max(0, start));
+    const [catalogs, setCatalogs] = useState(new Map());
+    const [loading, setLoading] = useState();
+    const [failure, setFailure] = useState();
+    const [query, setQuery] = useState('');
+    const [typing, setTyping] = useState(false);
+    const [role, setRole] = useState(0);
+    const [selected, setSelected] = useState(0);
+    const [verdicts, setVerdicts] = useState(new Map());
+    const [balances, setBalances] = useState(new Map());
+    const [closing, setClosing] = useState(false);
+    const top = useRef(0);
+    const provider = options.providers[at].provider;
+    const catalog = catalogs.get(provider);
+    const load = (p, refresh) => {
+        setLoading(p);
+        setFailure(undefined);
+        options.load(p, refresh).then((cat) => {
+            setCatalogs((prev) => new Map(prev).set(p, cat));
+            setLoading((now) => (now === p ? undefined : now));
+        }, (err) => {
+            setFailure(message(err));
+            setLoading((now) => (now === p ? undefined : now));
+        });
+    };
+    const fetchBalance = (p) => {
+        options.balance?.(p).then((b) => b && setBalances((prev) => new Map(prev).set(p, b)), (err) => setBalances((prev) => new Map(prev).set(p, message(err))));
+    };
+    useEffect(() => {
+        if (start >= 0) {
+            load(provider, false);
+        }
+        for (const p of options.providers) {
+            if (p.credential) {
+                fetchBalance(p.provider);
+            }
+        }
+        // Once, for `zen models browse <provider>`; every later open is a key.
+    }, []);
+    useEffect(() => {
+        if (closing) {
+            exit();
+        }
+    }, [closing, exit]);
+    // Only the roles this listing actually has: cycling through `audio` on a
+    // provider with no audio models is a keypress spent on an empty screen.
+    const present = useMemo(() => [
+        undefined,
+        ...ROLES.filter((r) => catalog?.entries.some((e) => e.roles.includes(r))),
+    ], [catalog]);
+    const only = present[role % present.length];
+    const rows = useMemo(() => (catalog?.entries ?? [])
+        .filter((e) => matches(e, query, { roles: only ? [only] : [] }))
+        .sort(byGroup), [catalog, query, only]);
+    const index = Math.min(selected, Math.max(0, rows.length - 1));
+    const current = rows[index];
+    const open = (next) => {
+        const p = options.providers[next].provider;
+        setAt(next);
+        setScreen('models');
+        setQuery('');
+        setTyping(false);
+        setRole(0);
+        setSelected(0);
+        top.current = 0;
+        if (!catalogs.has(p)) {
+            load(p, false);
+        }
+    };
+    const ask = (entry) => {
+        if (verdicts.get(entry.ref) === 'asking') {
+            return;
+        }
+        setVerdicts((prev) => new Map(prev).set(entry.ref, 'asking'));
+        options.test(entry).then((v) => setVerdicts((prev) => new Map(prev).set(entry.ref, v)), (err) => setVerdicts((prev) => new Map(prev).set(entry.ref, { state: 'unknown', detail: message(err) })));
+    };
+    const pick = (entry) => {
+        onPick(entry);
+        setClosing(true);
+    };
+    // Everything but the list is a fixed number of rows, and the list gets
+    // what is left. A row is kept in hand: a frame as tall as the viewport is
+    // the one Ink cannot erase (see tui/app.tsx).
+    const problem = catalog?.problem;
+    const balance = balances.get(provider);
+    const funds = balance === undefined
+        ? []
+        : wrap(typeof balance === 'string'
+            ? `balance could not be read: ${balance}`
+            : account(balance, false) || 'balance: nothing reported', Math.max(20, size.columns - 1));
+    const short = typeof balance === 'string' || (balance?.credits !== undefined && balance.credits <= 0);
+    const chrome = 7 + (problem ? 1 : 0) + funds.length;
+    const height = Math.max(3, size.rows - 1 - chrome);
+    top.current = scrollTop(index, top.current, height, rows.length);
+    useInput((input, key) => {
+        if (closing) {
+            return;
+        }
+        const quit = () => setClosing(true);
+        if (screen === 'providers') {
+            const n = options.providers.length;
+            if (key.upArrow || input === 'k') {
+                setAt((i) => (i + n - 1) % n);
+            }
+            else if (key.downArrow || input === 'j') {
+                setAt((i) => (i + 1) % n);
+            }
+            else if (key.return || key.rightArrow || input === 'l') {
+                open(at);
+            }
+            else if (key.escape || input === 'q') {
+                quit();
+            }
+            return;
+        }
+        if (screen === 'detail') {
+            if (!current) {
+                setScreen('models');
+            }
+            else if (input === 't') {
+                ask(current);
+            }
+            else if (key.return || input === 'p') {
+                pick(current);
+            }
+            else if (key.escape || key.leftArrow || input === 'h') {
+                setScreen('models');
+            }
+            else if (input === 'q') {
+                quit();
+            }
+            return;
+        }
+        const move = (by) => setSelected(Math.max(0, Math.min(rows.length - 1, index + by)));
+        if (key.upArrow) {
+            return move(-1);
+        }
+        if (key.downArrow) {
+            return move(1);
+        }
+        if (key.pageUp) {
+            return move(-height);
+        }
+        if (key.pageDown) {
+            return move(height);
+        }
+        if (typing) {
+            if (key.return) {
+                setTyping(false);
+            }
+            else if (key.escape) {
+                setQuery('');
+                setTyping(false);
+            }
+            else if (key.backspace || key.delete) {
+                setQuery((q) => q.slice(0, -1));
+                setSelected(0);
+            }
+            else if (input && !key.ctrl && !key.meta && !key.tab) {
+                // Fast typing or a paste can arrive as one chunk with the Enter
+                // inside it: keep the text, honour the Enter, drop the rest.
+                const [text = '', ...after] = input.split(/[\r\n]/);
+                setQuery((q) => q + text.replace(/[\u0000-\u001f\u007f]/g, ''));
+                setSelected(0);
+                if (after.length > 0) {
+                    setTyping(false);
+                }
+            }
+            return;
+        }
+        if (input === 'k') {
+            move(-1);
+        }
+        else if (input === 'j') {
+            move(1);
+        }
+        else if (key.home || input === 'g') {
+            setSelected(0);
+        }
+        else if (key.end || input === 'G') {
+            setSelected(Math.max(0, rows.length - 1));
+        }
+        else if (input.startsWith('/')) {
+            // A pasted `/gpt-5` arrives as one chunk, not as a slash and then
+            // the rest.
+            setTyping(true);
+            setQuery(input.slice(1));
+            setSelected(0);
+        }
+        else if (key.tab) {
+            setRole((r) => (r + 1) % present.length);
+            setSelected(0);
+        }
+        else if ((key.return || key.rightArrow || input === 'l') && current) {
+            setScreen('detail');
+        }
+        else if (input === 't' && current) {
+            ask(current);
+        }
+        else if (input === 'p' && current) {
+            pick(current);
+        }
+        else if (input === 'r') {
+            load(provider, true);
+            fetchBalance(provider);
+        }
+        else if (key.escape && query) {
+            setQuery('');
+            setSelected(0);
+        }
+        else if (key.escape || key.leftArrow || input === 'h') {
+            setScreen('providers');
+        }
+        else if (input === 'q') {
+            quit();
+        }
+    });
+    if (closing) {
+        // An empty frame erases the last one, so the shell is left as it was
+        // found rather than with a stale picture of a list on it.
+        return null;
+    }
+    const width = Math.max(20, size.columns - 1);
+    if (screen === 'providers') {
+        const nameW = Math.max(...options.providers.map((p) => p.provider.length)) + 2;
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Row, { bold: true, color: theme.accent, children: "Providers" }), _jsx(Text, { children: " " }), options.providers.map((p, i) => {
+                    const here = i === at;
+                    const cat = catalogs.get(p.provider);
+                    const count = cat?.entries.length ?? p.models;
+                    const fresh = cat
+                        ? freshness(cat.origin, cat.fetchedAt)
+                        : freshness(p.origin, p.fetchedAt);
+                    const b = balances.get(p.provider);
+                    return (_jsxs(Row, { children: [_jsxs(Text, { color: here ? theme.accent : undefined, bold: here, children: [here ? '› ' : '  ', p.provider.padEnd(nameW)] }), p.credential ? (_jsx(Text, { color: theme.code.color, children: p.credential.padEnd(15) })) : (_jsx(Text, { color: theme.line.error.color, children: 'no credential'.padEnd(15) })), _jsxs(Text, { color: theme.chrome.color, children: [`${count} model${count === 1 ? '' : 's'}`.padEnd(13), p.credential ? fresh : `zen key add ${p.provider}`] }), b && typeof b !== 'string' ? (_jsx(Text, { color: theme.code.color, children: `   ${account(b, true)}` })) : null] }, p.provider));
+                }), _jsx(Text, { children: " " }), _jsx(Keys, { theme: theme, text: "\u2191\u2193 move \u00B7 enter open \u00B7 q quit" })] }));
+    }
+    if (screen === 'detail' && current) {
+        return (_jsx(Detail, { entry: current, catalog: catalog, verdict: verdicts.get(current.ref), theme: theme, width: width, rows: size.rows - 1 }));
+    }
+    const header = catalog
+        ? `${provider} · ${catalog.entries.length} models · ${freshness(catalog.origin, catalog.fetchedAt)}`
+        : provider;
+    const withMaker = rows.some((e) => e.publisher);
+    const priced = rows.some((e) => e.pricing);
+    const ROLE_W = Math.max(4, ...rows.map((e) => e.roles.join('+').length)) + 2;
+    const CTX_W = 9;
+    const PRICE_W = 10;
+    const fixed = (withMaker ? 12 : 0) + ROLE_W + CTX_W + (priced ? PRICE_W * 2 : 0) + 'test'.length + 2;
+    const idW = Math.max(10, Math.min(46, Math.max(8, ...rows.map((e) => e.id.length)) + 2, width - fixed));
+    const shown = rows.slice(top.current, top.current + height);
+    const filter = typing ? `/${query}▌` : query ? `/${query}` : '';
+    const columns = [
+        `  ${'model'.padEnd(idW)}`,
+        withMaker ? 'maker'.padEnd(12) : '',
+        'role'.padEnd(ROLE_W),
+        'context'.padStart(CTX_W - 2).padEnd(CTX_W),
+        priced ? 'in $/1M'.padStart(PRICE_W - 2).padEnd(PRICE_W) : '',
+        priced ? 'out $/1M'.padStart(PRICE_W - 2).padEnd(PRICE_W) : '',
+        'test',
+    ].join('');
+    let body;
+    if (failure) {
+        body = _jsx(Row, { color: theme.line.error.color, children: failure });
+    }
+    else if (loading === provider || !catalog) {
+        body = _jsxs(Row, { color: theme.warn, children: ["listing ", provider, " \u2026"] });
+    }
+    else if (rows.length === 0) {
+        body = (_jsx(Row, { color: theme.chrome.color, children: query ? `nothing matches "${query}"` : 'nothing listed' }));
+    }
+    else {
+        body = (_jsx(_Fragment, { children: shown.map((e, i) => {
+                const here = top.current + i === index;
+                const v = said(verdicts.get(e.ref), theme);
+                return (_jsxs(Row, { children: [_jsxs(Text, { color: here ? theme.accent : undefined, bold: here, children: [here ? '› ' : '  ', clip(e.id, idW - 2).padEnd(idW)] }), withMaker ? (_jsx(Text, { color: isPartner(e) ? theme.warn : theme.code.color, children: clip(e.publisher ?? '', 11).padEnd(12) })) : null, _jsxs(Text, { color: theme.chrome.color, children: [e.roles.join('+').padEnd(ROLE_W), thousands(e.contextLength)
+                                    .padStart(CTX_W - 2)
+                                    .padEnd(CTX_W)] }), priced ? (_jsxs(Text, { color: e.pricing?.free ? theme.code.color : undefined, children: [perMillion(e.pricing?.prompt)
+                                    .padStart(PRICE_W - 2)
+                                    .padEnd(PRICE_W), (e.pricing?.free ? '' : perMillion(e.pricing?.completion))
+                                    .padStart(PRICE_W - 2)
+                                    .padEnd(PRICE_W)] })) : null, v ? _jsx(Text, { color: v.color, children: v.text }) : null] }, e.ref));
+            }) }));
+    }
+    const preview = current ? [current.name, current.description].filter(Boolean).join(' — ') : '';
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Row, { children: [_jsx(Text, { bold: true, color: theme.accent, children: header }), _jsxs(Text, { color: theme.chrome.color, children: ['   role: ', only ?? 'all', filter ? '   ' : ''] }), _jsx(Text, { color: theme.code.color, children: filter })] }), problem ? (_jsxs(Row, { color: theme.warn, children: ["could not be listed: ", problem.detail ?? 'no reason given'] })) : null, funds.map((line, i) => (_jsx(Row, { color: short ? theme.warn : theme.code.color, children: line }, `funds${i}`))), _jsx(Text, { children: " " }), _jsx(Row, { bold: true, color: theme.chrome.color, children: columns }), _jsx(Box, { flexDirection: "column", height: height, children: body }), _jsx(Row, { color: theme.chrome.color, children: clip(preview, width) || ' ' }), _jsx(Row, { color: theme.chrome.color, children: rows.length === 0
+                    ? ' '
+                    : `${index + 1} of ${rows.length}${rows.length < (catalog?.entries.length ?? 0) ? ` (${catalog.entries.length} in all)` : ''}` }), _jsx(Keys, { theme: theme, text: typing
+                    ? 'type to filter · enter keep · esc clear · ↑↓ move'
+                    : '↑↓ · / filter · tab role · ⏎ more · t test · p pick · r reload · esc back' })] }));
+}
+function Detail({ entry, catalog, verdict, theme, width, rows }) {
+    const facts = [];
+    const add = (label, value) => {
+        if (value) {
+            facts.push([label, value]);
+        }
+    };
+    add('name', entry.name);
+    add('roles', entry.roles.join(', '));
+    add('context', entry.contextLength ? `${entry.contextLength.toLocaleString()} tokens` : undefined);
+    add('max output', entry.maxOutputTokens ? `${entry.maxOutputTokens.toLocaleString()} tokens` : undefined);
+    add('dimensions', entry.dimensions ? String(entry.dimensions) : undefined);
+    add('input', entry.modalities?.input?.join(', '));
+    add('output', entry.modalities?.output?.join(', '));
+    add('supports', Object.entries(entry.supports ?? {})
+        .filter(([, on]) => on)
+        .map(([k]) => k)
+        .join(', '));
+    add('pricing', entry.pricing?.free
+        ? 'free'
+        : entry.pricing?.prompt
+            ? `${perMillion(entry.pricing.prompt)} per 1M input tokens, ${perMillion(entry.pricing.completion) || '?'} per 1M output tokens`
+            : undefined);
+    add('released', entry.created);
+    add('source', entry.source === 'live' && catalog
+        ? `${entry.provider}, ${freshness(catalog.origin, catalog.fetchedAt)}`
+        : 'built-in list');
+    const v = said(verdict, theme);
+    const reason = verdict && verdict !== 'asking'
+        ? [
+            verdict.dimensions ? `${verdict.dimensions} dims` : '',
+            verdict.state === 'live' ? '' : (verdict.detail ?? ''),
+            verdict.fix ? `fix: ${verdict.fix}` : '',
+        ]
+            .filter(Boolean)
+            .join(' · ')
+        : '';
+    // Header, blank, facts, the verdict row, blank, keys — the description has
+    // whatever is left, and is cut rather than allowed to push the keys off.
+    const room = Math.max(0, rows - facts.length - 6);
+    const about = entry.description ? wrap(entry.description, width - 2).slice(0, room) : [];
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Row, { bold: true, color: theme.accent, children: entry.ref }), _jsx(Text, { children: " " }), facts.map(([label, value]) => (_jsxs(Row, { children: [_jsx(Text, { color: theme.chrome.color, children: `  ${label.padEnd(12)}` }), _jsx(Text, { children: value })] }, label))), _jsxs(Row, { children: [_jsxs(Text, { color: theme.chrome.color, children: ['  ', 'asked'.padEnd(12)] }), v ? (_jsx(Text, { color: v.color, children: v.text })) : (_jsx(Text, { color: theme.chrome.color, children: "not yet \u2014 t to ask it one question" })), reason ? _jsx(Text, { color: v?.color, children: `  ${reason}` }) : null] }), about.length > 0 ? _jsx(Text, { children: " " }) : null, about.map((line, i) => (_jsx(Row, { color: theme.chrome.color, children: `  ${line}` }, i))), _jsx(Text, { children: " " }), _jsx(Keys, { theme: theme, text: "t test \u00B7 p pick (prints the ref) \u00B7 esc back \u00B7 q quit" })] }));
+}
+/**
+ * Runs the browser until the person picks a model or leaves. Resolves to the
+ * picked entry, or undefined when nothing was picked.
+ */
+export async function browse(options) {
+    // Asked before Ink takes the terminal, as tui/app.tsx does.
+    const theme = await resolveTheme(options.theme);
+    let chosen;
+    const instance = render(_jsx(Browser, { options: options, theme: theme, onPick: (entry) => {
+            chosen = entry;
+        } }), { stdout: process.stderr });
+    await instance.waitUntilExit();
+    return chosen;
+}
+//# sourceMappingURL=models.js.map

package/dist/tui/sandbox.d.ts

@@ -0,0 +1,10 @@
+import { type ResourceSampler } from '../resources.ts';
+export interface WatchOptions {
+    sampler: ResourceSampler;
+    intervalMs: number;
+    explain: boolean;
+    theme?: string;
+}
+/** Runs the live screen until the person leaves it. */
+export declare function watch(options: WatchOptions): Promise<void>;
+//# sourceMappingURL=sandbox.d.ts.map