@voidlabs.gg/voidshift 0.0.0-stage → 0.4.1

package/dist/tui/screens/runs.js

@@ -0,0 +1,420 @@
+// The Runs tab of the agents screen: every run newest first, the selected run
+// in detail below, and the keys to open its log, cancel, retry, run from a
+// step, clean old runs and filter. Every action is a real vsf command.
+import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { Box, Text } from 'ink';
+import { join } from 'node:path';
+import { configDir } from "../../config.js";
+import { runAction } from "../actions.js";
+import { useBackGuard, useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { useData } from "../data.js";
+import { duration, folderStamp, stamp, tilde, truncate } from "../format.js";
+import { Lines, Panel, Select, Table, TextInput, outcomeColour, seg } from "../widgets.js";
+import { theme } from "../theme.js";
+const h = React.createElement;
+// ---- pure helpers ----------------------------------------------------------
+// Where "Run from step" writes the output of the detached run.
+export const manualLogPath = (dir) => join(dir, 'agents', 'manual.log');
+// Shared with the agents shell: while the step picker is on screen, left and
+// right belong to it, not to the tab bar.
+export const tabLock = { on: false };
+// Runs whose card or workflow contains the text (case does not matter).
+export function filterRuns(runs, text) {
+    const q = text.trim().toLowerCase();
+    if (!q)
+        return runs;
+    return runs.filter((r) => r.card.toLowerCase().includes(q) || (r.record?.workflow ?? '').toLowerCase().includes(q));
+}
+// "Dev → QA": step labels in order, each once.
+export function stepsLabel(steps) {
+    const seen = [];
+    for (const s of steps)
+        if (!seen.includes(s.label))
+            seen.push(s.label);
+    return seen.join(' → ');
+}
+// How many times the first step started: the number of rounds begun.
+export function roundsOf(steps) {
+    const first = steps[0]?.step;
+    return first ? steps.filter((s) => s.step === first).length : 0;
+}
+export function runMs(run, nowMs) {
+    const rec = run.record;
+    if (!rec)
+        return null;
+    const start = Date.parse(rec.startedAt);
+    if (Number.isNaN(start))
+        return null;
+    const end = rec.endedAt ? Date.parse(rec.endedAt) : nowMs;
+    return Math.max(0, end - start);
+}
+// The outcome shown for a run. A run that says "running" while the runner is
+// busy with something else was cut off.
+export function outcomeOf(run, state) {
+    const outcome = run.record?.outcome;
+    if (!outcome)
+        return 'old run';
+    if (outcome === 'running' && state.agents && state.agents.current?.card !== run.card)
+        return 'interrupted';
+    return outcome;
+}
+export function isLive(run, state) {
+    if (!run || run.record?.outcome !== 'running')
+        return false;
+    const cur = state.agents?.current;
+    return !!cur && cur.card === run.card && (!cur.runDir || cur.runDir === run.dir);
+}
+export function startedText(run) {
+    const t = run.record ? Date.parse(run.record.startedAt) : NaN;
+    return Number.isNaN(t) ? folderStamp(run.stamp) : stamp(new Date(t));
+}
+// The steps of a run for display. When the run is not live, a step that never
+// got an end (cancelled, cut off) is shown as stopped at the end of the run.
+export function settledSteps(run, state) {
+    const steps = run.record?.steps ?? [];
+    if (isLive(run, state))
+        return steps;
+    return steps.map((s) => (s.endedAt ? s : { ...s, endedAt: run.record?.endedAt ?? s.startedAt, result: 'stopped' }));
+}
+// Which glyph and colour a step gets. Plain checks (SHIP, SKIP, done) pass.
+export function stepMark(step) {
+    if (!step.endedAt)
+        return { glyph: '◐', colour: theme.accent };
+    const r = (step.result ?? '').toUpperCase();
+    if (r === 'FIX')
+        return { glyph: '↻', colour: theme.yellow };
+    if (r === 'BLOCKED')
+        return { glyph: '✗', colour: theme.red };
+    if (r === 'STOPPED')
+        return { glyph: '-', colour: theme.dim };
+    return { glyph: '✓', colour: theme.green };
+}
+export const stepResult = (step) => (step.endedAt ? (step.result ?? 'done').toLowerCase() : '...');
+export function stepMs(step, nowMs) {
+    const start = Date.parse(step.startedAt);
+    if (Number.isNaN(start))
+        return null;
+    const end = step.endedAt ? Date.parse(step.endedAt) : nowMs;
+    return Math.max(0, end - start);
+}
+export const stepDuration = (step, nowMs) => {
+    const ms = stepMs(step, nowMs);
+    return ms === null ? '' : duration(ms);
+};
+// One line per step: mark, name, result, time, summary.
+export function stepLine(step, nowMs) {
+    const m = stepMark(step);
+    return [
+        seg(`${m.glyph} `, m.colour),
+        seg(step.label.padEnd(8)),
+        seg(stepResult(step).padEnd(7), step.endedAt ? undefined : theme.dim),
+        seg(stepDuration(step, nowMs).padStart(4) + '  ', theme.dim),
+        seg(truncate(step.summary ?? '', 300), theme.dim),
+    ];
+}
+// Window of `size` rows that keeps `selected` in view.
+export function windowStart(total, selected, size, start) {
+    if (total <= size)
+        return 0;
+    let s = Math.min(start, total - size);
+    if (selected < s)
+        s = selected;
+    if (selected >= s + size)
+        s = selected - size + 1;
+    return Math.max(0, s);
+}
+export function runsKey(input, key) {
+    if (key.return)
+        return 'open';
+    if (key.upArrow)
+        return 'up';
+    if (key.downArrow)
+        return 'down';
+    if (input === 'c')
+        return 'cancel';
+    if (input === 'r')
+        return 'retry';
+    if (input === 'f')
+        return 'from';
+    if (input === 'x')
+        return 'clean';
+    if (input === '/')
+        return 'filter';
+    return null;
+}
+// The confirm text from the approved mockup.
+export function cancelSpec(card, stepLabel) {
+    return {
+        args: ['agents', 'cancel', card],
+        title: `Cancel ${card}?`,
+        body: `Stops the ${stepLabel || 'running'} agent now. The card loses its VoidShift labels and gets a comment; add vs-plan again to restart it.`,
+        confirmLabel: 'Cancel card',
+        cancelLabel: 'Keep running',
+        done: `${card} cancelled`,
+    };
+}
+export const RUN_HINTS = [
+    { key: 'enter', label: 'live log' },
+    { key: 'c', label: 'cancel' },
+    { key: 'r', label: 'retry' },
+    { key: 'f', label: 'run from step' },
+    { key: 'x', label: 'clean old' },
+    { key: '/', label: 'filter' },
+    { key: 'esc', label: 'back' },
+];
+// The step to open the log on: the running one, else the last that ran.
+export function logStepOf(run) {
+    const steps = run.record?.steps ?? [];
+    return [...steps].reverse().find((s) => !s.endedAt) ?? steps[steps.length - 1];
+}
+// ---- labels from `vsf agents show CARD --json` -------------------------------
+const labelCache = new Map();
+const LABELS_TTL_MS = 60_000;
+export async function fetchLabelsReal(card) {
+    const r = await runAction(['agents', 'show', card, '--json'], { timeoutMs: 15_000 });
+    if (r.code !== 0)
+        return null;
+    try {
+        const labels = JSON.parse(r.output).labels;
+        return Array.isArray(labels) ? labels.map(String) : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Swapped out in tests.
+export const runsDeps = { fetchLabels: fetchLabelsReal, debounceMs: 500 };
+function useLabels(card) {
+    const [labels, setLabels] = useState(card ? (labelCache.get(card)?.labels ?? null) : null);
+    useEffect(() => {
+        if (!card || process.env.VSF_TUI_NO_LABELS === '1') {
+            setLabels(null);
+            return;
+        }
+        const hit = labelCache.get(card);
+        setLabels(hit?.labels ?? null);
+        if (hit && Date.now() - hit.at < LABELS_TTL_MS)
+            return;
+        let live = true;
+        const t = setTimeout(() => {
+            runsDeps.fetchLabels(card).then((l) => {
+                labelCache.set(card, { at: Date.now(), labels: l });
+                if (live)
+                    setLabels(l);
+            }, () => { });
+        }, runsDeps.debounceMs);
+        return () => {
+            live = false;
+            clearTimeout(t);
+        };
+    }, [card]);
+    return labels;
+}
+export function Runs(props) {
+    const ctx = useScreen();
+    const { state } = useData();
+    const [now, setNow] = useState(Date.now());
+    const [mode, setMode] = useState('list');
+    const [filter, setFilter] = useState('');
+    const [selDir, setSelDir] = useState(null);
+    const [from, setFrom] = useState('');
+    const start = useRef(0);
+    useEffect(() => {
+        const t = setInterval(() => setNow(Date.now()), 1000);
+        return () => clearInterval(t);
+    }, []);
+    const wanted = typeof props.params.card === 'string' ? props.params.card : null;
+    const runs = useMemo(() => filterRuns(state.runs, filter), [state.runs, filter]);
+    let index = selDir ? runs.findIndex((r) => r.dir === selDir) : -1;
+    if (index < 0 && !selDir && wanted)
+        index = runs.findIndex((r) => r.card === wanted);
+    if (index < 0)
+        index = 0;
+    const run = runs[index];
+    const record = run?.record;
+    const isLatest = !!run && state.runs.find((r) => r.card === run.card)?.dir === run.dir;
+    const labels = useLabels(isLatest && record ? run.card : undefined);
+    const live = isLive(run, state);
+    const liveStep = state.agents?.current?.step;
+    const workflow = state.workflows.find((w) => w.name === record?.workflow);
+    const stepIds = workflow?.steps ?? [...new Set((record?.steps ?? []).map((s) => s.step))];
+    const labelOf = (id) => state.steps?.steps.find((s) => s.id === id)?.label ?? record?.steps.find((s) => s.step === id)?.label ?? id;
+    const options = stepIds.map((id) => ({ value: id, label: labelOf(id) }));
+    useEquivalent(mode === 'pick' && run && from ? ['agents', 'run', run.card, '--from', from] : null);
+    useEffect(() => {
+        tabLock.on = mode === 'pick';
+        return () => {
+            tabLock.on = false;
+        };
+    }, [mode]);
+    useHints(mode === 'filter'
+        ? [
+            { key: 'enter', label: 'apply' },
+            { key: 'esc', label: 'clear' },
+        ]
+        : mode === 'pick'
+            ? [
+                { key: '←→', label: 'choose step' },
+                { key: 'enter', label: 'list' },
+                { key: 'g', label: 'run' },
+                { key: 'esc', label: 'cancel' },
+            ]
+            : filter
+                ? [...RUN_HINTS.slice(0, -1), { key: 'esc', label: 'clear filter' }]
+                : RUN_HINTS);
+    useBackGuard(() => {
+        if (mode === 'pick') {
+            setMode('list');
+            return true;
+        }
+        if (filter) {
+            setFilter('');
+            return true;
+        }
+        return false;
+    });
+    const move = (delta) => {
+        const next = runs[Math.max(0, Math.min(runs.length - 1, index + delta))];
+        if (next)
+            setSelDir(next.dir);
+    };
+    useKeys((input, key) => {
+        if (mode === 'filter') {
+            if (key.escape) {
+                setFilter('');
+                setMode('list');
+            }
+            return;
+        }
+        if (mode === 'pick') {
+            if (!ctx.capturing && input === 'g' && run && from) {
+                const label = labelOf(from);
+                setMode('list');
+                void ctx.actions
+                    .confirm({
+                    title: `Run ${run.card} from ${label}?`,
+                    body: `Starts the ${label} step of ${record?.workflow ?? 'the workflow'} on ${run.card} in the background. Watch it here as it runs. Output goes to ${tilde(manualLogPath(configDir()))}.`,
+                    confirmLabel: 'Run',
+                    cancelLabel: 'Cancel',
+                })
+                    .then((ok) => {
+                    if (ok)
+                        ctx.actions.detach(['agents', 'run', run.card, '--from', from], manualLogPath(configDir()), `Started ${run.card} from ${label}`);
+                });
+            }
+            return;
+        }
+        const action = runsKey(input, key);
+        if (action === 'up')
+            move(-1);
+        else if (action === 'down')
+            move(1);
+        else if (action === 'filter')
+            setMode('filter');
+        else if (action === 'clean')
+            void ctx.actions.run({
+                args: ['agents', 'clean', '--yes'],
+                title: 'Clean old runs?',
+                body: 'Removes run folders and worktrees older than 14 days. Work in progress is kept.',
+                confirmLabel: 'Clean',
+                cancelLabel: 'Keep them',
+            });
+        else if (!run)
+            return;
+        else if (action === 'open') {
+            const step = logStepOf(run);
+            if (!run.logs.length)
+                ctx.toast('This run has no logs yet.', 'info');
+            else
+                ctx.nav.push('agents.log', { card: run.card, dir: run.dir, ...(step ? { step: step.step, stepLabel: step.label } : {}) });
+        }
+        else if (action === 'cancel') {
+            if (!live)
+                ctx.toast(`${run.card} is not running, so there is nothing to cancel.`, 'info');
+            else
+                void ctx.actions.run(cancelSpec(run.card, liveStep));
+        }
+        else if (action === 'retry')
+            void ctx.actions.run({
+                args: ['agents', 'retry', run.card],
+                title: `Retry ${run.card}?`,
+                body: `Queues ${run.card} again. The runner picks it up on its next check.`,
+                confirmLabel: 'Retry card',
+                cancelLabel: 'Cancel',
+                done: `${run.card} queued again`,
+            });
+        else if (action === 'from') {
+            if (live)
+                ctx.toast(`${run.card} is running. Cancel it first.`, 'info');
+            else if (!options.length)
+                ctx.toast('No steps known for this run.', 'info');
+            else {
+                const last = record?.steps[record.steps.length - 1]?.step;
+                setFrom(last && stepIds.includes(last) ? last : stepIds[0]);
+                setMode('pick');
+            }
+        }
+    }, { whileCapturing: true });
+    // ---- layout ----
+    const steps = (run ? settledSteps(run, state) : []).slice(-8);
+    const detailRows = Math.max(2, steps.length) + 2 + (record?.outcome === 'parked' && record.reason ? 1 : 0) + (mode === 'pick' ? 2 : 0);
+    const listSize = Math.max(3, ctx.rows - 5 - 3 - (detailRows + 2));
+    start.current = windowStart(runs.length, index, listSize, start.current);
+    const shown = runs.slice(start.current, start.current + listSize);
+    const wide = ctx.columns >= 96;
+    const rows = shown.map((r) => {
+        const outcome = outcomeOf(r, state);
+        const ms = runMs(r, now);
+        return [
+            { text: r.card, bold: true },
+            startedText(r),
+            r.record?.workflow ?? '',
+            stepsLabel(r.record?.steps ?? []),
+            { text: outcome, colour: outcome === 'interrupted' ? theme.yellow : outcomeColour(outcome) },
+            String(roundsOf(r.record?.steps ?? [])),
+            ms === null ? '' : duration(ms),
+        ];
+    });
+    const cols = [
+        { title: 'CARD', width: 10 },
+        { title: 'STARTED', width: 14 },
+        { title: 'WORKFLOW', width: wide ? 20 : 14 },
+        { title: 'STEPS', width: wide ? 14 : 12 },
+        { title: 'OUTCOME', width: 12 },
+        { title: 'ROUNDS', width: 8 },
+        { title: 'TIME' },
+    ];
+    const empty = !state.loaded ? 'Loading...' : filter ? `No runs match "${filter}".` : 'No runs yet. They appear here when a card is picked up.';
+    const title = filter && mode !== 'filter' ? `Runs matching "${filter}"` : 'Runs, newest first';
+    const detail = steps.map((s) => stepLine(s, now));
+    if (record && !steps.length)
+        detail.push([seg('No steps yet.', theme.dim)]);
+    if (record?.outcome === 'parked' && record.reason)
+        detail.push([seg('Parked: ', theme.yellow), seg(truncate(record.reason, 300))]);
+    if (record) {
+        detail.push([]);
+        const tail = [];
+        if (record.prUrl)
+            tail.push(seg('PR ', theme.dim), seg(record.prUrl.replace(/^https?:\/\//, ''), theme.accent), seg('   '));
+        if (labels)
+            tail.push(seg('labels ', theme.dim), seg(labels.join(' ') || 'none'));
+        else if (!record.prUrl)
+            tail.push(seg('No PR yet', theme.dim));
+        detail.push(tail);
+    }
+    else if (run)
+        detail.push([seg('This run has logs only. Enter opens them.', theme.dim)]);
+    return h(Box, { flexDirection: 'column' }, h(Panel, { title, focused: mode !== 'pick', subtitle: mode === 'filter' ? undefined : runs.length > shown.length ? `${index + 1} of ${runs.length}` : undefined }, mode === 'filter'
+        ? h(Box, null, h(Text, { color: theme.dim }, 'Filter by card or workflow: '), h(TextInput, { value: filter, onChange: setFilter, onSubmit: () => setMode('list'), placeholder: 'ENG-12 or tether' }))
+        : null, h(Table, { columns: cols, rows, selected: index - start.current, empty })), run
+        ? h(Panel, { title: `${run.card}${record?.title ? '  ' + truncate(record.title, Math.max(10, ctx.columns - 20)) : ''}`, focused: mode === 'pick' }, h(Lines, { lines: detail }), mode === 'pick'
+            ? h(Box, { marginTop: 1 }, h(Text, { color: theme.dim }, `Run ${run.card} from: `), h(Select, { options, value: from, onChange: setFrom }))
+            : null)
+        : null);
+}
+export const runsScreen = {
+    id: 'agents.runs',
+    title: 'Runs',
+    component: Runs,
+    hints: () => RUN_HINTS,
+};

package/dist/tui/screens/settings.d.ts

@@ -0,0 +1,17 @@
+import type { Screen } from '../screens.ts';
+export interface SettingRow {
+    key: string;
+    shown: string;
+    edit: string;
+    secret: boolean;
+    hint: string;
+}
+export declare const isSkipped: (key: string) => boolean;
+export declare function editText(value: unknown): string;
+export declare function settingRows(tool: string, config: Record<string, unknown> | null): SettingRow[];
+export declare const hasOtherScreens: (tool: string, config: Record<string, unknown> | null) => boolean;
+export declare const setArgs: (key: string, value: string) => string[];
+export declare const unsetArgs: (key: string) => string[];
+export declare function problemLine(output: string): string;
+export declare const nextIndex: (count: number, index: number, delta: number) => number;
+export declare const settingsScreen: Screen;

package/dist/tui/screens/settings.js

@@ -0,0 +1,153 @@
+// Settings: every config key of each added tool, edited inline. Saving runs
+// `vsf config set KEY VALUE`, so the same validation as the command applies.
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { flatten, mask, parseValue } from "../../dotted.js";
+import { useData } from "../data.js";
+import { useEquivalent, useHints, useKeys, useScreen } from "../context.js";
+import { theme } from "../theme.js";
+import { Panel, TextInput } from "../widgets.js";
+import { fitCell } from "../widgets.js";
+import { windowOf } from "./list-window.js";
+const h = React.createElement;
+// Big structured keys that have their own screens.
+const SKIPPED = ['agents.projects', 'agents.workflows', 'agents.homes', 'agents.enabled', 'memory.homes'];
+const HINTS = {
+    'agents.engine': 'claude or codex',
+    'agents.timeoutMinutes': 'minutes before a step is stopped',
+    'agents.reviewState': 'Linear state for verified cards',
+    'awake.battery': 'battery floor, 5 to 95',
+    'awake.heat': 'stop when the Mac runs hot',
+    'awake.revertOnReboot': 'turn off again after a reboot',
+};
+export const isSkipped = (key) => SKIPPED.some((s) => key === s || key.startsWith(s + '.'));
+const show = (v) => (typeof v === 'string' ? v : JSON.stringify(v));
+// The text an edit starts with: strings as typed, everything else as JSON.
+export function editText(value) {
+    if (typeof value === 'string')
+        return parseValue(value) === value ? value : JSON.stringify(value);
+    return JSON.stringify(value) ?? '';
+}
+// The rows for one tool, with its name in front of every key ("agents.engine").
+export function settingRows(tool, config) {
+    const rows = [];
+    for (const [path, value] of flatten(config ?? {})) {
+        const key = `${tool}.${path}`;
+        if (isSkipped(key))
+            continue;
+        const masked = mask(key, value);
+        const secret = masked !== value;
+        rows.push({ key, shown: show(masked), edit: secret ? '' : editText(value), secret, hint: HINTS[key] ?? '' });
+    }
+    return rows;
+}
+// True when the tool has settings that live on other screens.
+export const hasOtherScreens = (tool, config) => Object.keys(config ?? {}).some((k) => isSkipped(`${tool}.${k}`));
+// `vsf config set KEY -- VALUE` keeps a value like -5 from being read as a flag.
+export const setArgs = (key, value) => ['config', 'set', key, ...(value.startsWith('-') ? ['--'] : []), value];
+export const unsetArgs = (key) => ['config', 'unset', key];
+// The command's own problem line, for showing next to the row.
+export function problemLine(output) {
+    return output.split('\n').map((l) => l.trim()).find(Boolean) ?? 'The change was not saved.';
+}
+export const nextIndex = (count, index, delta) => (count === 0 ? 0 : Math.max(0, Math.min(count - 1, index + delta)));
+const BASE_HINTS = [
+    { key: 'enter', label: 'edit' },
+    { key: 'u', label: 'reset' },
+    { key: 'e', label: '$EDITOR' },
+    { key: 'esc', label: 'back' },
+];
+function Settings(props) {
+    const ctx = useScreen();
+    const data = useData();
+    const tools = data.state.tools.filter((t) => data.readConfig(t) !== null);
+    const wanted = typeof props.params.tool === 'string' ? props.params.tool : tools[0];
+    const [toolName, setToolName] = useState(wanted);
+    const tool = toolName && tools.includes(toolName) ? toolName : tools[0];
+    const config = tool ? data.readConfig(tool) : null;
+    const rows = settingRows(tool ?? '', config);
+    const [sel, setSel] = useState(0);
+    const at = Math.min(sel, Math.max(0, rows.length - 1));
+    const row = rows[at];
+    const [editing, setEditing] = useState(false);
+    const [text, setText] = useState('');
+    const [error, setError] = useState('');
+    const [saving, setSaving] = useState(false);
+    useHints(editing ? [{ key: 'enter', label: 'save' }, { key: 'esc', label: 'cancel edit' }] : tools.length > 1 ? [...BASE_HINTS.slice(0, 3), { key: 'tab', label: 'tool' }, BASE_HINTS[3]] : BASE_HINTS);
+    useEquivalent(row ? (editing ? setArgs(row.key, text) : ['config', 'set', row.key]) : null);
+    const save = async (value) => {
+        if (!row || saving)
+            return;
+        setSaving(true);
+        const result = await ctx.actions.run({ args: setArgs(row.key, value), title: `Save ${row.key}`, noConfirm: true, done: `Saved ${row.key}` });
+        setSaving(false);
+        if (result && result.code === 0) {
+            setEditing(false);
+            setError('');
+        }
+        else if (result)
+            setError(problemLine(result.output));
+    };
+    useKeys((input, key) => {
+        if (editing) {
+            if (key.escape) {
+                setEditing(false);
+                setError('');
+            }
+            return;
+        }
+        if (key.upArrow)
+            setSel(nextIndex(rows.length, at, -1));
+        else if (key.downArrow)
+            setSel(nextIndex(rows.length, at, 1));
+        else if (key.tab && tools.length > 1) {
+            const i = tools.indexOf(tool ?? '');
+            setToolName(tools[(i + (key.shift ? tools.length - 1 : 1)) % tools.length]);
+            setSel(0);
+            setError('');
+        }
+        else if (key.return && row) {
+            setText(row.edit);
+            setError('');
+            setEditing(true);
+        }
+        else if (input === 'u' && row) {
+            void ctx.actions.run({
+                args: unsetArgs(row.key),
+                title: `Reset ${row.key}?`,
+                body: 'Removes your saved value, so the default applies again.',
+                confirmLabel: 'Reset',
+                cancelLabel: 'Keep it',
+            });
+        }
+        else if (input === 'e' && tool)
+            void ctx.actions.terminal(['config', 'edit', tool]);
+    }, { whileCapturing: true });
+    if (!tool) {
+        return h(Box, { paddingX: 1 }, h(Text, { color: theme.dim }, 'No added tool has settings yet.'));
+    }
+    const keyWidth = Math.min(34, Math.max(12, ...rows.map((r) => r.key.length - tool.length)) + 2);
+    const valueWidth = Math.min(26, Math.max(10, ...rows.map((r) => r.shown.length)) + 2);
+    const size = Math.max(4, ctx.rows - 14);
+    const win = windowOf(rows.length, at, size);
+    const other = hasOtherScreens(tool, config);
+    return h(Box, { flexDirection: 'row' }, h(Panel, { title: 'Tools', width: 16 }, ...tools.map((t) => h(Text, { key: t, color: t === tool ? theme.bold : theme.text, bold: t === tool }, `${t === tool ? '▶' : ' '} ${t}`))), h(Panel, { title: tool, focused: true, flexGrow: 1 }, rows.length === 0 ? h(Text, { color: theme.dim }, 'Nothing is saved yet. Defaults apply.') : null, ...rows.slice(win.start, win.end).map((r, i) => {
+        const index = win.start + i;
+        const on = index === at;
+        const bg = on ? theme.selected : undefined;
+        const name = r.key.slice(tool.length + 1);
+        return h(Box, { key: r.key, flexDirection: 'row' }, h(Text, { backgroundColor: bg, color: theme.accent }, on ? '▶ ' : '  '), h(Text, { backgroundColor: bg, bold: on, color: on ? theme.bold : theme.text }, fitCell(name, keyWidth)), on && editing
+            ? h(Box, { flexGrow: 1 }, h(TextInput, { value: text, onChange: setText, mask: r.secret, onSubmit: (v) => void save(v) }))
+            : h(Text, { backgroundColor: bg, bold: on }, fitCell(r.shown, valueWidth)), on && error
+            ? h(Text, { color: theme.red, wrap: 'truncate-end' }, ` ${error}`)
+            : on && editing
+                ? null
+                : h(Text, { color: theme.dim, wrap: 'truncate-end' }, ` ${r.hint}`));
+    }), rows.length > win.end - win.start ? h(Text, { color: theme.dim }, `${win.start + 1} to ${win.end} of ${rows.length}`) : null, other ? h(Box, { marginTop: 1 }, h(Text, { color: theme.dim }, 'Projects, workflows and folders have their own screens.')) : null));
+}
+export const settingsScreen = {
+    id: 'settings',
+    title: 'Settings',
+    component: (props) => h(Settings, { params: props.params }),
+    hints: () => BASE_HINTS,
+};

package/dist/tui/screens/workflow-form.d.ts

@@ -0,0 +1,58 @@
+import { type StepsCatalog, type WorkflowItem } from '../data.ts';
+import type { Screen } from '../screens.ts';
+import { type TriggerLike } from './workflows.ts';
+export interface FormState {
+    name: string;
+    triggers: TriggerLike[];
+    steps: string[];
+    project: string;
+    rounds: number;
+}
+export type FormAction = {
+    type: 'name';
+    value: string;
+} | {
+    type: 'addTrigger';
+    trigger: TriggerLike;
+} | {
+    type: 'removeTrigger';
+    index: number;
+} | {
+    type: 'addStep';
+    id: string;
+} | {
+    type: 'removeStep';
+    index: number;
+} | {
+    type: 'moveStep';
+    index: number;
+    dir: 1 | -1;
+} | {
+    type: 'project';
+    value: string;
+} | {
+    type: 'rounds';
+    value: number;
+};
+export declare function formReducer(s: FormState, a: FormAction): FormState;
+export declare function initialForm(w: WorkflowItem | undefined, name: string, projects: string[]): FormState;
+export declare function hasProducer(steps: string[], catalog: StepsCatalog | null): boolean;
+export declare const effectiveRounds: (s: FormState, catalog: StepsCatalog | null) => number;
+export declare function availableSteps(s: FormState, catalog: StepsCatalog | null): {
+    id: string;
+    label: string;
+    hint: string;
+}[];
+export declare function summaryLine(s: FormState, catalog: StepsCatalog | null): string;
+export declare function formProblems(s: FormState, isNew: boolean, origName: string | null, existingNames: string[], projectNames: string[]): string[];
+export declare function saveArgs(s: FormState, isNew: boolean, catalog: StepsCatalog | null): string[];
+export declare const renameArgs: (from: string, to: string) => string[];
+export declare function makeTrigger(team: string, label: string): {
+    trigger: TriggerLike;
+} | {
+    error: string;
+};
+export declare function sharedTriggerWarnings(workflows: WorkflowItem[], s: FormState, origName: string | null): string[];
+export type Section = 'name' | 'triggers' | 'steps' | 'project' | 'rounds';
+export declare function sectionsFor(s: FormState, catalog: StepsCatalog | null): Section[];
+export declare const workflowFormScreen: Screen;