@a9s/cli 0.0.1 → 0.1.0

package/dist/src/constants/keybindings.js

@@ -0,0 +1,530 @@
+import { KB } from "./keys.js";
+/** Convert a trigger to a human-readable display string */
+export function triggerToString(t) {
+    switch (t.type) {
+        case "key":
+            return t.char;
+        case "special":
+            return SPECIAL_DISPLAY[t.name];
+        case "chord":
+            return t.keys.join(" ");
+        case "any":
+            return t.of.map(triggerToString).join(" / ");
+    }
+}
+const SPECIAL_DISPLAY = {
+    return: "Enter",
+    escape: "Esc",
+    tab: "Tab",
+    upArrow: "↑",
+    downArrow: "↓",
+    leftArrow: "←",
+    rightArrow: "→",
+};
+const SCOPE_LABELS = {
+    navigate: "Navigate",
+    search: "Search",
+    command: "Command",
+    yank: "Yank",
+    details: "Details",
+    upload: "Upload",
+    picker: "Pickers",
+    help: "Help Panel",
+};
+// ---------------------------------------------------------------------------
+// Registry — THE single source of truth for every keybinding
+// ---------------------------------------------------------------------------
+const j_down = {
+    type: "any",
+    of: [
+        { type: "key", char: "j" },
+        { type: "special", name: "downArrow" },
+    ],
+};
+const k_up = {
+    type: "any",
+    of: [
+        { type: "key", char: "k" },
+        { type: "special", name: "upArrow" },
+    ],
+};
+export const KEYBINDINGS = [
+    // --- Navigate ---
+    {
+        action: KB.MOVE_DOWN,
+        trigger: j_down,
+        scope: "navigate",
+        label: "Move selection down",
+        shortLabel: "down",
+    },
+    {
+        action: KB.MOVE_UP,
+        trigger: k_up,
+        scope: "navigate",
+        label: "Move selection up",
+        shortLabel: "up",
+    },
+    {
+        action: KB.GO_TOP,
+        trigger: { type: "chord", keys: ["g", "g"] },
+        scope: "navigate",
+        label: "Jump to top",
+        shortLabel: "top",
+    },
+    {
+        action: KB.GO_BOTTOM,
+        trigger: { type: "key", char: "G" },
+        scope: "navigate",
+        label: "Jump to bottom",
+        shortLabel: "bottom",
+    },
+    {
+        action: KB.NAVIGATE_INTO,
+        trigger: { type: "special", name: "return" },
+        scope: "navigate",
+        label: "Navigate into / select",
+        shortLabel: "navigate",
+    },
+    {
+        action: KB.EDIT,
+        trigger: { type: "key", char: "e" },
+        scope: "navigate",
+        label: "Edit selected item",
+        shortLabel: "edit",
+    },
+    {
+        action: KB.DETAILS,
+        trigger: { type: "key", char: "d" },
+        scope: "navigate",
+        label: "Open details panel",
+        shortLabel: "details",
+    },
+    {
+        action: KB.YANK_MODE,
+        trigger: { type: "key", char: "y" },
+        scope: "navigate",
+        label: "Open yank mode",
+        shortLabel: "yank",
+    },
+    {
+        action: KB.SEARCH_MODE,
+        trigger: { type: "key", char: "/" },
+        scope: "navigate",
+        label: "Search mode",
+        shortLabel: "search",
+    },
+    {
+        action: KB.COMMAND_MODE,
+        trigger: { type: "key", char: ":" },
+        scope: "navigate",
+        label: "Command mode",
+        shortLabel: "command",
+    },
+    {
+        action: KB.REFRESH,
+        trigger: { type: "key", char: "r" },
+        scope: "navigate",
+        label: "Refresh",
+        shortLabel: "refresh",
+    },
+    {
+        action: KB.REVEAL_TOGGLE,
+        trigger: { type: "key", char: "v" },
+        scope: "navigate",
+        label: "Toggle reveal secrets",
+        shortLabel: "reveal",
+        priority: 90,
+        showIf: (ctx) => ctx.hasHiddenSecrets,
+    },
+    {
+        action: KB.QUIT,
+        trigger: { type: "key", char: "q" },
+        scope: "navigate",
+        label: "Quit",
+        shortLabel: "quit",
+    },
+    {
+        action: KB.HELP,
+        trigger: { type: "key", char: "?" },
+        scope: "navigate",
+        label: "Open help (navigate mode only)",
+        shortLabel: "help",
+    },
+    // --- Search (informational — text input handles actual typing) ---
+    {
+        action: KB.SEARCH_MODE,
+        trigger: { type: "key", char: "/" },
+        scope: "search",
+        label: "Open: press / in navigate mode",
+        shortLabel: "open search",
+    },
+    {
+        action: KB.NAVIGATE_INTO,
+        trigger: { type: "special", name: "return" },
+        scope: "search",
+        label: "Apply filter and return to navigate",
+        shortLabel: "apply filter",
+    },
+    {
+        action: KB.QUIT,
+        trigger: { type: "special", name: "escape" },
+        scope: "search",
+        label: "Cancel and restore previous filter",
+        shortLabel: "cancel search",
+    },
+    // --- Command (informational) ---
+    {
+        action: KB.COMMAND_MODE,
+        trigger: { type: "key", char: ":" },
+        scope: "command",
+        label: "Open: press : in navigate mode",
+        shortLabel: "open command",
+    },
+    {
+        action: KB.NAVIGATE_INTO,
+        trigger: { type: "special", name: "return" },
+        scope: "command",
+        label: "Run command",
+        shortLabel: "run",
+    },
+    {
+        action: KB.QUIT,
+        trigger: { type: "special", name: "escape" },
+        scope: "command",
+        label: "Cancel command mode",
+        shortLabel: "cancel",
+    },
+    // --- Yank (informational — actual options come from adapter.capabilities?.yank?.getYankOptions) ---
+    {
+        action: KB.YANK_MODE,
+        trigger: { type: "key", char: "y" },
+        scope: "yank",
+        label: "Open: press y in navigate mode",
+        shortLabel: "open yank",
+    },
+    {
+        action: KB.YANK_MODE,
+        trigger: { type: "key", char: "n" },
+        scope: "yank",
+        label: "Copy selected name",
+        shortLabel: "copy name",
+    },
+    {
+        action: KB.YANK_MODE,
+        trigger: { type: "key", char: "a" },
+        scope: "yank",
+        label: "Copy ARN (when available)",
+        shortLabel: "copy arn",
+    },
+    {
+        action: KB.QUIT,
+        trigger: { type: "special", name: "escape" },
+        scope: "yank",
+        label: "Cancel yank mode",
+        shortLabel: "cancel",
+    },
+    // --- Upload (informational) ---
+    {
+        action: KB.MOVE_DOWN,
+        trigger: j_down,
+        scope: "upload",
+        label: "Scroll diff down",
+        shortLabel: "scroll down",
+    },
+    {
+        action: KB.MOVE_UP,
+        trigger: k_up,
+        scope: "upload",
+        label: "Scroll diff up",
+        shortLabel: "scroll up",
+    },
+    {
+        action: KB.YANK_MODE,
+        trigger: { type: "key", char: "y" },
+        scope: "upload",
+        label: "Upload edited file",
+        shortLabel: "upload",
+    },
+    {
+        action: KB.QUIT,
+        trigger: {
+            type: "any",
+            of: [
+                { type: "key", char: "n" },
+                { type: "special", name: "escape" },
+            ],
+        },
+        scope: "upload",
+        label: "Cancel upload",
+        shortLabel: "cancel",
+    },
+    // --- Details ---
+    {
+        action: KB.DETAILS,
+        trigger: { type: "key", char: "d" },
+        scope: "details",
+        label: "Open: press d in navigate mode",
+        shortLabel: "open details",
+    },
+    {
+        action: KB.MOVE_DOWN,
+        trigger: j_down,
+        scope: "details",
+        label: "Scroll down",
+        shortLabel: "scroll down",
+    },
+    {
+        action: KB.MOVE_UP,
+        trigger: k_up,
+        scope: "details",
+        label: "Scroll up",
+        shortLabel: "scroll up",
+    },
+    {
+        action: KB.QUIT,
+        trigger: { type: "special", name: "escape" },
+        scope: "details",
+        label: "Close details panel",
+        shortLabel: "close",
+    },
+    // --- Picker ---
+    {
+        action: KB.PICKER_DOWN,
+        trigger: j_down,
+        scope: "picker",
+        label: "Move down",
+        shortLabel: "down",
+    },
+    { action: KB.PICKER_UP, trigger: k_up, scope: "picker", label: "Move up", shortLabel: "up" },
+    {
+        action: KB.PICKER_TOP,
+        trigger: { type: "chord", keys: ["g", "g"] },
+        scope: "picker",
+        label: "Jump to top",
+        shortLabel: "top",
+    },
+    {
+        action: KB.PICKER_BOTTOM,
+        trigger: { type: "key", char: "G" },
+        scope: "picker",
+        label: "Jump to bottom",
+        shortLabel: "bottom",
+    },
+    {
+        action: KB.PICKER_FILTER,
+        trigger: { type: "key", char: "/" },
+        scope: "picker",
+        label: "Filter",
+        shortLabel: "filter",
+    },
+    {
+        action: KB.PICKER_CONFIRM,
+        trigger: { type: "special", name: "return" },
+        scope: "picker",
+        label: "Confirm selection",
+        shortLabel: "confirm",
+    },
+    {
+        action: KB.PICKER_CLOSE,
+        trigger: { type: "special", name: "escape" },
+        scope: "picker",
+        label: "Close",
+        shortLabel: "close",
+    },
+    // --- Help panel ---
+    {
+        action: KB.HELP_PREV_TAB,
+        trigger: {
+            type: "any",
+            of: [
+                { type: "key", char: "h" },
+                { type: "special", name: "leftArrow" },
+            ],
+        },
+        scope: "help",
+        label: "Previous tab",
+        shortLabel: "prev",
+    },
+    {
+        action: KB.HELP_NEXT_TAB,
+        trigger: {
+            type: "any",
+            of: [
+                { type: "key", char: "l" },
+                { type: "special", name: "rightArrow" },
+            ],
+        },
+        scope: "help",
+        label: "Next tab",
+        shortLabel: "next",
+    },
+    {
+        action: KB.HELP_SCROLL_UP,
+        trigger: k_up,
+        scope: "help",
+        label: "Scroll up",
+        shortLabel: "scroll up",
+    },
+    {
+        action: KB.HELP_SCROLL_DOWN,
+        trigger: j_down,
+        scope: "help",
+        label: "Scroll down",
+        shortLabel: "scroll down",
+    },
+    {
+        action: KB.HELP_CLOSE,
+        trigger: {
+            type: "any",
+            of: [
+                { type: "key", char: "?" },
+                { type: "special", name: "escape" },
+            ],
+        },
+        scope: "help",
+        label: "Close help",
+        shortLabel: "close",
+    },
+];
+// ---------------------------------------------------------------------------
+// Help panel derivation
+// ---------------------------------------------------------------------------
+const SCOPE_ORDER = [
+    "navigate",
+    "search",
+    "command",
+    "yank",
+    "details",
+    "upload",
+    "picker",
+    "help",
+];
+/**
+ * Build HelpPanel tabs from KEYBINDINGS and adapter-specific bindings.
+ * Display key is automatically derived from each binding's trigger.
+ */
+export function buildHelpTabs(adapterId, adapterBindings) {
+    const groups = new Map();
+    for (const kb of KEYBINDINGS) {
+        if (!groups.has(kb.scope))
+            groups.set(kb.scope, []);
+        groups.get(kb.scope).push({
+            key: triggerToString(kb.trigger),
+            description: kb.label,
+        });
+    }
+    // Add adapter-specific bindings
+    if (adapterBindings) {
+        for (const ab of adapterBindings) {
+            const scope = ab.scope || "navigate";
+            if (!groups.has(scope))
+                groups.set(scope, []);
+            groups.get(scope).push({
+                key: triggerToString(ab.trigger),
+                description: ab.label,
+            });
+        }
+    }
+    // De-duplicate entries with identical key+description within the same scope
+    // (e.g. search/command/yank open entries share action with navigate entries)
+    for (const [scope, items] of groups) {
+        const seen = new Set();
+        groups.set(scope, items.filter((item) => {
+            const key = `${item.key}|${item.description}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        }));
+    }
+    return SCOPE_ORDER.filter((s) => groups.has(s)).map((s) => ({
+        title: SCOPE_LABELS[s],
+        items: groups.get(s),
+    }));
+}
+/** Derive the navigate mode hint string from KEYBINDINGS */
+export function buildNavigateHint() {
+    const navigateKeys = KEYBINDINGS.filter((kb) => kb.scope === "navigate");
+    return (" " +
+        navigateKeys
+            .slice(0, 6)
+            .map((kb) => `${triggerToString(kb.trigger)} ${kb.shortLabel}`)
+            .join("  •  "));
+}
+/** Generic bottom-hint builder for a given scope, derived from KEYBINDINGS and adapter bindings. */
+export function buildScopeHint(scope, adapterBindings, maxItems = 8, context = { hasHiddenSecrets: false }) {
+    const filtered = KEYBINDINGS.filter((kb) => kb.scope === scope);
+    const seen = new Set();
+    const compact = filtered.filter((kb) => {
+        const key = `${kb.action}|${triggerToString(kb.trigger)}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+    // Process adapter-specific bindings with filtering and priority support
+    const adapterBindingsByKey = new Map();
+    if (adapterBindings) {
+        for (const ab of adapterBindings) {
+            if ((ab.scope || "navigate") === scope) {
+                const key = `${ab.actionId}|${triggerToString(ab.trigger)}`;
+                if (!seen.has(key)) {
+                    const passesFilter = !ab.showIf || ab.showIf(context);
+                    if (passesFilter) {
+                        seen.add(key);
+                        const shortLabel = ab.shortLabel || ab.label;
+                        const item = {
+                            trigger: ab.trigger,
+                            shortLabel: `${ab.adapterId}: ${shortLabel}`,
+                        };
+                        if (ab.priority !== undefined) {
+                            item.priority = ab.priority;
+                        }
+                        adapterBindingsByKey.set(key, item);
+                    }
+                }
+            }
+        }
+    }
+    let ordered;
+    if (scope === "navigate") {
+        // Filter core bindings
+        const filteredCore = compact.filter((kb) => !kb.showIf || kb.showIf(context));
+        const allItems = [
+            ...filteredCore.map((kb) => ({
+                trigger: kb.trigger,
+                shortLabel: kb.shortLabel,
+                priority: kb.priority ?? 100,
+            })),
+            ...Array.from(adapterBindingsByKey.values()).map((item) => ({
+                trigger: item.trigger,
+                shortLabel: item.shortLabel,
+                priority: item.priority ?? 100,
+            })),
+        ];
+        // Sort by priority (lower number = higher prominence) and drop the priority field
+        ordered = allItems
+            .sort((a, b) => a.priority - b.priority)
+            .map(({ priority: _priority, ...item }) => item);
+    }
+    else {
+        // For non-navigate scopes, filter but maintain source order (core first, then adapters)
+        const filteredCore = compact
+            .filter((kb) => !kb.showIf || kb.showIf(context))
+            .map((kb) => ({
+            trigger: kb.trigger,
+            shortLabel: kb.shortLabel,
+        }));
+        ordered = [
+            ...filteredCore,
+            ...Array.from(adapterBindingsByKey.values()).map((item) => ({
+                trigger: item.trigger,
+                shortLabel: item.shortLabel,
+            })),
+        ];
+    }
+    const parts = ordered.slice(0, maxItems).map((item) => {
+        return `${triggerToString(item.trigger)} · ${item.shortLabel}`;
+    });
+    return parts.length > 0 ? ` ${parts.join(" • ")}` : "";
+}

package/dist/src/constants/keys.js

@@ -0,0 +1,37 @@
+/**
+ * Closed action-enum: every user-triggerable action has a named constant here.
+ * Reference KB.XXX everywhere — never use raw strings like "move_down".
+ */
+export const KB = {
+    // Navigation
+    MOVE_DOWN: "move_down",
+    MOVE_UP: "move_up",
+    GO_TOP: "go_top", // chord: g g
+    GO_BOTTOM: "go_bottom", // G
+    NAVIGATE_INTO: "navigate_into", // Enter
+    EDIT: "edit", // e
+    DETAILS: "details", // d
+    FETCH: "fetch", // f  (S3 only)
+    YANK_MODE: "yank_mode", // y
+    SEARCH_MODE: "search_mode", // /
+    COMMAND_MODE: "command_mode", // :
+    REFRESH: "refresh", // r
+    REVEAL_TOGGLE: "reveal_toggle", // v (secrets/fields only)
+    QUIT: "quit", // q
+    HELP: "help", // ?
+    JUMP_TO_PATH: "jump_to_path", // chord: g p  (S3 only)
+    // Picker
+    PICKER_UP: "picker_up",
+    PICKER_DOWN: "picker_down",
+    PICKER_FILTER: "picker_filter",
+    PICKER_CONFIRM: "picker_confirm",
+    PICKER_CLOSE: "picker_close",
+    PICKER_TOP: "picker_top", // chord: g g
+    PICKER_BOTTOM: "picker_bottom", // G
+    // Help panel
+    HELP_PREV_TAB: "help_prev_tab",
+    HELP_NEXT_TAB: "help_next_tab",
+    HELP_SCROLL_UP: "help_scroll_up",
+    HELP_SCROLL_DOWN: "help_scroll_down",
+    HELP_CLOSE: "help_close",
+};

package/dist/src/features/AppMainView.integration.test.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { render } from "ink-testing-library";
+import { AppMainView } from "./AppMainView.js";
+import { textCell } from "../types.js";
+function createPickerManager(active) {
+    const noop = () => { };
+    const mkEntry = (id) => ({
+        id,
+        columns: [{ key: id, label: id }],
+        contextLabel: id,
+        open: false,
+        filter: "",
+        searchEntry: null,
+        pickerMode: "navigate",
+        setFilter: noop,
+        openPicker: noop,
+        closePicker: noop,
+        startSearch: noop,
+        cancelSearch: noop,
+        confirmSearch: noop,
+        filteredRows: [],
+        selectedRow: null,
+        selectedIndex: 0,
+        scrollOffset: 0,
+        moveUp: noop,
+        moveDown: noop,
+        reset: noop,
+        toTop: noop,
+        toBottom: noop,
+    });
+    return {
+        region: mkEntry("region"),
+        profile: mkEntry("profile"),
+        resource: mkEntry("resource"),
+        activePicker: active,
+        openPicker: (_id) => { },
+        closeActivePicker: noop,
+        resetPicker: (_id) => { },
+        confirmActivePickerSelection: (_handlers) => { },
+    };
+}
+const baseProps = {
+    helpPanel: {
+        helpOpen: false,
+        helpTabIndex: 0,
+        helpScrollOffset: 0,
+        helpVisibleRows: 10,
+        open: () => { },
+        openAtTab: () => { },
+        close: () => { },
+        scrollUp: () => { },
+        scrollDown: () => { },
+        goToPrevTab: () => { },
+        goToNextTab: () => { },
+        goToTab: () => true,
+    },
+    helpTabs: [{ title: "General", items: [{ key: "q", description: "quit" }] }],
+    pickers: createPickerManager(null),
+    error: null,
+    describeState: null,
+    isLoading: false,
+    filteredRows: [{ id: "r1", cells: { name: textCell("row1") } }],
+    columns: [{ key: "name", label: "Name" }],
+    selectedIndex: 0,
+    scrollOffset: 0,
+    filterText: "",
+    adapter: {
+        id: "s3",
+        label: "S3",
+        hudColor: { bg: "blue", fg: "white" },
+        getColumns: () => [{ key: "name", label: "Name" }],
+        getRows: async () => [],
+        onSelect: async () => ({ action: "none" }),
+        canGoBack: () => false,
+        goBack: () => { },
+        getPath: () => "s3://",
+        getContextLabel: () => "Buckets",
+    },
+    termCols: 120,
+    tableHeight: 20,
+    yankHelpOpen: false,
+    yankOptions: [],
+    yankHelpRow: null,
+    panelScrollOffset: 0,
+};
+describe("AppMainView integration", () => {
+    it("prioritizes help panel when open", () => {
+        const { lastFrame } = render(_jsx(AppMainView, { ...baseProps, helpPanel: { ...baseProps.helpPanel, helpOpen: true } }));
+        expect(lastFrame()).toContain("Keyboard Help");
+    });
+    it("renders picker table when picker is active", () => {
+        const activePicker = {
+            ...createPickerManager(null).resource,
+            open: true,
+            contextLabel: "Select AWS Resource",
+            filteredRows: [
+                { id: "s3", cells: { resource: textCell("s3"), description: textCell("S3") } },
+            ],
+            columns: [
+                { key: "resource", label: "Resource" },
+                { key: "description", label: "Description" },
+            ],
+        };
+        const { lastFrame } = render(_jsx(AppMainView, { ...baseProps, pickers: createPickerManager(activePicker) }));
+        expect(lastFrame()).toContain("Select AWS Resource");
+    });
+    it("renders details panel when details are present", () => {
+        const { lastFrame } = render(_jsx(AppMainView, { ...baseProps, describeState: {
+                row: { id: "obj-1", cells: { name: textCell("object-1") } },
+                fields: [{ label: "Name", value: "object-1" }],
+                loading: false,
+            } }));
+        expect(lastFrame()).toContain("object-1");
+    });
+    it("renders yank header markers when provided", () => {
+        const { lastFrame } = render(_jsx(AppMainView, { ...baseProps, headerMarkers: { name: ["n", "k"] } }));
+        expect(lastFrame()).toContain("[n,k]");
+    });
+    it("renders lightweight yank help panel", () => {
+        const { lastFrame } = render(_jsx(AppMainView, { ...baseProps, yankHelpOpen: true, yankOptions: [
+                {
+                    trigger: { type: "key", char: "n" },
+                    label: "copy name",
+                    feedback: "Copied",
+                    isRelevant: () => true,
+                    resolve: async () => "x",
+                },
+            ], yankHelpRow: { id: "row", cells: { name: textCell("item") } } }));
+        expect(lastFrame()).toContain("Yank Options");
+        expect(lastFrame()).toContain("copy name");
+    });
+});