@contentful/experience-design-system-cli 2.2.1

package/dist/src/analyze/select/tui/components/JsonEditor.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { Box, Text } from 'ink';
+import { useUndo } from '../hooks/useUndo.js';
+import { useImmediateInput } from '../hooks/useImmediateInput.js';
+export function JsonEditor({ value, width, height, onChange, onSave, onDiscard }) {
+    const undo = useUndo({
+        lines: value.split('\n'),
+        cursorRow: 0,
+        cursorCol: 0,
+    });
+    const [scrollRow, setScrollRow] = useState(0);
+    const [scrollCol] = useState(0);
+    const [validationError, setValidationError] = useState(null);
+    const [cursorVisible, setCursorVisible] = useState(true);
+    // Blinking cursor
+    useEffect(() => {
+        const interval = setInterval(() => setCursorVisible((v) => !v), 500);
+        return () => clearInterval(interval);
+    }, []);
+    const { lines, cursorRow, cursorCol } = undo.current;
+    // Keep scroll in sync with cursor
+    useEffect(() => {
+        if (cursorRow < scrollRow)
+            setScrollRow(cursorRow);
+        if (cursorRow >= scrollRow + height)
+            setScrollRow(cursorRow - height + 1);
+    }, [cursorRow, scrollRow, height]);
+    useImmediateInput((input, key) => {
+        const currentLines = undo.current.lines;
+        const currentRow = undo.current.cursorRow;
+        const currentCol = undo.current.cursorCol;
+        if (key.ctrl && input === 's') {
+            // Validate and save
+            const text = currentLines.join('\n');
+            try {
+                JSON.parse(text);
+                setValidationError(null);
+                onChange(text);
+                onSave();
+            }
+            catch (e) {
+                setValidationError(e instanceof Error ? e.message : String(e));
+            }
+            return;
+        }
+        if (key.escape) {
+            onDiscard();
+            return;
+        }
+        if (key.ctrl && input === 'z') {
+            undo.undo();
+            onChange(undo.current.lines.join('\n'));
+            return;
+        }
+        let newLines = [...currentLines];
+        let newRow = currentRow;
+        let newCol = currentCol;
+        if (key.return) {
+            const before = newLines[currentRow].slice(0, currentCol);
+            const after = newLines[currentRow].slice(currentCol);
+            newLines = [...newLines.slice(0, currentRow), before, after, ...newLines.slice(currentRow + 1)];
+            newRow = currentRow + 1;
+            newCol = 0;
+        }
+        else if (key.backspace || key.delete) {
+            if (key.backspace) {
+                if (currentCol > 0) {
+                    newLines[currentRow] = newLines[currentRow].slice(0, currentCol - 1) + newLines[currentRow].slice(currentCol);
+                    newCol = currentCol - 1;
+                }
+                else if (currentRow > 0) {
+                    const prevLen = newLines[currentRow - 1].length;
+                    newLines[currentRow - 1] = newLines[currentRow - 1] + newLines[currentRow];
+                    newLines = [...newLines.slice(0, currentRow), ...newLines.slice(currentRow + 1)];
+                    newRow = currentRow - 1;
+                    newCol = prevLen;
+                }
+            }
+            else {
+                // Delete key
+                if (currentCol < newLines[currentRow].length) {
+                    newLines[currentRow] = newLines[currentRow].slice(0, currentCol) + newLines[currentRow].slice(currentCol + 1);
+                }
+                else if (currentRow < newLines.length - 1) {
+                    newLines[currentRow] = newLines[currentRow] + newLines[currentRow + 1];
+                    newLines = [...newLines.slice(0, currentRow + 1), ...newLines.slice(currentRow + 2)];
+                }
+            }
+        }
+        else if (key.leftArrow) {
+            if (currentCol > 0) {
+                newCol = currentCol - 1;
+            }
+            else if (currentRow > 0) {
+                newRow = currentRow - 1;
+                newCol = newLines[currentRow - 1].length;
+            }
+        }
+        else if (key.rightArrow) {
+            if (currentCol < newLines[currentRow].length) {
+                newCol = currentCol + 1;
+            }
+            else if (currentRow < newLines.length - 1) {
+                newRow = currentRow + 1;
+                newCol = 0;
+            }
+        }
+        else if (key.upArrow) {
+            if (currentRow > 0) {
+                newRow = currentRow - 1;
+                newCol = Math.min(currentCol, newLines[currentRow - 1].length);
+            }
+        }
+        else if (key.downArrow) {
+            if (currentRow < newLines.length - 1) {
+                newRow = currentRow + 1;
+                newCol = Math.min(currentCol, newLines[currentRow + 1].length);
+            }
+        }
+        else if (input === '\x1b[H' || input === '\x1b[1~') {
+            // Home key
+            newCol = 0;
+        }
+        else if (input === '\x1b[F' || input === '\x1b[4~') {
+            // End key
+            newCol = newLines[currentRow].length;
+        }
+        else if (input && input.length === 1 && !key.ctrl && !key.meta) {
+            // Printable character
+            newLines[currentRow] = newLines[currentRow].slice(0, currentCol) + input + newLines[currentRow].slice(currentCol);
+            newCol = currentCol + 1;
+        }
+        else {
+            return; // No change
+        }
+        undo.push({ lines: newLines, cursorRow: newRow, cursorCol: newCol });
+        onChange(newLines.join('\n'));
+    });
+    const innerWidth = Math.max(1, width - 2);
+    const visibleLines = lines.slice(scrollRow, scrollRow + height);
+    return (_jsxs(Box, { flexDirection: "column", width: width, borderStyle: "single", borderColor: "white", children: [_jsx(Text, { bold: true, children: 'EDIT [EDITING — Ctrl+S save · Esc discard]' }), visibleLines.map((line, displayRow) => {
+                const actualRow = displayRow + scrollRow;
+                const displayLine = line.slice(scrollCol, scrollCol + innerWidth);
+                if (actualRow === cursorRow) {
+                    // Render cursor on this line
+                    const beforeCursor = displayLine.slice(0, cursorCol - scrollCol);
+                    const cursorChar = displayLine[cursorCol - scrollCol] ?? ' ';
+                    const afterCursor = displayLine.slice(cursorCol - scrollCol + 1);
+                    return (_jsxs(Box, { children: [_jsx(Text, { children: beforeCursor }), _jsx(Text, { inverse: cursorVisible, children: cursorChar }), _jsx(Text, { children: afterCursor })] }, displayRow));
+                }
+                return _jsx(Text, { children: displayLine }, displayRow);
+            }), validationError && _jsx(Text, { color: "red", children: '✗ Invalid JSON: ' + validationError })] }));
+}

package/dist/src/analyze/select/tui/components/JsonPanel.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type JsonPanelProps = {
+    label: string;
+    value: string;
+    scrollOffset: number;
+    width: number;
+    height: number;
+    active: boolean;
+};
+export declare function JsonPanel({ label, value, scrollOffset, width, height, active }: JsonPanelProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/JsonPanel.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function highlightJson(line) {
+    // Simple regex-based syntax highlighting
+    const parts = [];
+    let remaining = line;
+    while (remaining.length > 0) {
+        // Object key: "key":
+        const keyMatch = remaining.match(/^("(?:[^"\\]|\\.)*"\s*:)/);
+        if (keyMatch) {
+            parts.push({ text: keyMatch[1], color: 'cyan' });
+            remaining = remaining.slice(keyMatch[1].length);
+            continue;
+        }
+        // String value
+        const strMatch = remaining.match(/^("(?:[^"\\]|\\.)*")/);
+        if (strMatch) {
+            parts.push({ text: strMatch[1], color: 'green' });
+            remaining = remaining.slice(strMatch[1].length);
+            continue;
+        }
+        // Number
+        const numMatch = remaining.match(/^(-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)/);
+        if (numMatch) {
+            parts.push({ text: numMatch[1], color: 'yellow' });
+            remaining = remaining.slice(numMatch[1].length);
+            continue;
+        }
+        // Boolean
+        const boolMatch = remaining.match(/^(true|false)/);
+        if (boolMatch) {
+            parts.push({ text: boolMatch[1], color: 'magenta' });
+            remaining = remaining.slice(boolMatch[1].length);
+            continue;
+        }
+        // Null
+        const nullMatch = remaining.match(/^(null)/);
+        if (nullMatch) {
+            parts.push({ text: nullMatch[1], color: 'red', dim: true });
+            remaining = remaining.slice(nullMatch[1].length);
+            continue;
+        }
+        // Take one character as-is (punctuation, whitespace, etc.)
+        parts.push({ text: remaining[0] });
+        remaining = remaining.slice(1);
+    }
+    return (_jsx(_Fragment, { children: parts.map((part, i) => (_jsx(Text, { color: part.color, dimColor: part.dim, children: part.text }, i))) }));
+}
+function truncateLine(line, maxWidth) {
+    if (line.length <= maxWidth)
+        return line;
+    return line.slice(0, maxWidth - 1) + '…';
+}
+export function JsonPanel({ label, value, scrollOffset, width, height, active }) {
+    const allLines = value.split('\n');
+    const visibleLines = allLines.slice(scrollOffset, scrollOffset + height);
+    const innerWidth = Math.max(1, width - 2); // subtract border
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height + 2, borderStyle: "single", borderColor: active ? 'white' : undefined, children: [_jsx(Text, { bold: true, dimColor: !active, children: label }), visibleLines.map((line, i) => {
+                const truncated = truncateLine(line, innerWidth);
+                return _jsx(Box, { children: highlightJson(truncated) }, i);
+            })] }));
+}

package/dist/src/analyze/select/tui/components/PreviewSummaryBar.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ServerPreviewResponse } from '@contentful/experience-design-system-types';
+type PreviewSummaryBarProps = {
+    preview: ServerPreviewResponse | null;
+    loading: boolean;
+};
+export declare function PreviewSummaryBar({ preview, loading }: PreviewSummaryBarProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/PreviewSummaryBar.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function PreviewSummaryBar({ preview, loading }) {
+    if (!preview && !loading) {
+        return _jsx(Box, {});
+    }
+    if (loading && !preview) {
+        return (_jsx(Box, { gap: 1, children: _jsx(Text, { dimColor: true, children: "\u21BB Loading preview..." }) }));
+    }
+    const comp = preview.components;
+    const tok = preview.tokens;
+    const parts = [];
+    const newCount = comp.new.length + tok.new.length;
+    const changedCount = comp.changed.length + tok.changed.length;
+    const removedCount = comp.removed.length + tok.removed.length;
+    const unchangedCount = comp.unchanged.length + tok.unchanged.length;
+    if (newCount > 0)
+        parts.push({ label: `${newCount} new`, color: 'green' });
+    if (changedCount > 0)
+        parts.push({ label: `${changedCount} changed`, color: 'yellow' });
+    if (removedCount > 0)
+        parts.push({ label: `${removedCount} removed`, color: 'red' });
+    if (unchangedCount > 0)
+        parts.push({ label: `${unchangedCount} unchanged`, color: 'gray' });
+    if (parts.length === 0 && !loading) {
+        return (_jsx(Box, { gap: 1, children: _jsx(Text, { dimColor: true, children: "Preview: no changes detected" }) }));
+    }
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Preview:" }), parts.map((part, i) => (_jsx(Text, { color: part.color, children: part.label }, i))), loading && _jsx(Text, { dimColor: true, children: "\u21BB" })] }));
+}

package/dist/src/analyze/select/tui/components/QuitDialog.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type QuitDialogProps = {
+    hasUnsavedDrafts: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+};
+export declare function QuitDialog({ hasUnsavedDrafts, onConfirm, onCancel }: QuitDialogProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/QuitDialog.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useImmediateInput } from '../hooks/useImmediateInput.js';
+export function QuitDialog({ hasUnsavedDrafts, onConfirm, onCancel }) {
+    useImmediateInput((input, key) => {
+        if (input === 'y' || key.return) {
+            onConfirm();
+        }
+        else if (input === 'n' || key.escape) {
+            onCancel();
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", padding: 1, width: 50, children: [_jsx(Text, { bold: true, children: '─'.repeat(19) + ' Quit ' + '─'.repeat(19) }), _jsx(Text, { children: " " }), hasUnsavedDrafts ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: "You have unsaved draft edits." }), _jsx(Text, { children: 'Session state is preserved — you can resume' }), _jsx(Text, { children: 'by running the same review command again.' })] })) : (_jsx(Text, { children: "Session is saved. Quit without finalizing?" })), _jsx(Text, { children: " " }), _jsx(Text, { children: '  [y / Enter]  Quit    [n / Esc]  Stay' })] }));
+}

package/dist/src/analyze/select/tui/components/Sidebar.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { ReviewComponentSummary } from '../../types.js';
+type SidebarProps = {
+    components: ReviewComponentSummary[];
+    selectedId: string | null;
+    focused: boolean;
+    scrollOffset: number;
+    visibleCount: number;
+    onSelect: (id: string) => void;
+    onScrollChange: (offset: number) => void;
+    collapsed?: boolean;
+    width?: number;
+};
+export declare function Sidebar({ components, selectedId, focused, scrollOffset, visibleCount, collapsed, width: widthProp, }: SidebarProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/Sidebar.js

@@ -0,0 +1,48 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+function statusIcon(status) {
+    switch (status) {
+        case 'accepted':
+            return '✓';
+        case 'rejected':
+            return '✗';
+        case 'reviewed':
+            return '~';
+        case 'needs-review':
+            return '·';
+    }
+}
+function statusColor(status) {
+    switch (status) {
+        case 'accepted':
+            return 'green';
+        case 'rejected':
+            return 'red';
+        case 'reviewed':
+            return 'yellow';
+        case 'needs-review':
+            return 'white';
+    }
+}
+function truncateName(name, maxLen) {
+    if (name.length <= maxLen)
+        return name;
+    return name.slice(0, maxLen) + '…';
+}
+export function Sidebar({ components, selectedId, focused, scrollOffset, visibleCount, collapsed = false, width: widthProp, }) {
+    const visible = components.slice(scrollOffset, scrollOffset + visibleCount);
+    const showScrollUp = scrollOffset > 0;
+    const showScrollDown = scrollOffset + visibleCount < components.length;
+    const width = collapsed ? 3 : (widthProp ?? 18);
+    return (_jsxs(Box, { flexDirection: "column", width: width, borderStyle: "single", borderColor: focused ? 'white' : undefined, children: [showScrollUp && !collapsed && _jsx(Text, { dimColor: true, children: "\u25B2" }), visible.map((component) => {
+                const isSelected = component.id === selectedId;
+                const icon = statusIcon(component.status);
+                const color = statusColor(component.status);
+                const maxNameLen = Math.max(1, width - 5);
+                const name = truncateName(component.name, maxNameLen);
+                if (collapsed) {
+                    return (_jsx(Box, { children: _jsx(Text, { color: color, inverse: isSelected && focused, underline: isSelected && !focused, children: icon }) }, component.id));
+                }
+                return (_jsx(Box, { children: _jsx(Text, { color: color, inverse: isSelected && focused, underline: isSelected && !focused, wrap: "truncate", children: icon + ' ' + name }) }, component.id));
+            }), showScrollDown && !collapsed && _jsx(Text, { dimColor: true, children: "\u25BC" })] }));
+}

package/dist/src/analyze/select/tui/components/SourcePanel.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type SourcePanelProps = {
+    sourceCode: string | null;
+    filePath: string;
+    width: number;
+    height: number;
+    scrollX: number;
+    scrollY: number;
+};
+export declare function SourcePanel({ sourceCode, filePath, width, height, scrollX, scrollY, }: SourcePanelProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/SourcePanel.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const KEYWORDS = /\b(function|export|const|let|import|return|interface|type|default|class|extends|implements|from|async|await)\b/;
+function highlightSourceLine(line) {
+    const parts = [];
+    let remaining = line;
+    while (remaining.length > 0) {
+        // String literal
+        const strMatch = remaining.match(/^("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|`(?:[^`\\]|\\.)*`)/);
+        if (strMatch) {
+            parts.push({ text: strMatch[1], color: 'green' });
+            remaining = remaining.slice(strMatch[1].length);
+            continue;
+        }
+        // Keyword
+        const kwMatch = remaining.match(KEYWORDS);
+        if (kwMatch && kwMatch.index === 0) {
+            parts.push({ text: kwMatch[0], color: 'cyan' });
+            remaining = remaining.slice(kwMatch[0].length);
+            continue;
+        }
+        parts.push({ text: remaining[0] });
+        remaining = remaining.slice(1);
+    }
+    return (_jsx(_Fragment, { children: parts.map((part, i) => (_jsx(Text, { color: part.color, children: part.text }, i))) }));
+}
+function truncateFilePath(filePath, maxWidth) {
+    if (filePath.length <= maxWidth)
+        return filePath;
+    const filename = filePath.split('/').pop() ?? filePath;
+    if (filename.length >= maxWidth)
+        return filename.slice(0, maxWidth - 1) + '…';
+    return '…' + filePath.slice(filePath.length - (maxWidth - 1));
+}
+export function SourcePanel({ sourceCode, filePath, width, height, scrollX, scrollY, }) {
+    const innerWidth = Math.max(1, width - 2);
+    const header = truncateFilePath(filePath, innerWidth);
+    if (!sourceCode) {
+        return (_jsxs(Box, { flexDirection: "column", width: width, height: height + 2, borderStyle: "single", children: [_jsx(Text, { dimColor: true, children: header }), _jsx(Box, { justifyContent: "center", alignItems: "center", height: height, children: _jsx(Text, { dimColor: true, children: "[No source available]" }) })] }));
+    }
+    const allLines = sourceCode.split('\n');
+    const visibleLines = allLines.slice(scrollY, scrollY + height);
+    const showScrollUp = scrollY > 0;
+    const showScrollDown = scrollY + height < allLines.length;
+    const maxLineWidth = Math.max(...visibleLines.map((l) => l.length));
+    const showScrollLeft = scrollX > 0;
+    const showScrollRight = scrollX + innerWidth < maxLineWidth;
+    return (_jsxs(Box, { flexDirection: "column", width: width, height: height + 2, borderStyle: "single", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { dimColor: true, children: header }), _jsxs(Text, { dimColor: true, children: [showScrollUp ? '▲' : ' ', showScrollDown ? '▼' : ' ', showScrollLeft ? '◀' : ' ', showScrollRight ? '▶' : ' '] })] }), visibleLines.map((line, i) => {
+                const sliced = line.slice(scrollX, scrollX + innerWidth);
+                return _jsx(Box, { children: highlightSourceLine(sliced) }, i);
+            })] }));
+}

package/dist/src/analyze/select/tui/components/StatusBar.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type StatusBarProps = {
+    accepted: number;
+    rejected: number;
+    reviewed: number;
+    needsReview: number;
+    onApproveAll: () => void;
+    onFinalize: () => void;
+};
+export declare function StatusBar({ accepted, rejected, reviewed, needsReview }: StatusBarProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/StatusBar.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function StatusBar({ accepted, rejected, reviewed, needsReview }) {
+    const allResolved = needsReview === 0;
+    return (_jsxs(Box, { gap: 2, flexWrap: "wrap", children: [_jsxs(Text, { color: "green", children: [accepted, " accepted"] }), _jsxs(Text, { color: "red", children: [rejected, " rejected"] }), _jsxs(Text, { dimColor: true, children: [needsReview, " pending"] }), _jsxs(Text, { color: "cyan", children: [reviewed, " reviewed"] }), _jsx(Text, { dimColor: true, children: "\u00B7" }), _jsx(Text, { dimColor: true, children: "[A] accept all" }), _jsx(Text, { bold: allResolved, color: allResolved ? 'green' : 'white', children: "[F] finalize" })] }));
+}

package/dist/src/analyze/select/tui/components/TopBar.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type TopBarProps = {
+    subcommand: string;
+    hints: Array<{
+        key: string;
+        label: string;
+    }>;
+};
+export declare function TopBar({ subcommand, hints }: TopBarProps): React.ReactElement;
+export {};

package/dist/src/analyze/select/tui/components/TopBar.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+export function TopBar({ subcommand, hints }) {
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: 'experience-design-system-cli  ' + subcommand }), _jsx(Text, { dimColor: true, children: hints.map((h) => `[${h.key}] ${h.label}`).join('  ') })] }));
+}

package/dist/src/analyze/select/tui/hooks/useImmediateInput.d.ts

@@ -0,0 +1,24 @@
+type Key = {
+    upArrow: boolean;
+    downArrow: boolean;
+    leftArrow: boolean;
+    rightArrow: boolean;
+    pageDown: boolean;
+    pageUp: boolean;
+    return: boolean;
+    escape: boolean;
+    ctrl: boolean;
+    shift: boolean;
+    tab: boolean;
+    backspace: boolean;
+    delete: boolean;
+    meta: boolean;
+};
+type InputHandler = (input: string, key: Key) => void;
+/**
+ * Like Ink's useInput, but uses useLayoutEffect so the listener is registered
+ * synchronously after render. This allows stdin.write() calls in tests to work
+ * immediately after render() without awaiting effects.
+ */
+export declare function useImmediateInput(handler: InputHandler): void;
+export {};

package/dist/src/analyze/select/tui/hooks/useImmediateInput.js

@@ -0,0 +1,68 @@
+import { useLayoutEffect, useRef } from 'react';
+import { useStdin } from 'ink';
+function parseInput(data) {
+    const key = {
+        upArrow: data === '\x1b[A',
+        downArrow: data === '\x1b[B',
+        leftArrow: data === '\x1b[D',
+        rightArrow: data === '\x1b[C',
+        pageDown: data === '\x1b[6~',
+        pageUp: data === '\x1b[5~',
+        return: data === '\r' || data === '\n',
+        escape: data === '\x1b',
+        ctrl: false,
+        shift: false,
+        tab: data === '\t',
+        backspace: data === '\x7f' || data === '\b',
+        delete: data === '\x1b[3~',
+        meta: data === '\x1b',
+    };
+    let input = data;
+    // Ctrl+letter: data is \x01-\x1a (Ctrl+A through Ctrl+Z)
+    if (data.length === 1) {
+        const code = data.charCodeAt(0);
+        if (code >= 1 && code <= 26) {
+            key.ctrl = true;
+            input = String.fromCharCode(code + 96); // convert to lowercase letter
+        }
+    }
+    // Arrow keys and special keys produce no printable input
+    if (key.upArrow ||
+        key.downArrow ||
+        key.leftArrow ||
+        key.rightArrow ||
+        key.pageUp ||
+        key.pageDown ||
+        key.return ||
+        key.escape ||
+        key.tab ||
+        key.backspace ||
+        key.delete) {
+        if (!key.ctrl)
+            input = '';
+    }
+    return { input, key };
+}
+/**
+ * Like Ink's useInput, but uses useLayoutEffect so the listener is registered
+ * synchronously after render. This allows stdin.write() calls in tests to work
+ * immediately after render() without awaiting effects.
+ */
+export function useImmediateInput(handler) {
+    const { stdin, setRawMode } = useStdin();
+    const handlerRef = useRef(handler);
+    handlerRef.current = handler;
+    useLayoutEffect(() => {
+        setRawMode(true);
+        const handleData = (data) => {
+            const str = Buffer.isBuffer(data) ? data.toString('utf8') : data;
+            const { input, key } = parseInput(str);
+            handlerRef.current(input, key);
+        };
+        stdin.on('data', handleData);
+        return () => {
+            stdin.off('data', handleData);
+            setRawMode(false);
+        };
+    }, [stdin, setRawMode]);
+}

package/dist/src/analyze/select/tui/hooks/useKeymap.d.ts

@@ -0,0 +1,24 @@
+type KeymapContext = {
+    sidebarFocused: boolean;
+    editMode: boolean;
+    dialogOpen: boolean;
+    disabled: boolean;
+};
+type KeymapHandlers = {
+    onSidebarUp: () => void;
+    onSidebarDown: () => void;
+    onSidebarSelect: () => void;
+    onAccept: () => void;
+    onReject: () => void;
+    onEnterEditMode: () => void;
+    onToggleSource: () => void;
+    onScrollUp: () => void;
+    onScrollDown: () => void;
+    onToggleFocus: () => void;
+    onApproveAll: () => void;
+    onFinalize: () => void;
+    onQuit: () => void;
+    onToggleHelp: () => void;
+};
+export declare function useKeymap(context: KeymapContext, handlers: KeymapHandlers): void;
+export {};

package/dist/src/analyze/select/tui/hooks/useKeymap.js

@@ -0,0 +1,67 @@
+import { useImmediateInput } from './useImmediateInput.js';
+export function useKeymap(context, handlers) {
+    useImmediateInput((input, key) => {
+        if (context.disabled)
+            return;
+        if (context.dialogOpen)
+            return;
+        if (context.editMode)
+            return;
+        if (input === 'q') {
+            handlers.onQuit();
+            return;
+        }
+        if (input === '?') {
+            handlers.onToggleHelp();
+            return;
+        }
+        if (key.tab) {
+            handlers.onToggleFocus();
+            return;
+        }
+        if (input === 'A') {
+            handlers.onApproveAll();
+            return;
+        }
+        if (input === 'F') {
+            handlers.onFinalize();
+            return;
+        }
+        // a/r/e/s work regardless of sidebar focus
+        if (input === 'a') {
+            handlers.onAccept();
+            return;
+        }
+        if (input === 'r') {
+            handlers.onReject();
+            return;
+        }
+        if (input === 'e') {
+            handlers.onEnterEditMode();
+            return;
+        }
+        if (input === 's') {
+            handlers.onToggleSource();
+            return;
+        }
+        if (context.sidebarFocused) {
+            if (key.upArrow || input === 'k') {
+                handlers.onSidebarUp();
+            }
+            else if (key.downArrow || input === 'j') {
+                handlers.onSidebarDown();
+            }
+            else if (key.return) {
+                handlers.onSidebarSelect();
+            }
+        }
+        else {
+            if (key.upArrow || input === 'k') {
+                handlers.onScrollUp();
+            }
+            else if (key.downArrow || input === 'j') {
+                handlers.onScrollDown();
+            }
+        }
+    });
+}