@a9s/cli 0.0.1 → 1.0.6

package/dist/src/components/AdvancedTextInput.js

@@ -0,0 +1,200 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { Text, useInput } from "ink";
+function clamp(n, min, max) {
+    return Math.max(min, Math.min(max, n));
+}
+function isWordChar(char) {
+    return /[A-Za-z0-9_]/.test(char);
+}
+export function moveCursorWordLeft(text, cursor) {
+    let i = clamp(cursor, 0, text.length);
+    while (i > 0 && !isWordChar(text[i - 1] ?? ""))
+        i -= 1;
+    while (i > 0 && isWordChar(text[i - 1] ?? ""))
+        i -= 1;
+    return i;
+}
+export function moveCursorWordRight(text, cursor) {
+    let i = clamp(cursor, 0, text.length);
+    while (i < text.length && !isWordChar(text[i] ?? ""))
+        i += 1;
+    while (i < text.length && isWordChar(text[i] ?? ""))
+        i += 1;
+    return i;
+}
+export function decodeAltWordDirection(input, key) {
+    if (key.meta && key.leftArrow)
+        return "left";
+    if (key.meta && key.rightArrow)
+        return "right";
+    // Fallbacks used by various terminals for Alt/Option+Left/Right.
+    if (input === "\u001bb")
+        return "left";
+    if (input === "\u001bf")
+        return "right";
+    if (input === "\u001b[1;3D" || input === "\u001b[1;9D")
+        return "left";
+    if (input === "\u001b[1;3C" || input === "\u001b[1;9C")
+        return "right";
+    return null;
+}
+function isBackspaceSignal(input, key) {
+    // Don't match Alt+Backspace sequences (they start with ESC)
+    if (input.startsWith("\u001b"))
+        return false;
+    // Accept delete key without meta as backspace (some terminals report backspace as delete)
+    return (key.backspace ||
+        input === "\u0008" ||
+        input === "\u007f" ||
+        (key.delete && !key.meta && input === ""));
+}
+function isDeleteSignal(input, _key) {
+    return input === "\u001b[3~";
+}
+export function isAltBackspaceSignal(input, key) {
+    // Ink interprets Alt+Backspace as Alt+Delete
+    if (key.meta && key.delete) {
+        return true;
+    }
+    if (key.meta && key.backspace) {
+        return true;
+    }
+    // Fallback for Alt+Backspace sequences in various terminals
+    if (input === "\u001b\u007f")
+        return true; // ESC+DEL
+    if (input === "\u001b\u0008")
+        return true; // ESC+BS
+    if (input === "\u001b[3;3~")
+        return true; // Alt+Del variant
+    if (input === "\u001b[127")
+        return true; // ESC+127
+    if (input === "\u001bDEL")
+        return true; // ESC+literal DEL
+    return false;
+}
+export function applyAdvancedInputEdit(currentValue, currentCursor, input, key) {
+    const cursor = clamp(currentCursor, 0, currentValue.length);
+    if (key.return) {
+        return { value: currentValue, cursor, submit: true, handled: true };
+    }
+    const wordDirection = decodeAltWordDirection(input, key);
+    if (wordDirection === "left") {
+        return {
+            value: currentValue,
+            cursor: moveCursorWordLeft(currentValue, cursor),
+            submit: false,
+            handled: true,
+        };
+    }
+    if (wordDirection === "right") {
+        return {
+            value: currentValue,
+            cursor: moveCursorWordRight(currentValue, cursor),
+            submit: false,
+            handled: true,
+        };
+    }
+    if (key.leftArrow) {
+        return { value: currentValue, cursor: Math.max(0, cursor - 1), submit: false, handled: true };
+    }
+    if (key.rightArrow) {
+        return {
+            value: currentValue,
+            cursor: Math.min(currentValue.length, cursor + 1),
+            submit: false,
+            handled: true,
+        };
+    }
+    if (key.home) {
+        return { value: currentValue, cursor: 0, submit: false, handled: true };
+    }
+    if (key.end) {
+        return { value: currentValue, cursor: currentValue.length, submit: false, handled: true };
+    }
+    // Check Alt+Backspace first (before regular Backspace) since both use backspace flag
+    if (isAltBackspaceSignal(input, key)) {
+        if (cursor <= 0)
+            return { value: currentValue, cursor, submit: false, handled: true };
+        const wordStart = moveCursorWordLeft(currentValue, cursor);
+        const next = currentValue.slice(0, wordStart) + currentValue.slice(cursor);
+        return { value: next, cursor: wordStart, submit: false, handled: true };
+    }
+    if (isBackspaceSignal(input, key)) {
+        if (cursor <= 0)
+            return { value: currentValue, cursor, submit: false, handled: true };
+        const next = currentValue.slice(0, cursor - 1) + currentValue.slice(cursor);
+        return { value: next, cursor: cursor - 1, submit: false, handled: true };
+    }
+    if (isDeleteSignal(input, key)) {
+        if (cursor >= currentValue.length) {
+            return { value: currentValue, cursor, submit: false, handled: true };
+        }
+        const next = currentValue.slice(0, cursor) + currentValue.slice(cursor + 1);
+        return { value: next, cursor, submit: false, handled: true };
+    }
+    if (key.ctrl || key.meta || key.escape || key.tab) {
+        return { value: currentValue, cursor, submit: false, handled: false };
+    }
+    if (!input) {
+        return { value: currentValue, cursor, submit: false, handled: false };
+    }
+    // Ignore control escape-sequences or other non-printable input.
+    // eslint-disable-next-line no-control-regex
+    if (input.length > 1 || /[\u0000-\u001f\u007f]/.test(input)) {
+        return { value: currentValue, cursor, submit: false, handled: false };
+    }
+    const next = currentValue.slice(0, cursor) + input + currentValue.slice(cursor);
+    return {
+        value: next,
+        cursor: cursor + input.length,
+        submit: false,
+        handled: true,
+    };
+}
+export function AdvancedTextInput({ value, onChange, onSubmit, placeholder, focus = true, cursorToEndToken, }) {
+    const [cursor, setCursor] = useState(value.length);
+    useEffect(() => {
+        setCursor((prev) => clamp(prev, 0, value.length));
+    }, [value]);
+    useEffect(() => {
+        if (cursorToEndToken === undefined)
+            return;
+        setCursor(value.length);
+    }, [cursorToEndToken, value.length]);
+    useInput((input, key) => {
+        if (!focus)
+            return;
+        const result = applyAdvancedInputEdit(value, cursor, input, key);
+        if (!result.handled)
+            return;
+        if (result.value !== value) {
+            onChange(result.value);
+        }
+        if (result.cursor !== cursor) {
+            setCursor(result.cursor);
+        }
+        if (result.submit) {
+            onSubmit();
+        }
+    }, { isActive: focus });
+    const rendered = useMemo(() => {
+        if (value.length === 0) {
+            return { isPlaceholder: true, text: placeholder ?? "" };
+        }
+        const safeCursor = clamp(cursor, 0, value.length);
+        const before = value.slice(0, safeCursor);
+        const at = safeCursor < value.length ? value[safeCursor] : " ";
+        const after = value.slice(Math.min(value.length, safeCursor + 1));
+        return {
+            isPlaceholder: false,
+            before,
+            at,
+            after,
+        };
+    }, [cursor, placeholder, value]);
+    if (rendered.isPlaceholder) {
+        return _jsx(Text, { color: "gray", children: rendered.text });
+    }
+    return (_jsxs(Text, { children: [rendered.before, _jsx(Text, { inverse: true, children: rendered.at }), rendered.after] }));
+}

package/dist/src/components/AdvancedTextInput.test.js

@@ -0,0 +1,190 @@
+import { describe, expect, it } from "vitest";
+import { applyAdvancedInputEdit, decodeAltWordDirection, moveCursorWordLeft, moveCursorWordRight, isAltBackspaceSignal, } from "./AdvancedTextInput.js";
+function makeKey(patch = {}) {
+    return {
+        upArrow: false,
+        downArrow: false,
+        leftArrow: false,
+        rightArrow: false,
+        pageDown: false,
+        pageUp: false,
+        home: false,
+        end: false,
+        return: false,
+        escape: false,
+        ctrl: false,
+        shift: false,
+        tab: false,
+        backspace: false,
+        delete: false,
+        meta: false,
+        ...patch,
+    };
+}
+describe("AdvancedTextInput helpers", () => {
+    it("moves by words left and right across spaces/punctuation", () => {
+        const text = "hello, world  test";
+        expect(moveCursorWordLeft(text, text.length)).toBe(14);
+        expect(moveCursorWordLeft(text, 14)).toBe(7);
+        expect(moveCursorWordLeft(text, 7)).toBe(0);
+        expect(moveCursorWordRight(text, 0)).toBe(5);
+        expect(moveCursorWordRight(text, 5)).toBe(12);
+        expect(moveCursorWordRight(text, 12)).toBe(18);
+    });
+    it("decodes alt/meta word directions", () => {
+        expect(decodeAltWordDirection("", makeKey({ meta: true, leftArrow: true }))).toBe("left");
+        expect(decodeAltWordDirection("", makeKey({ meta: true, rightArrow: true }))).toBe("right");
+        expect(decodeAltWordDirection("\u001bb", makeKey())).toBe("left");
+        expect(decodeAltWordDirection("\u001bf", makeKey())).toBe("right");
+        expect(decodeAltWordDirection("\u001b[1;3D", makeKey())).toBe("left");
+        expect(decodeAltWordDirection("\u001b[1;3C", makeKey())).toBe("right");
+        expect(decodeAltWordDirection("x", makeKey())).toBeNull();
+    });
+    it("supports insertion, deletion, and submit", () => {
+        const ins = applyAdvancedInputEdit("hello", 5, "!", makeKey());
+        expect(ins.value).toBe("hello!");
+        expect(ins.cursor).toBe(6);
+        const back = applyAdvancedInputEdit("hello", 5, "", makeKey({ backspace: true }));
+        expect(back.value).toBe("hell");
+        expect(back.cursor).toBe(4);
+        // Note: delete key without meta is treated as backspace (deletes before cursor)
+        // because some terminals report backspace as delete key
+        const del = applyAdvancedInputEdit("hello", 1, "", makeKey({ delete: true }));
+        expect(del.value).toBe("ello");
+        expect(del.cursor).toBe(0);
+        const submit = applyAdvancedInputEdit("hello", 5, "", makeKey({ return: true }));
+        expect(submit.submit).toBe(true);
+    });
+    it("handles backspace with single character", () => {
+        // Backspace after single character should delete it
+        const singleCharEnd = applyAdvancedInputEdit("a", 1, "", makeKey({ backspace: true }));
+        expect(singleCharEnd.value).toBe("");
+        expect(singleCharEnd.cursor).toBe(0);
+        // Backspace at start should do nothing
+        const singleCharStart = applyAdvancedInputEdit("a", 0, "", makeKey({ backspace: true }));
+        expect(singleCharStart.value).toBe("a");
+        expect(singleCharStart.cursor).toBe(0);
+    });
+    it("handles backspace when reported as delete key (terminal issue in search mode)", () => {
+        // Some terminals report backspace as key.delete with empty input
+        // This is critical for search mode where users can't delete characters otherwise
+        const deleteAsBackspace = applyAdvancedInputEdit("search", 6, "", makeKey({ delete: true }));
+        expect(deleteAsBackspace.value).toBe("searc");
+        expect(deleteAsBackspace.cursor).toBe(5);
+        // Multiple backspaces in sequence
+        const secondBackspace = applyAdvancedInputEdit("searc", 5, "", makeKey({ delete: true }));
+        expect(secondBackspace.value).toBe("sear");
+        expect(secondBackspace.cursor).toBe(4);
+        // Backspace in middle of text (reported as delete)
+        const middleBackspace = applyAdvancedInputEdit("hello", 3, "", makeKey({ delete: true }));
+        expect(middleBackspace.value).toBe("helo");
+        expect(middleBackspace.cursor).toBe(2);
+        // Alt+Delete should still delete word, not single char
+        const altDelete = applyAdvancedInputEdit("foo bar", 7, "", makeKey({ delete: true, meta: true }));
+        expect(altDelete.value).toBe("foo ");
+        expect(altDelete.cursor).toBe(4);
+    });
+    it("treats raw terminal backspace/delete sequences as editing signals", () => {
+        const bsAscii = applyAdvancedInputEdit("hello", 5, "\u007f", makeKey());
+        expect(bsAscii.value).toBe("hell");
+        expect(bsAscii.cursor).toBe(4);
+        const bsCtrlH = applyAdvancedInputEdit("hello", 5, "\u0008", makeKey());
+        expect(bsCtrlH.value).toBe("hell");
+        expect(bsCtrlH.cursor).toBe(4);
+        const delSeq = applyAdvancedInputEdit("hello", 1, "\u001b[3~", makeKey());
+        expect(delSeq.value).toBe("hllo");
+        expect(delSeq.cursor).toBe(1);
+    });
+    it("does not insert control/escape sequences as text", () => {
+        const escSeq = applyAdvancedInputEdit("hello", 5, "\u001b[A", makeKey());
+        expect(escSeq.value).toBe("hello");
+        expect(escSeq.handled).toBe(false);
+    });
+    it("supports word jump edit flow via meta and fallback escape sequence", () => {
+        const leftMeta = applyAdvancedInputEdit("foo bar baz", 11, "", makeKey({ meta: true, leftArrow: true }));
+        expect(leftMeta.cursor).toBe(8);
+        const leftSeq = applyAdvancedInputEdit("foo bar baz", 8, "\u001bb", makeKey());
+        expect(leftSeq.cursor).toBe(4);
+        const rightMeta = applyAdvancedInputEdit("foo bar baz", 4, "", makeKey({ meta: true, rightArrow: true }));
+        expect(rightMeta.cursor).toBe(7);
+        const rightSeq = applyAdvancedInputEdit("foo bar baz", 7, "\u001bf", makeKey());
+        expect(rightSeq.cursor).toBe(11);
+    });
+    it("detects alt/option+backspace signals", () => {
+        // Via key object
+        expect(isAltBackspaceSignal("", makeKey({ meta: true, backspace: true }))).toBe(true);
+        // Via escape sequences (various terminals)
+        expect(isAltBackspaceSignal("\u001b\u007f", makeKey())).toBe(true); // ESC + DEL
+        expect(isAltBackspaceSignal("\u001b\u0008", makeKey())).toBe(true); // ESC + Backspace
+        expect(isAltBackspaceSignal("\u001b[3;3~", makeKey())).toBe(true); // Alt+Delete variant
+        // Non-matches
+        expect(isAltBackspaceSignal("", makeKey({ backspace: true }))).toBe(false);
+        expect(isAltBackspaceSignal("x", makeKey())).toBe(false);
+    });
+    it("deletes whole word before cursor with alt+backspace", () => {
+        // Delete "baz" when cursor is at position 11 (end of "foo bar baz")
+        const deleteEnd = applyAdvancedInputEdit("foo bar baz", 11, "", makeKey({ meta: true, backspace: true }));
+        expect(deleteEnd.value).toBe("foo bar ");
+        expect(deleteEnd.cursor).toBe(8);
+        // Delete "bar" when cursor is at position 7 (the space after "bar")
+        // moveCursorWordLeft("foo bar baz", 7) returns 4, so we delete from 4 to 7
+        // slice(0, 4) = "foo " + slice(7) = " baz" = "foo  baz"
+        const deleteMiddle = applyAdvancedInputEdit("foo bar baz", 7, "", makeKey({ meta: true, backspace: true }));
+        expect(deleteMiddle.value).toBe("foo  baz");
+        expect(deleteMiddle.cursor).toBe(4);
+        // Delete "foo" when cursor is at position 3 (the space after "foo")
+        // moveCursorWordLeft("foo bar baz", 3) returns 0
+        const deleteStart = applyAdvancedInputEdit("foo bar baz", 3, "", makeKey({ meta: true, backspace: true }));
+        expect(deleteStart.value).toBe(" bar baz");
+        expect(deleteStart.cursor).toBe(0);
+    });
+    it("handles alt+backspace with trailing/leading spaces", () => {
+        // Delete "hello" when cursor is at position 5 (after "hello")
+        // moveCursorWordLeft("hello   world", 5) returns 0
+        // Delete from 0 to 5 removes "hello"
+        const trailingSpaces = applyAdvancedInputEdit("hello   world", 5, "", makeKey({ meta: true, backspace: true }));
+        expect(trailingSpaces.value).toBe("   world");
+        expect(trailingSpaces.cursor).toBe(0);
+        // "hello   world" at cursor 8 ('w' position)
+        // moveCursorWordLeft returns 0 (goes back through 3 spaces and entire "hello")
+        // So we delete from 0 to 8, leaving "world"
+        const deleteSpaces = applyAdvancedInputEdit("hello   world", 8, "", makeKey({ meta: true, backspace: true }));
+        expect(deleteSpaces.value).toBe("world");
+        expect(deleteSpaces.cursor).toBe(0);
+        // Delete "world" when cursor is at position 13 (end of string)
+        // moveCursorWordLeft("hello   world", 13) returns 8 (skips back through "world" and 3 spaces to after "hello")
+        const deleteWordAfterSpaces = applyAdvancedInputEdit("hello   world", 13, "", makeKey({ meta: true, backspace: true }));
+        expect(deleteWordAfterSpaces.value).toBe("hello   ");
+        expect(deleteWordAfterSpaces.cursor).toBe(8);
+    });
+    it("handles alt+backspace at start of input", () => {
+        // At position 0, nothing should be deleted
+        const atStart = applyAdvancedInputEdit("hello world", 0, "", makeKey({ meta: true, backspace: true }));
+        expect(atStart.value).toBe("hello world");
+        expect(atStart.cursor).toBe(0);
+    });
+    it("supports alt+backspace via escape sequences", () => {
+        // Using \u001b\u007f (Alt+Backspace in some terminals)
+        const escSeq1 = applyAdvancedInputEdit("foo bar baz", 11, "\u001b\u007f", makeKey());
+        expect(escSeq1.value).toBe("foo bar ");
+        expect(escSeq1.cursor).toBe(8);
+        // Using \u001b\u0008 (Alt+Backspace in other terminals)
+        const escSeq2 = applyAdvancedInputEdit("foo bar baz", 11, "\u001b\u0008", makeKey());
+        expect(escSeq2.value).toBe("foo bar ");
+        expect(escSeq2.cursor).toBe(8);
+    });
+    it("alt+backspace deletes full word even with numbers/underscores", () => {
+        // "foo test_var123 bar", cursor at 14 (the '3' in '123')
+        // moveCursorWordLeft at 14 returns 4 (start of "test_var123")
+        // Delete from 4 to 14: slice(0,4)="foo " + slice(14)="3 bar" = "foo 3 bar"
+        const wordChars = applyAdvancedInputEdit("foo test_var123 bar", 14, "", makeKey({ meta: true, backspace: true }));
+        expect(wordChars.value).toBe("foo 3 bar");
+        expect(wordChars.cursor).toBe(4);
+        // "hello_world", cursor at 8 (the 'r')
+        // moveCursorWordLeft at 8 returns 0 (entire "hello_wor" is one word)
+        // Delete from 0 to 8, leaving "rld"
+        const midWord = applyAdvancedInputEdit("hello_world", 8, "", makeKey({ meta: true, backspace: true }));
+        expect(midWord.value).toBe("rld");
+        expect(midWord.cursor).toBe(0);
+    });
+});

package/dist/src/components/AutocompleteInput.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useEffect, useImperativeHandle, useMemo, useState } from "react";
+import { Box, Text } from "ink";
+import { AdvancedTextInput } from "./AdvancedTextInput.js";
+export const AutocompleteInput = React.forwardRef(({ value, onChange, onSubmit, placeholder, suggestions = [], focus = true, cursorToEndToken }, ref) => {
+    const [inputKey, setInputKey] = useState(0);
+    const matchingSuggestions = useMemo(() => {
+        if (!value || suggestions.length === 0)
+            return [];
+        return suggestions.filter((s) => s.toLowerCase().startsWith(value.toLowerCase()));
+    }, [value, suggestions]);
+    const firstMatch = matchingSuggestions[0];
+    const suggestion = firstMatch ? firstMatch.slice(value.length) : "";
+    useImperativeHandle(ref, () => ({
+        autocomplete: () => {
+            if (firstMatch && firstMatch !== value) {
+                onChange(firstMatch);
+                // Remount input to move cursor to end
+                setInputKey((k) => k + 1);
+            }
+        },
+    }));
+    useEffect(() => {
+        if (cursorToEndToken === undefined)
+            return;
+        setInputKey((k) => k + 1);
+    }, [cursorToEndToken]);
+    return (_jsxs(Box, { children: [_jsx(AdvancedTextInput, { value: value, onChange: onChange, onSubmit: onSubmit, placeholder: placeholder, focus: focus, ...(cursorToEndToken !== undefined ? { cursorToEndToken } : {}) }, `autocomplete-input-${inputKey}`), suggestion && (_jsx(Text, { color: "gray", dimColor: true, children: suggestion }))] }));
+});

package/dist/src/components/DetailPanel.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function DetailPanel({ title, fields, isLoading, scrollOffset, visibleLines, }) {
+    const labelWidth = Math.max(...fields.map((f) => f.label.length), 12);
+    // Clamp scrollOffset to valid range
+    const clampedOffset = Math.max(0, Math.min(scrollOffset, Math.max(0, fields.length - visibleLines)));
+    // Show visible fields only
+    const visibleFields = fields.slice(clampedOffset, clampedOffset + visibleLines);
+    const hasMoreAbove = clampedOffset > 0;
+    const hasMoreBelow = clampedOffset + visibleLines < fields.length;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsx(Text, { bold: true, color: "blue", children: title }), _jsx(Text, { color: "gray", children: "─".repeat(40) }), isLoading ? (_jsx(Text, { color: "gray", children: "Loading..." })) : (_jsxs(_Fragment, { children: [hasMoreAbove && (_jsxs(Text, { color: "gray", dimColor: true, children: ["\u2191 ", clampedOffset, " more above"] })), visibleFields.map((f) => (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: f.label.padEnd(labelWidth + 2) }), _jsx(Text, { children: f.value })] }, f.label))), hasMoreBelow && (_jsxs(Text, { color: "gray", dimColor: true, children: ["\u2193 ", fields.length - clampedOffset - visibleLines, " more below"] }))] })), _jsx(Text, { color: "gray", children: "─".repeat(40) }), _jsx(Text, { color: "gray", children: "j/k scroll \u2022 Esc close" })] }));
+}

package/dist/src/components/DiffViewer.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function DiffViewer({ oldValue, newValue, scrollOffset, visibleLines }) {
+    const oldLines = oldValue.split("\n");
+    const newLines = newValue.split("\n");
+    const maxLines = Math.max(oldLines.length, newLines.length);
+    // Clamp scrollOffset to valid range
+    const clampedOffset = Math.max(0, Math.min(scrollOffset, Math.max(0, maxLines - visibleLines)));
+    // Show visible lines only
+    const oldDisplay = oldLines.slice(clampedOffset, clampedOffset + visibleLines).join("\n");
+    const newDisplay = newLines.slice(clampedOffset, clampedOffset + visibleLines).join("\n");
+    const hasMoreAbove = clampedOffset > 0;
+    const hasMoreBelow = clampedOffset + visibleLines < maxLines;
+    // Calculate column width
+    const colWidth = 35;
+    return (_jsxs(Box, { flexDirection: "column", gap: 0, children: [_jsxs(Box, { gap: 2, children: [_jsx(Box, { width: colWidth, children: _jsx(Text, { color: "red", bold: true, children: "Original" }) }), _jsx(Box, { children: _jsx(Text, { color: "green", bold: true, children: "Updated" }) })] }), _jsxs(Box, { gap: 2, children: [_jsx(Box, { width: colWidth, children: _jsx(Text, { color: "gray", children: "-".repeat(30) }) }), _jsx(Text, { color: "gray", children: "-".repeat(30) })] }), _jsxs(Box, { gap: 2, flexDirection: "column", children: [hasMoreAbove && (_jsxs(Box, { gap: 2, children: [_jsx(Box, { width: colWidth, children: _jsxs(Text, { color: "gray", dimColor: true, children: ["\u2191 ", clampedOffset, " lines above"] }) }), _jsxs(Text, { color: "gray", dimColor: true, children: ["\u2191 ", clampedOffset, " lines above"] })] })), _jsxs(Box, { gap: 2, children: [_jsx(Box, { width: colWidth, children: _jsx(Text, { children: oldDisplay }) }), _jsx(Box, { children: _jsx(Text, { children: newDisplay }) })] }), hasMoreBelow && (_jsxs(Box, { gap: 2, children: [_jsx(Box, { width: colWidth, children: _jsxs(Text, { color: "gray", dimColor: true, children: ["\u2193 ", maxLines - clampedOffset - visibleLines, " more lines"] }) }), _jsxs(Text, { color: "gray", dimColor: true, children: ["\u2193 ", maxLines - clampedOffset - visibleLines, " more lines"] })] }))] })] }));
+}

package/dist/src/components/ErrorStatePanel.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export function ErrorStatePanel({ title, message, hint }) {
+    return (_jsx(Box, { width: "100%", borderStyle: "round", borderColor: "red", children: _jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, color: "red", children: title }), _jsx(Text, { children: message }), hint ? _jsx(Text, { color: "gray", children: hint }) : null] }) }));
+}

package/dist/src/components/HUD.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Box, Text } from "ink";
+export function HUD({ serviceLabel, hudColor, path, accountName, accountId, awsProfile, currentIdentity, region, terminalWidth, loading = false, }) {
+    const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    const [spinnerIndex, setSpinnerIndex] = React.useState(0);
+    React.useEffect(() => {
+        if (!loading) {
+            setSpinnerIndex(0);
+            return;
+        }
+        const timer = setInterval(() => {
+            setSpinnerIndex((prev) => (prev + 1) % SPINNER_FRAMES.length);
+        }, 120);
+        return () => clearInterval(timer);
+    }, [loading]);
+    const truncate = (value, max) => value.length > max ? `${value.slice(0, Math.max(1, max - 1))}…` : value;
+    const nameMaxLen = Math.max(8, terminalWidth - 44);
+    const compactName = accountName.length > nameMaxLen ? `${accountName.slice(0, nameMaxLen - 1)}…` : accountName;
+    const idPart = `(${accountId})`;
+    const profilePart = `[${awsProfile}]`;
+    const leftTopRaw = `${compactName}${idPart}·${region}·${profilePart}`;
+    const spinnerWidth = loading ? 1 : 0;
+    const topPadLen = Math.max(0, terminalWidth - leftTopRaw.length - spinnerWidth);
+    const identityLine = truncate(currentIdentity || "-", Math.max(1, terminalWidth));
+    const identityPadLen = Math.max(0, terminalWidth - identityLine.length);
+    const label = ` ${serviceLabel.toUpperCase()} `;
+    const pathDisplay = ` ${path} `;
+    const padLen = Math.max(0, terminalWidth - label.length - pathDisplay.length);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "blue", bold: true, children: compactName }), _jsx(Text, { color: "yellow", bold: true, children: idPart }), _jsx(Text, { color: "gray", bold: true, children: "\u00B7" }), _jsx(Text, { color: "green", bold: true, children: region }), _jsx(Text, { color: "gray", bold: true, children: "\u00B7" }), _jsx(Text, { color: "magenta", bold: true, children: profilePart }), _jsx(Text, { children: " ".repeat(topPadLen) }), loading ? (_jsx(Text, { color: "cyan", bold: true, children: SPINNER_FRAMES[spinnerIndex] })) : null] }), _jsxs(Text, { color: "cyan", wrap: "truncate-end", children: [identityLine, " ".repeat(identityPadLen)] }), _jsxs(Box, { children: [_jsx(Text, { backgroundColor: hudColor.bg, color: hudColor.fg, bold: true, children: label }), _jsxs(Text, { backgroundColor: "gray", color: "white", children: [pathDisplay, " ".repeat(padLen)] })] })] }));
+}

package/dist/src/components/HelpPanel.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    if (maxLen <= 1)
+        return "…";
+    return `${text.slice(0, maxLen - 1)}…`;
+}
+export function HelpPanel({ title, scopeLabel, tabs, activeTab, terminalWidth, maxRows, scrollOffset, }) {
+    const currentTab = tabs[activeTab] ?? tabs[0];
+    const keyColWidth = 12;
+    const descColWidth = Math.max(16, terminalWidth - keyColWidth - 8);
+    const maxTabRowWidth = Math.max(16, terminalWidth - 2);
+    const tabRow = [];
+    let rowWidth = 0;
+    for (let idx = 0; idx < tabs.length; idx += 1) {
+        const shortTitle = truncate(tabs[idx]?.title ?? "Tab", 10);
+        const label = ` ${idx + 1}:${shortTitle} `;
+        if (rowWidth + label.length > maxTabRowWidth)
+            break;
+        tabRow.push({ idx, label });
+        rowWidth += label.length;
+    }
+    const listRowsBudget = Math.max(1, maxRows);
+    const visibleItems = (currentTab?.items ?? []).slice(scrollOffset, scrollOffset + listRowsBudget);
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, flexGrow: 1, children: [_jsx(Text, { bold: true, color: "blue", children: title }), _jsx(Text, { color: "gray", children: scopeLabel }), _jsx(Box, { children: tabRow.map((chip) => {
+                    const isActive = chip.idx === activeTab;
+                    return (_jsx(Text, { ...(isActive
+                            ? { backgroundColor: "blue", color: "white" }
+                            : { color: "cyan" }), bold: isActive, children: chip.label }, `chip-${chip.idx}`));
+                }) }), _jsx(Box, { flexDirection: "column", flexGrow: 1, children: visibleItems.map((item, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", bold: true, children: truncate(item.key, keyColWidth).padEnd(keyColWidth) }), _jsx(Text, { children: truncate(item.description, descColWidth) })] }, `${item.key}-${scrollOffset + idx}`))) })] }));
+}

package/dist/src/components/ModeBar.js

@@ -0,0 +1,43 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React, { useRef } from "react";
+import { Box, Text } from "ink";
+import { AutocompleteInput } from "./AutocompleteInput.js";
+import { AVAILABLE_COMMANDS } from "../constants/commands.js";
+const MODE_ICONS = {
+    navigate: "◉",
+    search: "/",
+    command: ":",
+};
+const MODE_COLORS = {
+    navigate: "blue",
+    search: "blue",
+    command: "blue",
+};
+export const ModeBar = React.forwardRef(({ mode, filterText, commandText, commandCursorToEndToken, hintOverride, pickerSearchActive, onFilterChange, onCommandChange, onFilterSubmit, onCommandSubmit, }, ref) => {
+    const commandInputRef = useRef(null);
+    const filterInputRef = useRef(null);
+    const renderHint = (hint) => {
+        const entries = hint
+            .trim()
+            .split("•")
+            .map((x) => x.trim())
+            .filter(Boolean);
+        return (_jsx(Text, { color: "gray", wrap: "truncate-end", children: entries.map((entry, idx) => {
+                const [rawKey, rawDesc] = entry.split("·").map((x) => x.trim());
+                const keyPart = rawKey ?? entry;
+                const descPart = rawDesc ?? "";
+                return (_jsxs(React.Fragment, { children: [_jsx(Text, { color: "yellow", children: keyPart }), descPart ? _jsxs(Text, { color: "gray", children: [" ", descPart] }) : null, idx < entries.length - 1 ? _jsx(Text, { color: "gray", children: " \u2022 " }) : null] }, `hint-${idx}`));
+            }) }));
+    };
+    React.useImperativeHandle(ref, () => ({
+        commandInput: commandInputRef.current ?? {},
+        filterInput: filterInputRef.current ?? {},
+    }));
+    const isPickerSearch = pickerSearchActive === true;
+    const icon = isPickerSearch ? "/" : MODE_ICONS[mode];
+    const showNavigateHint = mode === "navigate" && !isPickerSearch;
+    const showFilterInput = mode === "search" || isPickerSearch;
+    return (_jsx(Box, { flexDirection: "column", width: "100%", children: _jsxs(Box, { paddingX: 1, children: [_jsx(Text, { color: MODE_COLORS[mode], bold: true, children: icon }), _jsx(Text, { children: " " }), showNavigateHint && renderHint(hintOverride ?? ""), showFilterInput && (_jsx(AutocompleteInput, { ref: filterInputRef, value: filterText, onChange: onFilterChange, onSubmit: onFilterSubmit, placeholder: "Type to filter", focus: showFilterInput })), mode === "command" && (_jsx(AutocompleteInput, { ref: commandInputRef, value: commandText, onChange: onCommandChange, onSubmit: onCommandSubmit, placeholder: "Type a command", suggestions: [...AVAILABLE_COMMANDS], focus: mode === "command", ...(commandCursorToEndToken !== undefined
+                        ? { cursorToEndToken: commandCursorToEndToken }
+                        : {}) }))] }) }));
+});