@voidlabs.gg/voidshift 0.0.0-stage → 0.4.1

package/dist/tui/home.js

@@ -0,0 +1,336 @@
+// The Home screen: one live overview of every added tool. Tab moves between
+// sections, Enter opens the focused one. The functions at the top are pure
+// shaping of the store's data into lines (tested); the component below draws them.
+import React, { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { useData, runsThisWeek, updateNotice } from "./data.js";
+import { useHints, useKeys, useScreen } from "./context.js";
+import { clock, clockOrStamp, duration, minutesText, plural, secondsToNextCheck, tilde, truncate } from "./format.js";
+import { theme } from "./theme.js";
+import { Lines, Panel, ProgressSteps, seg, SplitRow } from "./widgets.js";
+const h = React.createElement;
+// Sections of tools that are not added are hidden; Checks is always there.
+export function sectionsFor(tools) {
+    const out = [];
+    for (const t of ['agents', 'awake', 'memory'])
+        if (tools.includes(t))
+            out.push(t);
+    out.push('checks');
+    return out;
+}
+// Tab moves to the next section, Shift+Tab to the one before; both wrap.
+export function nextSection(sections, current, dir) {
+    const i = sections.indexOf(current);
+    if (i === -1)
+        return sections[0];
+    return sections[(i + dir + sections.length) % sections.length];
+}
+// The focused section, or the first one when it just disappeared.
+export const clampFocus = (sections, current) => (sections.includes(current) ? current : sections[0]);
+const titleCase = (id) => {
+    const t = id.replace(/^vs-/, '').replace(/-/g, ' ');
+    return t.charAt(0).toUpperCase() + t.slice(1);
+};
+// The card being worked on, with the progress of each step of its workflow.
+export function liveCard(state, nowMs) {
+    const current = state.agents?.current;
+    if (!current || !current.card)
+        return null;
+    const run = state.runs.find((r) => r.card === current.card && r.record?.outcome === 'running' && (!current.runDir || r.dir === current.runDir));
+    const rec = run?.record;
+    const workflow = state.workflows.find((w) => w.name === (current.workflow ?? rec?.workflow));
+    const recSteps = rec?.steps ?? [];
+    const labelOf = (id) => state.steps?.steps.find((s) => s.id === id)?.label ?? recSteps.find((s) => s.step === id)?.label ?? titleCase(id);
+    const ids = workflow?.steps ?? recSteps.map((s) => s.step).filter((s, i, all) => all.indexOf(s) === i);
+    const runningRec = [...recSteps].reverse().find((s) => !s.endedAt);
+    const byLabel = ids.find((id) => labelOf(id) === current.step);
+    const runningId = runningRec?.step ?? byLabel;
+    const runningPos = runningRec ? recSteps.indexOf(runningRec) : recSteps.length;
+    const timeout = typeof state.agentsConfig?.timeoutMinutes === 'number' ? state.agentsConfig.timeoutMinutes : 45;
+    const steps = ids.map((id) => {
+        const label = labelOf(id);
+        if (id === runningId) {
+            const started = Date.parse(runningRec?.startedAt ?? current.startedAt ?? '');
+            const min = Number.isNaN(started) ? 0 : (nowMs - started) / 60_000;
+            return { label, state: 'running', fraction: Math.max(0.25, Math.min(0.9, min / timeout)) };
+        }
+        let last = -1;
+        recSteps.forEach((s, i) => {
+            if (s.step === id)
+                last = i;
+        });
+        const done = last >= 0 && last < runningPos && !!recSteps[last].endedAt;
+        if (!done)
+            return { label, state: 'pending' };
+        return { label, state: recSteps[last].result === 'FIX' ? 'failed' : 'done' };
+    });
+    const startedAt = Date.parse(current.startedAt ?? rec?.startedAt ?? '');
+    return {
+        card: current.card,
+        title: current.title ?? rec?.title ?? '',
+        workflow: current.workflow ?? rec?.workflow ?? '',
+        step: current.step ?? '',
+        minutes: current.elapsedMinutes ?? (Number.isNaN(startedAt) ? 0 : Math.max(0, Math.round((nowMs - startedAt) / 60_000))),
+        round: (current.round ?? 0) + 1,
+        maxRounds: workflow?.maxRounds ?? null,
+        steps,
+    };
+}
+// "● Runner running" and "last check 14:03 · next in 41s".
+export function runnerLines(agents, nowMs) {
+    const left = agents.runner === 'running'
+        ? [seg('● ', theme.green), seg('Runner running')]
+        : agents.runner === 'paused'
+            ? [seg('● ', theme.yellow), seg('Runner paused'), seg('  p resumes it', theme.dim)]
+            : [seg('○ ', theme.dim), seg('Runner stopped'), seg('  vsf agents start', theme.dim)];
+    const right = [];
+    if (agents.lastTick) {
+        const next = agents.runner === 'running' ? secondsToNextCheck(agents.lastTick.at, nowMs) : null;
+        const parts = [`last check ${clock(new Date(agents.lastTick.at))}`];
+        if (next !== null)
+            parts.push(next > 0 ? `next in ${next}s` : 'due now');
+        right.push(seg(parts.join(' · '), theme.dim));
+    }
+    return { left, right };
+}
+// Parked and interrupted cards, the ones `r` can retry.
+export function parkedRows(agents) {
+    return [
+        ...agents.parked.map((p) => ({ card: p.card, kind: 'parked', text: p.reason ? `parked: ${truncate(p.reason, 70)}` : 'parked' })),
+        ...agents.interrupted.map((c) => ({ card: c, kind: 'interrupted', text: 'interrupted' })),
+    ];
+}
+export function countsLine(agents, runs, nowMs) {
+    return [plural(agents.workflows, 'workflow'), plural(agents.projects, 'project'), plural(runsThisWeek(runs, nowMs), 'run') + ' this week'].join(' · ');
+}
+// ---- Awake ----------------------------------------------------------------
+export function awakeLines(a) {
+    const power = a.power.onBattery ? `on battery, ${a.power.percent ?? '?'}%` : 'on power adapter';
+    const dog = a.watchdog ? seg('watchdog ok', theme.dim) : seg('watchdog not loaded', theme.yellow);
+    if (a.on) {
+        const stops = a.until && a.minutesLeft !== null ? `stops ${clock(new Date(a.until))} (${minutesText(a.minutesLeft)}) or at ${a.batteryFloor}%` : `stops at ${a.batteryFloor}%`;
+        return [
+            [seg('● ', theme.green), seg(`On since ${a.since ? clock(new Date(a.since)) : '?'}, the lid can close`)],
+            [seg(`  ${stops}`)],
+            [seg(`  ${power} · `, theme.dim), dog],
+        ];
+    }
+    if (a.sleepDisabledByOther) {
+        return [[seg('● ', theme.yellow), seg('Sleep is off, but not by VoidShift')], [seg(`  ${power}`, theme.dim)]];
+    }
+    const lines = [[seg('○ ', theme.dim), seg('Off. The Mac sleeps normally.')]];
+    if (a.lastReason)
+        lines.push([seg(`  last session ended because ${a.lastReason}`, theme.dim)]);
+    lines.push([seg(`  ${power} · `, theme.dim), dog]);
+    return lines;
+}
+// ---- Memory ---------------------------------------------------------------
+const kindLabel = (k) => (k === 'codex' ? 'Codex' : 'Claude Code');
+export function memoryLines(m, now = new Date()) {
+    if (!m.isVault)
+        return [[seg('Vault has no INDEX.md', theme.yellow)], [seg(tilde(m.vault), theme.dim)]];
+    const first = [seg(plural(m.notes, 'note'))];
+    if (m.unindexed.count)
+        first.push(seg(' · '), seg(`${m.unindexed.count} not in INDEX.md`, theme.yellow));
+    const lines = [first];
+    for (const home of m.homes.slice(0, 2)) {
+        const recall = home.recall === 'on' ? 'recall on' : home.recall === 'other' ? 'another hook recalls' : 'recall off';
+        lines.push([seg(`${recall} in ${kindLabel(home.kind)} `), seg(tilde(home.dir), theme.dim)]);
+    }
+    if (m.lastUpdated)
+        lines.push([seg(`last note ${clockOrStamp(new Date(m.lastUpdated), now)}`, theme.dim)]);
+    return lines;
+}
+export function checksView(checks) {
+    const problems = checks.filter((c) => c.status !== 'ok');
+    return {
+        ok: checks.filter((c) => c.status === 'ok').length,
+        warn: checks.filter((c) => c.status === 'warn').length,
+        fail: checks.filter((c) => c.status === 'fail').length,
+        problems: [...problems.filter((c) => c.status === 'fail'), ...problems.filter((c) => c.status === 'warn')],
+    };
+}
+export function checksLines(checks) {
+    const v = checksView(checks);
+    const counts = [seg(`✓ ${v.ok} ok`, theme.green)];
+    if (v.warn)
+        counts.push(seg('   '), seg(`! ${plural(v.warn, 'warning')}`, theme.yellow));
+    if (v.fail)
+        counts.push(seg('   '), seg(`✗ ${v.fail} failed`, theme.red));
+    const detail = (c) => [seg(`${c.name} ${c.detail}`), ...(c.fix ? [seg(`  fix: ${c.fix}`, theme.dim)] : [])];
+    const rows = [];
+    const [first, ...rest] = v.problems;
+    rows.push({ left: first ? [...counts, seg('  '), ...detail(first)] : counts, right: first ? [seg('enter fixes it', theme.dim)] : [] });
+    for (const c of rest.slice(0, 2))
+        rows.push({ left: [seg(c.status === 'fail' ? '✗ ' : '! ', c.status === 'fail' ? theme.red : theme.yellow), ...detail(c)], right: [] });
+    if (rest.length > 2)
+        rows.push({ left: [seg(`+${rest.length - 2} more`, theme.dim)], right: [] });
+    return rows;
+}
+// ---- hints ----------------------------------------------------------------
+export function homeHints(opts) {
+    const hints = [
+        { key: 'tab', label: 'section' },
+        { key: 'enter', label: 'open' },
+    ];
+    if (opts.runner)
+        hints.push({ key: 'p', label: opts.runner === 'paused' ? 'resume runner' : 'pause runner' });
+    if (opts.hasAwake)
+        hints.push({ key: 'a', label: 'awake' });
+    hints.push({ key: ':', label: 'command' }, { key: '?', label: 'keys' }, { key: 'q', label: 'quit' });
+    return hints;
+}
+// ---- component ------------------------------------------------------------
+export const homeScreen = {
+    id: 'home',
+    title: 'VoidShift',
+    component: () => h(Home),
+    hints: () => [{ key: 'q', label: 'quit' }],
+};
+const SCREEN_OF = { agents: 'agents', awake: 'awake', memory: 'memory', checks: 'checks' };
+export function Home() {
+    const ctx = useScreen();
+    const { state, refreshChecks } = useData();
+    const sections = sectionsFor(state.tools);
+    const [focus, setFocus] = useState('agents');
+    const [parkedIdx, setParkedIdx] = useState(0);
+    const [now, setNow] = useState(Date.now());
+    useEffect(() => {
+        const t = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(t);
+    }, []);
+    const at = clampFocus(sections, focus);
+    const agents = state.agents;
+    const parked = agents ? parkedRows(agents) : [];
+    const sel = Math.min(parkedIdx, Math.max(0, parked.length - 1));
+    const update = updateNotice(state.update);
+    useHints(homeHints({ runner: agents?.runner, hasAwake: !!state.awake }));
+    useKeys((input, key) => {
+        if (key.tab)
+            setFocus(nextSection(sections, at, key.shift ? -1 : 1));
+        else if (key.return) {
+            const card = at === 'agents' ? parked[sel]?.card : undefined;
+            ctx.nav.push(SCREEN_OF[at], at === 'agents' ? { tab: 'agents.runs', ...(card ? { card } : {}) } : {});
+        }
+        else if (at === 'agents' && key.upArrow)
+            setParkedIdx(Math.max(0, sel - 1));
+        else if (at === 'agents' && key.downArrow)
+            setParkedIdx(Math.min(parked.length - 1, sel + 1));
+        else if (input === 'p' && agents) {
+            if (agents.runner === 'stopped')
+                ctx.toast('The runner is stopped. Start it with: vsf agents start', 'info');
+            else
+                void ctx.actions.run({
+                    args: ['agents', agents.runner === 'paused' ? 'resume' : 'pause'],
+                    title: 'Pause the runner?',
+                    noConfirm: true,
+                    done: agents.runner === 'paused' ? 'Runner resumed' : 'Runner paused. A card in progress carries on.',
+                });
+        }
+        else if (input === 'a' && state.awake) {
+            if (state.awake.on)
+                void ctx.actions.run({ args: ['awake', 'off'], title: 'Turn awake off?', noConfirm: true, done: 'Awake is off. The Mac sleeps normally.' });
+            else
+                void ctx.actions.run({
+                    args: ['awake', 'on'],
+                    title: 'Keep this Mac awake?',
+                    body: `The lid can close and the Mac keeps running. It stays on until the battery drops to ${state.awake.batteryFloor}% or you run "vsf awake off".`,
+                    confirmLabel: 'Turn on',
+                    cancelLabel: 'Cancel',
+                    done: 'Awake is on',
+                });
+        }
+        else if (input === 'r' && parked[sel]) {
+            const card = parked[sel].card;
+            void ctx.actions.run({
+                args: ['agents', 'retry', card],
+                title: `Retry ${card}?`,
+                body: `Queues ${card} again. The runner picks it up on its next check.`,
+                confirmLabel: 'Retry card',
+                cancelLabel: 'Cancel',
+                done: `${card} queued again`,
+            });
+        }
+        else if (input === 'u') {
+            void ctx.actions.run({
+                args: ['update'],
+                title: 'Update VoidShift?',
+                body: `Updates vsf${update ? ` to ${update}` : ''} and every tool you added. This can take a minute. Start vsf again afterwards to use it.`,
+                confirmLabel: 'Update',
+                cancelLabel: 'Cancel',
+                timeoutMs: 10 * 60_000,
+                done: 'Update finished. Start vsf again to use it.',
+            });
+        }
+        else if (input === 'c')
+            refreshChecks();
+    });
+    const panels = [];
+    if (sections.includes('agents'))
+        panels.push(h(AgentsPanel, { key: 'agents', focused: at === 'agents', selected: sel, now }));
+    const lower = [];
+    // Whole-number widths: halves of an odd width would misalign the borders.
+    const count = ['awake', 'memory'].filter((t) => state.tools.includes(t)).length;
+    const gap = count === 2 ? 1 : 0;
+    const left = count === 2 ? Math.floor((ctx.columns - gap) / 2) : ctx.columns;
+    if (state.tools.includes('awake'))
+        lower.push(h(Panel, { key: 'awake', title: 'Awake', focused: at === 'awake', width: left }, state.awake ? h(Lines, { lines: awakeLines(state.awake) }) : toolState(state.errors.awake)));
+    if (state.tools.includes('memory'))
+        lower.push(h(Box, { key: 'memory', marginLeft: lower.length ? gap : 0 }, h(Panel, { title: 'Memory', focused: at === 'memory', width: lower.length ? ctx.columns - gap - left : ctx.columns }, state.memory ? h(Lines, { lines: memoryLines(state.memory) }) : toolState(state.errors.memory))));
+    if (lower.length)
+        panels.push(h(Box, { key: 'lower', flexDirection: 'row' }, ...lower));
+    panels.push(h(ChecksPanel, { key: 'checks', focused: at === 'checks' }));
+    if (!state.tools.length && state.loaded)
+        panels.unshift(h(Text, { key: 'none', color: theme.dim }, ' No tools added yet. Run vsf setup in a terminal to pick some.'));
+    return h(Box, { flexDirection: 'column' }, ...panels);
+}
+const toolState = (error) => h(Text, { color: error ? theme.yellow : theme.dim, wrap: 'truncate-end' }, error ?? 'Loading...');
+function AgentsPanel(props) {
+    const { state } = useData();
+    const agents = state.agents;
+    if (!agents)
+        return h(Panel, { title: 'Agents', focused: props.focused }, toolState(state.errors.agents));
+    const run = runnerLines(agents, props.now);
+    const live = liveCard(state, props.now);
+    const parked = parkedRows(agents);
+    const rows = [h(SplitRow, { key: 'runner', left: run.left, right: run.right })];
+    if (live) {
+        rows.push(h(Text, { key: 'g1' }, ' '));
+        rows.push(h(SplitRow, {
+            key: 'live',
+            left: [seg('▶ ', theme.accent), seg(live.card, theme.accent, { bold: true }), seg(`  ${truncate(live.title, 60)}`)],
+            right: [seg(live.workflow, theme.dim)],
+        }));
+        rows.push(h(Box, { key: 'steps', flexDirection: 'row' }, h(Text, null, '  '), h(ProgressSteps, { steps: live.steps }), h(Text, { color: theme.dim }, `       running ${duration(live.minutes * 60_000)}${live.maxRounds ? ` · round ${live.round} of ${live.maxRounds}` : ` · round ${live.round}`}`)));
+    }
+    else if (agents.current) {
+        rows.push(h(Text, { key: 'g1' }, ' '));
+        rows.push(h(Text, { key: 'checking', color: theme.dim }, '  Checking Linear now.'));
+    }
+    if (parked.length) {
+        rows.push(h(Text, { key: 'g2' }, ' '));
+        parked.forEach((p, i) => {
+            const on = props.focused && i === props.selected;
+            rows.push(h(SplitRow, {
+                key: `p${p.card}`,
+                left: [seg(p.kind === 'parked' ? '! ' : '○ ', p.kind === 'parked' ? theme.yellow : theme.dim), seg(p.card, p.kind === 'parked' ? theme.yellow : theme.dim, { bold: on }), seg(`  ${p.text}`)],
+                right: on || parked.length === 1 ? [seg('r retry · enter details', theme.dim)] : [],
+            }));
+        });
+    }
+    rows.push(h(Text, { key: 'g3' }, ' '));
+    rows.push(h(Text, { key: 'counts', color: theme.dim }, countsLine(agents, state.runs, props.now)));
+    for (const key of ['agents.runs', 'agents']) {
+        if (state.errors[key])
+            rows.push(h(Text, { key: `e${key}`, color: theme.yellow, wrap: 'truncate-end' }, `! ${state.errors[key]}`));
+    }
+    return h(Panel, { title: 'Agents', focused: props.focused }, ...rows);
+}
+function ChecksPanel(props) {
+    const { state } = useData();
+    if (state.checks && state.checks.length === 0 && process.env.VSF_TUI_SKIP_CHECKS === '1')
+        return h(Panel, { title: 'Checks', focused: props.focused }, h(Text, { color: theme.dim }, 'Checks skipped'));
+    if (!state.checks)
+        return h(Panel, { title: 'Checks', focused: props.focused }, toolState(state.errors.checks ?? (state.checksAt === null ? 'Checking…' : undefined)));
+    return h(Panel, { title: 'Checks', focused: props.focused }, ...checksLines(state.checks).map((r, i) => h(SplitRow, { key: i, left: r.left, right: r.right })));
+}

package/dist/tui/keys.d.ts

@@ -0,0 +1,2 @@
+export declare function splitKeys(chunk: string): string[];
+export declare function useKeyBatching(keepWhole: () => boolean): void;

package/dist/tui/keys.js

@@ -0,0 +1,107 @@
+// Key batching. A terminal can hand over several keys in one chunk (fast typing,
+// key repeat, a paste). Ink hands a plain-text chunk such as "\r\r" to useInput
+// as one key and runs a burst of keys without letting the screen update between
+// them, so only one takes effect. This splits a chunk into single keys and
+// delivers them one per tick.
+import { useEffect, useRef } from 'react';
+import { useStdin } from 'ink';
+const ESC = '\u001b';
+const PASTE_START = '\u001b[200~';
+// Length of the escape sequence starting at s[i] (s[i] is ESC).
+function escapeLength(s, i) {
+    let j = i + 1;
+    if (j >= s.length)
+        return 1;
+    if (s[j] === ESC) {
+        // ESC ESC [ ... : a double-prefixed sequence. Otherwise a lone ESC.
+        if (s[j + 1] !== '[' && s[j + 1] !== 'O')
+            return 1;
+        j++;
+    }
+    const kind = s[j];
+    if (kind === '[') {
+        j++;
+        if (s[j] === '[')
+            j++;
+        while (j < s.length) {
+            const c = s.charCodeAt(j);
+            j++;
+            if (c >= 0x40 && c <= 0x7e)
+                return j - i;
+        }
+        return s.length - i;
+    }
+    if (kind === 'O') {
+        j++;
+        while (j < s.length) {
+            const c = s.charCodeAt(j);
+            j++;
+            if (c >= 0x40 && c <= 0x7e)
+                return j - i;
+        }
+        return s.length - i;
+    }
+    // ESC plus one character (alt+key).
+    return j + (s.codePointAt(j) > 0xffff ? 2 : 1) - i;
+}
+// Splits a raw input chunk into single keys: escape sequences (\x1b[C, \x1bOA),
+// a lone \x1b, \r, \t, control bytes and each printable character. A chunk with
+// a bracketed paste is left whole.
+export function splitKeys(chunk) {
+    if (chunk.includes(PASTE_START))
+        return [chunk];
+    const keys = [];
+    let i = 0;
+    while (i < chunk.length) {
+        if (chunk[i] === ESC) {
+            const n = escapeLength(chunk, i);
+            keys.push(chunk.slice(i, i + n));
+            i += n;
+        }
+        else {
+            const n = chunk.codePointAt(i) > 0xffff ? 2 : 1;
+            keys.push(chunk.slice(i, i + n));
+            i += n;
+        }
+    }
+    return keys;
+}
+// Makes the stdin Ink reads hand over one key per tick. While `keepWhole()` is
+// true (a text input has focus) chunks go through unsplit, so typed or pasted
+// text reaches the input as today.
+export function useKeyBatching(keepWhole) {
+    const { stdin } = useStdin();
+    const whole = useRef(keepWhole);
+    whole.current = keepWhole;
+    useEffect(() => {
+        const s = stdin;
+        const original = s.read;
+        const queue = [];
+        let gate = false;
+        s.read = function () {
+            if (gate)
+                return null;
+            let item = queue.shift();
+            if (item === undefined) {
+                const raw = original.call(s);
+                if (raw === null || raw === undefined)
+                    return raw ?? null;
+                const text = typeof raw === 'string' ? raw : Buffer.from(raw).toString('utf8');
+                const keys = whole.current() ? [text] : splitKeys(text);
+                item = keys[0];
+                queue.push(...keys.slice(1));
+                if (item === undefined)
+                    return null;
+            }
+            gate = true;
+            setTimeout(() => {
+                gate = false;
+                s.emit('readable');
+            }, 0);
+            return item;
+        };
+        return () => {
+            s.read = original;
+        };
+    }, [stdin]);
+}

package/dist/tui/nav.d.ts

@@ -0,0 +1,24 @@
+export type Params = Record<string, unknown>;
+export interface Route {
+    id: string;
+    params: Params;
+}
+export type NavAction = {
+    type: 'push';
+    id: string;
+    params?: Params;
+} | {
+    type: 'replace';
+    id: string;
+    params?: Params;
+} | {
+    type: 'pop';
+} | {
+    type: 'reset';
+    id: string;
+    params?: Params;
+};
+export declare const HOME = "home";
+export declare const initialStack: () => Route[];
+export declare function navReducer(stack: Route[], action: NavAction): Route[];
+export declare function breadcrumb(stack: Route[], titles: (route: Route) => string[]): string[];

package/dist/tui/nav.js

@@ -0,0 +1,32 @@
+// The screen stack. Pure, so it is easy to test: the app feeds actions in.
+export const HOME = 'home';
+export const initialStack = () => [{ id: HOME, params: {} }];
+const same = (a, b) => a.id === b.id && JSON.stringify(a.params) === JSON.stringify(b.params);
+export function navReducer(stack, action) {
+    switch (action.type) {
+        case 'push': {
+            const next = { id: action.id, params: action.params ?? {} };
+            // Pushing the screen you are already on does nothing.
+            return same(stack[stack.length - 1], next) ? stack : [...stack, next];
+        }
+        case 'replace':
+            return [...stack.slice(0, -1), { id: action.id, params: action.params ?? {} }];
+        case 'pop':
+            // The first screen never leaves the stack.
+            return stack.length > 1 ? stack.slice(0, -1) : stack;
+        case 'reset':
+            return [{ id: action.id, params: action.params ?? {} }];
+    }
+}
+// Breadcrumb for the header. `titles` are each route's crumbs. Screens below
+// the top one give only their first crumb, so [home, agents, agents.log]
+// reads "Agents > ENG-1412 > QA log". Home is not part of the trail.
+export function breadcrumb(stack, titles) {
+    const rest = stack.filter((r) => r.id !== HOME);
+    const out = [];
+    rest.forEach((r, i) => {
+        const t = titles(r);
+        out.push(...(i === rest.length - 1 ? t : t.slice(0, 1)));
+    });
+    return out;
+}

package/dist/tui/palette.d.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import type { ActionResult } from './actions.ts';
+import type { DataState } from './data.ts';
+export interface PaletteEntry {
+    text: string;
+    desc?: string;
+    prefix: string;
+    runnable: boolean;
+    dynamic?: boolean;
+}
+export declare function splitCommand(text: string): string[];
+export declare function makeEntry(text: string, desc?: string, dynamic?: boolean): PaletteEntry;
+export declare function parseHelpLines(tool: string, text: string): PaletteEntry[];
+export declare function parseUsages(usages: Record<string, string>): PaletteEntry[];
+export declare function dynamicEntries(state: Pick<DataState, 'agents' | 'runs' | 'steps'>): PaletteEntry[];
+export declare function filterPalette(entries: PaletteEntry[], query: string): PaletteEntry[];
+export declare function completion(entry: PaletteEntry): string;
+export type EnterAction = {
+    run: string[];
+} | {
+    fill: string;
+} | {
+    none: true;
+};
+export declare function onEnter(entry: PaletteEntry | undefined, query: string): EnterAction;
+export interface PaletteProps {
+    umbrella: PaletteEntry[];
+    onClose(): void;
+    onRun(args: string[]): Promise<ActionResult>;
+    onTerminal(args: string[]): void;
+}
+export declare function Palette(props: PaletteProps): React.ReactElement;