@stigg/terminal 0.0.1-alpha

package/dist/ui/steps/LoginStep.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { Action } from "../state.js";
+interface Props {
+    dispatch: React.Dispatch<Action>;
+}
+export declare function LoginStep({ dispatch }: Props): React.ReactElement;
+export {};

package/dist/ui/steps/LoginStep.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Spinner } from "@inkjs/ui";
+import { Box, Text, useInput } from "ink";
+import { useState } from "react";
+import { authenticate } from "../../auth/oauth.js";
+import { saveSession } from "../../auth/storage.js";
+import { SectionTitle } from "../components/SectionTitle.js";
+import { useAsyncEffect } from "../hooks/useAsyncEffect.js";
+export function LoginStep({ dispatch }) {
+    const [started, setStarted] = useState(false);
+    const [message, setMessage] = useState("Opening browser to log in…");
+    const [errored, setErrored] = useState(null);
+    useInput((_input, key) => {
+        if (key.return)
+            setStarted(true);
+    }, { isActive: !started && !errored });
+    useAsyncEffect(async (signal) => {
+        if (!started)
+            return;
+        try {
+            const session = await authenticate({
+                onAuthUrlReady: (_url, port) => {
+                    if (!signal.cancelled) {
+                        setMessage(`Waiting for callback on http://127.0.0.1:${port}`);
+                    }
+                },
+            });
+            await saveSession(session);
+            if (signal.cancelled)
+                return;
+            dispatch({
+                type: "LOGIN_OK",
+                session: {
+                    email: session.email,
+                    accessToken: session.access_token,
+                },
+            });
+        }
+        catch (err) {
+            if (signal.cancelled)
+                return;
+            setErrored(err instanceof Error ? err.message : String(err));
+            dispatch({
+                type: "ERROR",
+                message: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }, [started]);
+    if (errored) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "\u2717 Login failed" }), _jsx(Text, { dimColor: true, children: errored })] }));
+    }
+    if (!started) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SectionTitle, { children: "Sign in to Stigg" }), _jsx(Text, { dimColor: true, children: "We'll open your browser to complete the OAuth flow." }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Press ", _jsx(Text, { color: "cyan", children: "enter" }), " to continue."] }) })] }));
+    }
+    return _jsx(Spinner, { label: message });
+}

package/dist/ui/steps/SkillsStep.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+import type { Action } from "../state.js";
+interface Props {
+    dispatch: React.Dispatch<Action>;
+}
+export declare function SkillsStep({ dispatch }: Props): React.ReactElement;
+export {};

package/dist/ui/steps/SkillsStep.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ConfirmInput } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { SectionTitle } from "../components/SectionTitle.js";
+export function SkillsStep({ dispatch }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SectionTitle, { children: "Install Stigg skills for Claude Code?" }), _jsx(Text, { dimColor: true, children: "Clones stiggio/skills into ~/.claude/plugins/marketplaces/ \u2014 works as a Claude Code marketplace plugin." }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Install? " }), _jsx(ConfirmInput, { onConfirm: () => dispatch({ type: "SKILLS_CHOICE", install: true }), onCancel: () => dispatch({ type: "SKILLS_CHOICE", install: false }) })] })] }));
+}

package/dist/ui/steps/SummaryStep.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { WizardState } from "../state.js";
+interface Props {
+    state: WizardState;
+    onDone: () => void;
+}
+export declare function SummaryStep({ state, onDone }: Props): React.ReactElement;
+export {};

package/dist/ui/steps/SummaryStep.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useInput } from "ink";
+import { ContextRow } from "../components/ContextRow.js";
+import { SectionTitle } from "../components/SectionTitle.js";
+function credentialLabel(state) {
+    if (!state.credential)
+        return "?";
+    if (state.credential.kind === "scoped") {
+        const name = state.selectedKey?.name ?? "scoped";
+        const last4 = state.selectedKey?.lastFour ?? "????";
+        return `API key  ${name} (sk_…${last4})`;
+    }
+    return `User JWT  (broad access, env: ${state.environment?.name ?? "?"})`;
+}
+export function SummaryStep({ state, onDone }) {
+    useInput(() => onDone());
+    const entries = [
+        { label: "Account", value: state.session?.email ?? "?" },
+        { label: "Credential", value: credentialLabel(state) },
+        { label: "Environment", value: state.environment?.name ?? "?" },
+    ];
+    for (const w of state.writes) {
+        entries.push({
+            label: entries.find((e) => e.label === "Wrote to") ? "" : "Wrote to",
+            value: w.path,
+            hint: w.backedUpTo ? `backup: ${w.backedUpTo}` : undefined,
+        });
+    }
+    if (state.installedSkills) {
+        entries.push({
+            label: "Skills",
+            value: state.installedSkills.ok
+                ? `cloned to ${state.installedSkills.installedPath ?? "~/.claude/plugins/marketplaces/stiggio-skills"}`
+                : `skipped (${state.installedSkills.reason ?? "see logs"})`,
+        });
+    }
+    else if (state.installSkills === false) {
+        entries.push({ label: "Skills", value: "not installed (declined)" });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SectionTitle, { children: "Setup complete" }), _jsx(ContextRow, { entries: entries }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { children: "Next:" }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "/stigg help" }), "     ", "in Claude Code"] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "@stigg" }), "          ", "in Cursor (after restart)"] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "cyberdeck dash" }), "   ", "to open the Stigg dashboard"] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "cyberdeck debug" }), "  ", "to stream audit + usage logs"] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "press any key to return to menu" }) })] }));
+}

package/dist/ui/steps/WritingStep.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import type { ClientId, McpClientHandler } from "../../types.js";
+import type { Action, WizardState } from "../state.js";
+interface Props {
+    state: WizardState;
+    dispatch: React.Dispatch<Action>;
+    handlers: Record<ClientId, McpClientHandler>;
+}
+export declare function WritingStep({ state, dispatch, handlers, }: Props): React.ReactElement;
+export {};

package/dist/ui/steps/WritingStep.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ConfirmInput, Spinner } from "@inkjs/ui";
+import { Box, Text } from "ink";
+import { useEffect, useState } from "react";
+import { installStiggSkills } from "../../skills/install.js";
+import { SectionTitle } from "../components/SectionTitle.js";
+import { useAsyncEffect } from "../hooks/useAsyncEffect.js";
+export function WritingStep({ state, dispatch, handlers, }) {
+    const [phase, setPhase] = useState({ kind: "init" });
+    const [currentClient, setCurrentClient] = useState(null);
+    const [skipped, setSkipped] = useState([]);
+    useAsyncEffect(async (signal) => {
+        if (phase.kind !== "init")
+            return;
+        const clients = state.selectedClients ?? [];
+        const existing = [];
+        for (const c of clients) {
+            if (await handlers[c].hasExistingEntry())
+                existing.push(c);
+        }
+        if (signal.cancelled)
+            return;
+        if (existing.length > 0) {
+            setPhase({ kind: "needs-confirm", existing });
+        }
+        else {
+            setPhase({ kind: "writing" });
+        }
+    }, [phase.kind], (err) => dispatch({
+        type: "ERROR",
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    useAsyncEffect(async (signal) => {
+        if (phase.kind !== "writing")
+            return;
+        const clients = (state.selectedClients ?? []).filter((c) => !skipped.includes(c));
+        for (const c of clients) {
+            if (signal.cancelled)
+                return;
+            setCurrentClient(c);
+            try {
+                const result = await handlers[c].write(state.credential);
+                const decorated = { ...result, client: c };
+                dispatch({ type: "WRITE_OK", result: decorated });
+            }
+            catch (err) {
+                dispatch({
+                    type: "ERROR",
+                    message: err instanceof Error ? err.message : String(err),
+                });
+                return;
+            }
+        }
+        setCurrentClient(null);
+        if (signal.cancelled)
+            return;
+        if (state.installSkills) {
+            setPhase({ kind: "skills" });
+        }
+        else {
+            setPhase({ kind: "advancing" });
+        }
+    }, [phase.kind]);
+    useAsyncEffect(async (signal) => {
+        if (phase.kind !== "skills")
+            return;
+        const result = await installStiggSkills();
+        if (signal.cancelled)
+            return;
+        dispatch({ type: "SKILLS_INSTALL_OK", result });
+    }, [phase.kind], (err) => dispatch({
+        type: "ERROR",
+        message: err instanceof Error ? err.message : String(err),
+    }));
+    useEffect(() => {
+        if (phase.kind === "advancing") {
+            dispatch({ type: "ADVANCE" });
+        }
+    }, [phase.kind, dispatch]);
+    if (phase.kind === "needs-confirm") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(SectionTitle, { children: "Existing stigg entry found" }), _jsx(Text, { children: "The following clients already have a stigg MCP entry:" }), _jsx(Box, { flexDirection: "column", marginY: 1, children: phase.existing.map((c) => (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "\u2022" }), " ", handlers[c].label] }, c))) }), _jsx(Text, { children: "Overwrite? Existing entries will be backed up." }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Overwrite? " }), _jsx(ConfirmInput, { onConfirm: () => setPhase({ kind: "writing" }), onCancel: () => {
+                                setSkipped(phase.existing);
+                                setPhase({ kind: "writing" });
+                            } })] }), skipped.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { color: "yellow", children: ["Will skip: ", skipped.map((c) => handlers[c].label).join(", ")] }) }))] }));
+    }
+    if (phase.kind === "writing") {
+        const label = currentClient
+            ? `Writing ${handlers[currentClient].label}…`
+            : "Writing config files…";
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Spinner, { label: label }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: state.writes.map((w, i) => (_jsxs(Text, { color: "green", children: ["  ✓ ", w.path, w.backedUpTo ? (_jsxs(Text, { dimColor: true, children: ["  (backup: ", w.backedUpTo, ")"] })) : null] }, i))) })] }));
+    }
+    if (phase.kind === "skills") {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Spinner, { label: "Cloning stiggio/skills\u2026" }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: state.writes.map((w, i) => (_jsxs(Text, { color: "green", children: ["  ✓ ", w.path] }, i))) })] }));
+    }
+    return _jsx(Spinner, { label: "Preparing\u2026" });
+}

package/dist/ui/theme.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Stigg brand palette — dark background, electric lime accent.
+ * Matches the May-2026 website theme.
+ */
+export declare const BRAND_LIME: {
+    readonly brightest: "#c8ff3c";
+    readonly primary: "#9eff00";
+    readonly mid: "#7dd83a";
+    readonly forest: "#4a9e1f";
+    readonly deep: "#235a14";
+};
+export declare const COLORS: {
+    readonly primary: "#9eff00";
+    readonly accent: "cyan";
+    readonly success: "#9eff00";
+    readonly warning: "yellow";
+    readonly error: "#ff4d4d";
+    readonly muted: "gray";
+};
+export declare const GLYPHS: {
+    readonly check: "✓";
+    readonly cross: "✗";
+    readonly bullet: "·";
+    readonly arrow: "▸";
+    readonly filled: "■";
+    readonly empty: "□";
+    readonly dot: "●";
+    readonly ring: "○";
+};
+/** Shell palette used by the new TUI (TitleBar, PickerMenu, hints bar). */
+export declare const Colors: {
+    readonly primary: "#c8ff3c";
+    readonly accent: "#9eff00";
+    readonly titleColor: "#0a0a0a";
+    readonly success: "#9eff00";
+    readonly error: "#ff4d4d";
+    readonly muted: "gray";
+};
+/** RGB triplet painted into the terminal's alt-screen background via ANSI 48;2;r;g;b. */
+export declare const SHELL_BG_RGB: readonly [10, 10, 10];
+export declare const Icons: {
+    readonly triangleSmallRight: "▸";
+    readonly squareFilled: "◼";
+    readonly squareOpen: "◻";
+    readonly check: "✓";
+    readonly cross: "✗";
+    readonly bullet: "·";
+};
+export declare const MIN_SHELL_WIDTH = 80;
+export declare const MAX_SHELL_WIDTH = 120;
+export declare const MIN_CARD_WIDTH = 78;
+export declare function shouldRenderBorder(): boolean;
+export declare function shouldRenderAnimation(): boolean;

package/dist/ui/theme.js

@@ -0,0 +1,66 @@
+/**
+ * Stigg brand palette — dark background, electric lime accent.
+ * Matches the May-2026 website theme.
+ */
+export const BRAND_LIME = {
+    brightest: '#c8ff3c',
+    primary: '#9eff00',
+    mid: '#7dd83a',
+    forest: '#4a9e1f',
+    deep: '#235a14',
+};
+export const COLORS = {
+    primary: BRAND_LIME.primary,
+    accent: 'cyan',
+    success: BRAND_LIME.primary,
+    warning: 'yellow',
+    error: '#ff4d4d',
+    muted: 'gray',
+};
+export const GLYPHS = {
+    check: '✓',
+    cross: '✗',
+    bullet: '·',
+    arrow: '▸',
+    filled: '■',
+    empty: '□',
+    dot: '●',
+    ring: '○',
+};
+/** Shell palette used by the new TUI (TitleBar, PickerMenu, hints bar). */
+export const Colors = {
+    primary: BRAND_LIME.brightest,
+    accent: BRAND_LIME.primary,
+    titleColor: '#0a0a0a',
+    success: BRAND_LIME.primary,
+    error: '#ff4d4d',
+    muted: 'gray',
+};
+/** RGB triplet painted into the terminal's alt-screen background via ANSI 48;2;r;g;b. */
+export const SHELL_BG_RGB = [10, 10, 10];
+export const Icons = {
+    triangleSmallRight: '▸',
+    squareFilled: '◼',
+    squareOpen: '◻',
+    check: '✓',
+    cross: '✗',
+    bullet: '·',
+};
+export const MIN_SHELL_WIDTH = 80;
+export const MAX_SHELL_WIDTH = 120;
+export const MIN_CARD_WIDTH = 78;
+export function shouldRenderBorder() {
+    const cols = process.stdout.columns ?? 80;
+    return cols >= MIN_CARD_WIDTH;
+}
+export function shouldRenderAnimation() {
+    if (!process.stdout.isTTY)
+        return false;
+    if (process.env.CI === 'true' || process.env.CI === '1')
+        return false;
+    if (process.env.NO_COLOR)
+        return false;
+    if (process.env.TERM === 'dumb')
+        return false;
+    return shouldRenderBorder();
+}

package/dist/ui/tui/App.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { LaunchRequest } from '../../launch/agent.js';
+export type AppScreen = 'menu' | 'init' | 'dash' | 'env';
+interface AppProps {
+    initialScreen?: AppScreen;
+    callbackPort?: number;
+    onLaunchAgent?: (req: LaunchRequest) => void;
+}
+export declare function App(props: AppProps): React.ReactElement;
+export {};

package/dist/ui/tui/App.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useApp } from 'ink';
+import { useState } from 'react';
+import { Logo } from '../intro/LogoView.js';
+import { KeyMatch } from './hooks/keyboard-hints-utils.js';
+import { DashScreen } from './screens/DashScreen.js';
+import { EnvScreen } from './screens/EnvScreen.js';
+import { InitScreen } from './screens/InitScreen.js';
+import { MenuScreen } from './screens/MenuScreen.js';
+import { useKeyBindings } from './hooks/useKeyBindings.js';
+import { ScreenContainer } from './primitives/ScreenContainer.js';
+function AppInner({ initialScreen = 'menu', callbackPort, onLaunchAgent, }) {
+    const [screen, setScreen] = useState(initialScreen);
+    const { exit } = useApp();
+    useKeyBindings('app', [
+        {
+            match: KeyMatch.Escape,
+            label: 'esc',
+            action: screen === 'menu' ? 'quit' : 'menu',
+            priority: 30,
+            handler: () => {
+                if (screen === 'menu') {
+                    exit();
+                }
+                else {
+                    setScreen('menu');
+                }
+            },
+        },
+        {
+            match: '\x03', // ctrl+c — handled by Ink's exitOnCtrlC, this is a hint-only entry
+            label: 'ctrl+c',
+            action: 'quit',
+            priority: 99,
+            handler: () => exit(),
+        },
+    ]);
+    return (_jsxs(ScreenContainer, { chrome: screen === 'menu' ? (cols) => _jsx(Logo, { containerWidth: cols }) : undefined, children: [screen === 'menu' && (_jsx(MenuScreen, { onPick: (c) => {
+                    if (c === 'exit') {
+                        exit();
+                        return;
+                    }
+                    setScreen(c);
+                } })), screen === 'init' && (_jsx(InitScreen, { onDone: () => setScreen('menu'), onLaunch: (req) => {
+                    onLaunchAgent?.(req);
+                    exit();
+                }, callbackPort: callbackPort })), screen === 'env' && _jsx(EnvScreen, { onDone: () => setScreen('menu') }), screen === 'dash' && _jsx(DashScreen, { onDone: () => setScreen('menu') })] }));
+}
+export function App(props) {
+    return _jsx(AppInner, { ...props });
+}

package/dist/ui/tui/components/ContextStrip.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+export interface ContextEntry {
+    label: string;
+    value: string;
+    hint?: string;
+}
+interface ContextStripProps {
+    entries: ContextEntry[];
+}
+export declare function ContextStrip({ entries }: ContextStripProps): React.ReactElement | null;
+export {};

package/dist/ui/tui/components/ContextStrip.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function ContextStrip({ entries }) {
+    if (entries.length === 0)
+        return null;
+    const labelWidth = Math.max(...entries.map((e) => (e.label ? e.label.length : 0)));
+    return (_jsx(Box, { flexDirection: "column", children: entries.map((e, i) => (_jsxs(Box, { flexDirection: "row", children: [_jsx(Box, { width: labelWidth + 2, children: _jsx(Text, { dimColor: true, children: e.label }) }), _jsx(Text, { children: e.value }), e.hint && (_jsxs(Text, { dimColor: true, children: ['  ', e.hint] }))] }, `${e.label}-${i}`))) }));
+}

package/dist/ui/tui/components/TitleBar.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface TitleBarProps {
+    width: number;
+}
+export declare function TitleBar({ width }: TitleBarProps): React.ReactElement;
+export {};

package/dist/ui/tui/components/TitleBar.js

@@ -0,0 +1,18 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Colors } from '../../theme.js';
+const VERSION = '0.0.1-alpha';
+const FULL_TITLE = ` stigg · terminal v${VERSION}`;
+const SHORT_TITLE = ` terminal v${VERSION}`;
+const FEEDBACK = 'github.com/stiggio/terminal ';
+const FEEDBACK_SHORT = 'stigg.io ';
+export function TitleBar({ width }) {
+    let title = FULL_TITLE;
+    let feedback = FEEDBACK;
+    if (title.length + feedback.length > width)
+        feedback = FEEDBACK_SHORT;
+    if (title.length + feedback.length > width)
+        title = SHORT_TITLE;
+    const gap = Math.max(0, width - title.length - feedback.length);
+    return (_jsx(Box, { width: width, overflow: "hidden", children: _jsxs(Text, { backgroundColor: Colors.accent, color: Colors.titleColor, children: [title, ' '.repeat(gap), feedback] }) }));
+}

package/dist/ui/tui/components/WizardChecklist.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { WizardState } from '../../state.js';
+interface Props {
+    state: WizardState;
+}
+export declare function WizardChecklist({ state }: Props): React.ReactElement;
+export {};

package/dist/ui/tui/components/WizardChecklist.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Colors, Icons } from '../../theme.js';
+const STEPS = [
+    {
+        id: 'login',
+        meta: { label: 'Sign in', description: 'Authenticate with Stigg via browser (OAuth)' },
+    },
+    {
+        id: 'account',
+        meta: { label: 'Account', description: 'Pick which Stigg account to configure' },
+    },
+    {
+        id: 'environment',
+        meta: {
+            label: 'Environment',
+            description: 'Pick a target environment (dev / staging / prod)',
+        },
+    },
+    {
+        id: 'apiKey',
+        meta: { label: 'API key', description: 'Select an API key for that environment' },
+    },
+    {
+        id: 'clients',
+        meta: {
+            label: 'Clients',
+            description: 'Pick AI clients to configure (Claude Code, Cursor, …)',
+        },
+    },
+    {
+        id: 'skills',
+        meta: { label: 'Skills', description: "Optionally install Stigg's agent skills" },
+    },
+    {
+        id: 'writing',
+        meta: { label: 'Configure', description: 'Write MCP entries to each selected client' },
+    },
+    {
+        id: 'summary',
+        meta: { label: 'Done', description: 'Review the setup' },
+    },
+];
+const MARKER_WIDTH = 2;
+const NUMBER_WIDTH = 4;
+const LABEL_WIDTH = 14;
+function classify(state, step) {
+    if (state.history.includes(step))
+        return 'done';
+    if (state.step === step) {
+        return state.step === 'summary' ? 'done' : 'current';
+    }
+    if (step === 'account' && state.accounts != null && state.accounts.length === 1) {
+        return 'skipped';
+    }
+    if (step === 'skills' && state.selectedClients != null && state.selectedClients.length === 0) {
+        return 'skipped';
+    }
+    return 'pending';
+}
+export function WizardChecklist({ state }) {
+    return (_jsx(Box, { flexDirection: "column", children: STEPS.map(({ id, meta }, i) => {
+            const status = classify(state, id);
+            const isDone = status === 'done';
+            const labelColor = isDone ? Colors.success : undefined;
+            const dim = !isDone;
+            return (_jsxs(Box, { children: [_jsx(Box, { width: MARKER_WIDTH, children: _jsx(Text, { color: labelColor, children: isDone ? Icons.check : ' ' }) }), _jsx(Box, { width: NUMBER_WIDTH, children: _jsxs(Text, { color: labelColor, dimColor: dim, children: [i + 1, "."] }) }), _jsx(Box, { width: LABEL_WIDTH, children: _jsx(Text, { color: labelColor, dimColor: dim, children: meta.label }) }), _jsx(Text, { dimColor: true, children: meta.description }), status === 'skipped' && _jsx(Text, { dimColor: true, children: '  (skipped)' })] }, id));
+        }) }));
+}

package/dist/ui/tui/hooks/keyboard-hints-utils.d.ts

@@ -0,0 +1,26 @@
+import type { Key } from 'ink';
+export declare enum KeyMatch {
+    UpArrow = 0,
+    DownArrow = 1,
+    LeftArrow = 2,
+    RightArrow = 3,
+    Return = 4,
+    Escape = 5,
+    Space = 6,
+    Tab = 7,
+    AnyChar = 8
+}
+export type KeyMatchOrChar = KeyMatch | string;
+export interface KeyHint {
+    label: string;
+    action: string;
+    priority?: number;
+}
+export interface KeyBinding extends KeyHint {
+    match: KeyMatchOrChar | KeyMatchOrChar[];
+    handler: (input: string, key: Key) => void;
+}
+export declare const DEFAULT_HINT_PRIORITY = 50;
+export declare function defaultPriorityFor(m: KeyMatchOrChar): number;
+export declare function matchesKey(m: KeyMatchOrChar, input: string, key: Key): boolean;
+export declare function dedupeAndSortHints(bag: Map<string, KeyHint[]>): KeyHint[];

package/dist/ui/tui/hooks/keyboard-hints-utils.js

@@ -0,0 +1,69 @@
+export var KeyMatch;
+(function (KeyMatch) {
+    KeyMatch[KeyMatch["UpArrow"] = 0] = "UpArrow";
+    KeyMatch[KeyMatch["DownArrow"] = 1] = "DownArrow";
+    KeyMatch[KeyMatch["LeftArrow"] = 2] = "LeftArrow";
+    KeyMatch[KeyMatch["RightArrow"] = 3] = "RightArrow";
+    KeyMatch[KeyMatch["Return"] = 4] = "Return";
+    KeyMatch[KeyMatch["Escape"] = 5] = "Escape";
+    KeyMatch[KeyMatch["Space"] = 6] = "Space";
+    KeyMatch[KeyMatch["Tab"] = 7] = "Tab";
+    KeyMatch[KeyMatch["AnyChar"] = 8] = "AnyChar";
+})(KeyMatch || (KeyMatch = {}));
+export const DEFAULT_HINT_PRIORITY = 50;
+const PRIORITY_BY_MATCH = {
+    [KeyMatch.UpArrow]: 0,
+    [KeyMatch.DownArrow]: 0,
+    [KeyMatch.LeftArrow]: 1,
+    [KeyMatch.RightArrow]: 1,
+    [KeyMatch.Space]: 10,
+    [KeyMatch.Tab]: 15,
+    [KeyMatch.Escape]: 20,
+    [KeyMatch.Return]: 21,
+};
+export function defaultPriorityFor(m) {
+    if (typeof m === 'string')
+        return DEFAULT_HINT_PRIORITY;
+    return PRIORITY_BY_MATCH[m] ?? DEFAULT_HINT_PRIORITY;
+}
+export function matchesKey(m, input, key) {
+    if (typeof m === 'string')
+        return input === m;
+    switch (m) {
+        case KeyMatch.UpArrow:
+            return key.upArrow;
+        case KeyMatch.DownArrow:
+            return key.downArrow;
+        case KeyMatch.LeftArrow:
+            return key.leftArrow;
+        case KeyMatch.RightArrow:
+            return key.rightArrow;
+        case KeyMatch.Return:
+            return key.return;
+        case KeyMatch.Escape:
+            return key.escape;
+        case KeyMatch.Space:
+            return input === ' ';
+        case KeyMatch.Tab:
+            return key.tab;
+        case KeyMatch.AnyChar:
+            return true;
+    }
+}
+export function dedupeAndSortHints(bag) {
+    const byKey = new Map();
+    for (const hints of bag.values()) {
+        for (const h of hints) {
+            const k = `${h.label}:${h.action}`;
+            // first registration wins for label/action, but keep smallest priority
+            const existing = byKey.get(k);
+            if (!existing) {
+                byKey.set(k, h);
+            }
+            else if ((h.priority ?? DEFAULT_HINT_PRIORITY) < (existing.priority ?? DEFAULT_HINT_PRIORITY)) {
+                byKey.set(k, h);
+            }
+        }
+    }
+    return Array.from(byKey.values()).sort((a, b) => (a.priority ?? DEFAULT_HINT_PRIORITY) - (b.priority ?? DEFAULT_HINT_PRIORITY));
+}