@a9s/cli 0.0.1 → 0.1.0

package/dist/src/hooks/useKeyChord.js

@@ -0,0 +1,83 @@
+import { useState, useCallback } from "react";
+// ---------------------------------------------------------------------------
+// Pure helper: does (input, inkKey) match a single trigger?
+// ---------------------------------------------------------------------------
+function matchSpecial(inkKey, name) {
+    switch (name) {
+        case "return":
+            return inkKey.return;
+        case "escape":
+            return inkKey.escape;
+        case "tab":
+            return inkKey.tab;
+        case "upArrow":
+            return inkKey.upArrow;
+        case "downArrow":
+            return inkKey.downArrow;
+        case "leftArrow":
+            return inkKey.leftArrow;
+        case "rightArrow":
+            return inkKey.rightArrow;
+    }
+}
+export function matchesTrigger(input, inkKey, trigger) {
+    switch (trigger.type) {
+        case "key":
+            return input === trigger.char;
+        case "special":
+            return matchSpecial(inkKey, trigger.name);
+        case "chord":
+            return false; // chords are resolved separately
+        case "any":
+            return trigger.of.some((t) => matchesTrigger(input, inkKey, t));
+    }
+}
+// ---------------------------------------------------------------------------
+// Hook
+// ---------------------------------------------------------------------------
+/**
+ * Chord-aware key resolver.
+ *
+ * Usage:
+ *   const { resolve } = useKeyChord(KEYBINDINGS);
+ *   // inside useInput:
+ *   const action = resolve(input, key, "navigate");
+ *   if (action === KB.MOVE_DOWN) moveDown();
+ *
+ * Resolution order:
+ *   1. [...pending, input] completes a chord → fire action, clear pending
+ *   2. [...pending, input] is a valid chord prefix → accumulate pending, return null
+ *   3. Single-key / special-key match → fire action, clear pending
+ *   4. No match → clear pending, return null
+ */
+export function useKeyChord(bindings) {
+    const [pending, setPending] = useState([]);
+    const resolve = useCallback((input, inkKey, scope) => {
+        const scoped = bindings.filter((kb) => kb.scope === scope);
+        const next = pending.length > 0 ? [...pending, input] : [input];
+        // 1. Complete chord match
+        const chordHit = scoped.find((kb) => kb.trigger.type === "chord" &&
+            kb.trigger.keys.length === next.length &&
+            kb.trigger.keys.every((k, i) => k === next[i]));
+        if (chordHit) {
+            setPending([]);
+            return chordHit.action;
+        }
+        // 2. Chord prefix — accumulate and wait for next key
+        const isPrefix = scoped.some((kb) => kb.trigger.type === "chord" &&
+            kb.trigger.keys.length > next.length &&
+            kb.trigger.keys.slice(0, next.length).every((k, i) => k === next[i]));
+        if (isPrefix) {
+            setPending(next);
+            return null;
+        }
+        // 3. Single / special / any — only check when no chord is pending
+        // (if something is pending but didn't extend any chord, fall through and
+        //  reset; the current key is then checked as a fresh single-key press)
+        setPending([]);
+        const hit = scoped.find((kb) => matchesTrigger(input, inkKey, kb.trigger));
+        return hit?.action ?? null;
+    }, [pending, bindings]);
+    const reset = useCallback(() => setPending([]), []);
+    return { pending, resolve, reset };
+}

package/dist/src/hooks/useMainInput.js

@@ -0,0 +1,18 @@
+import { useEffect } from "react";
+import { useInput } from "ink";
+export function useMainInput(dispatch) {
+    useEffect(() => {
+        const handle = (data) => {
+            if (data.toString() === "\x03") {
+                dispatch({ scope: "system", type: "ctrl-c" });
+            }
+        };
+        process.stdin.on("data", handle);
+        return () => {
+            process.stdin.off("data", handle);
+        };
+    }, [dispatch]);
+    useInput((input, key) => {
+        dispatch({ scope: "raw", type: "key", input, key });
+    }, { isActive: true });
+}

package/dist/src/hooks/useNavigation.js

@@ -0,0 +1,47 @@
+import { useState, useCallback } from "react";
+export function useNavigation(rowCount, maxVisible) {
+    const [state, setState] = useState({ selectedIndex: 0, scrollOffset: 0 });
+    const moveUp = useCallback(() => {
+        setState((prev) => {
+            const next = Math.max(0, prev.selectedIndex - 1);
+            const off = next < prev.scrollOffset ? next : prev.scrollOffset;
+            return { selectedIndex: next, scrollOffset: off };
+        });
+    }, []);
+    const moveDown = useCallback(() => {
+        setState((prev) => {
+            const next = Math.min(Math.max(0, rowCount - 1), prev.selectedIndex + 1);
+            const off = next >= prev.scrollOffset + maxVisible ? next - maxVisible + 1 : prev.scrollOffset;
+            return { selectedIndex: next, scrollOffset: off };
+        });
+    }, [rowCount, maxVisible]);
+    const reset = useCallback(() => {
+        setState({ selectedIndex: 0, scrollOffset: 0 });
+    }, []);
+    const setIndex = useCallback((index) => {
+        setState(() => {
+            const next = Math.max(0, Math.min(Math.max(0, rowCount - 1), index));
+            const off = Math.max(0, next - Math.max(0, maxVisible - 1));
+            return { selectedIndex: next, scrollOffset: off };
+        });
+    }, [rowCount, maxVisible]);
+    const toTop = useCallback(() => {
+        setState({ selectedIndex: 0, scrollOffset: 0 });
+    }, []);
+    const toBottom = useCallback(() => {
+        const lastIndex = Math.max(0, rowCount - 1);
+        const bottomOffset = Math.max(0, rowCount - maxVisible);
+        setState({ selectedIndex: lastIndex, scrollOffset: bottomOffset });
+    }, [rowCount, maxVisible]);
+    const clampedIndex = Math.min(state.selectedIndex, Math.max(0, rowCount - 1));
+    return {
+        selectedIndex: clampedIndex,
+        scrollOffset: state.scrollOffset,
+        moveUp,
+        moveDown,
+        reset,
+        setIndex,
+        toTop,
+        toBottom,
+    };
+}

package/dist/src/hooks/usePendingAction.js

@@ -0,0 +1,8 @@
+import { useState } from "react";
+export function usePendingAction() {
+    const [pendingAction, setPendingAction] = useState(null);
+    return {
+        pendingAction,
+        setPendingAction,
+    };
+}

package/dist/src/hooks/usePickerManager.js

@@ -0,0 +1,130 @@
+import { useMemo } from "react";
+import { textCell } from "../types.js";
+import { usePickerState } from "./usePickerState.js";
+import { usePickerTable } from "./usePickerTable.js";
+import { SERVICE_REGISTRY } from "../services.js";
+export function usePickerManager({ tableHeight, availableRegions, availableProfiles, }) {
+    const region = usePickerState();
+    const profile = usePickerState();
+    const resource = usePickerState();
+    const regionRows = useMemo(() => availableRegions.map((r) => ({
+        id: r.name,
+        cells: { region: textCell(r.name), description: textCell(r.description) },
+        meta: {},
+    })), [availableRegions]);
+    const profileRows = useMemo(() => availableProfiles.map((p) => ({
+        id: p.name,
+        cells: { profile: textCell(p.name), description: textCell(p.description) },
+        meta: {},
+    })), [availableProfiles]);
+    const resourceRows = useMemo(() => Object.keys(SERVICE_REGISTRY).map((serviceId) => ({
+        id: serviceId,
+        cells: {
+            resource: textCell(serviceId),
+            description: textCell(`${serviceId.toUpperCase()} service`),
+        },
+        meta: {},
+    })), []);
+    const regionTable = usePickerTable({
+        rows: regionRows,
+        filterText: region.filter,
+        maxHeight: tableHeight,
+    });
+    const profileTable = usePickerTable({
+        rows: profileRows,
+        filterText: profile.filter,
+        maxHeight: tableHeight,
+    });
+    const resourceTable = usePickerTable({
+        rows: resourceRows,
+        filterText: resource.filter,
+        maxHeight: tableHeight,
+    });
+    const regionColumns = [
+        { key: "region", label: "Region" },
+        { key: "description", label: "Description" },
+    ];
+    const profileColumns = [
+        { key: "profile", label: "Profile" },
+        { key: "description", label: "Description" },
+    ];
+    const resourceColumns = [
+        { key: "resource", label: "Resource" },
+        { key: "description", label: "Description" },
+    ];
+    const regionEntry = {
+        id: "region",
+        columns: regionColumns,
+        contextLabel: "Select AWS Region",
+        ...region,
+        ...regionTable,
+    };
+    const profileEntry = {
+        id: "profile",
+        columns: profileColumns,
+        contextLabel: "Select AWS Profile",
+        ...profile,
+        ...profileTable,
+    };
+    const resourceEntry = {
+        id: "resource",
+        columns: resourceColumns,
+        contextLabel: "Select AWS Resource",
+        ...resource,
+        ...resourceTable,
+    };
+    const activePicker = regionEntry.open
+        ? regionEntry
+        : profileEntry.open
+            ? profileEntry
+            : resourceEntry.open
+                ? resourceEntry
+                : null;
+    const getEntry = (id) => {
+        switch (id) {
+            case "region":
+                return regionEntry;
+            case "profile":
+                return profileEntry;
+            case "resource":
+                return resourceEntry;
+        }
+    };
+    const openPicker = (id) => {
+        const entry = getEntry(id);
+        entry.openPicker();
+        entry.reset();
+    };
+    const closeActivePicker = () => {
+        activePicker?.closePicker();
+    };
+    const resetPicker = (id) => {
+        getEntry(id).reset();
+    };
+    const confirmActivePickerSelection = (handlers) => {
+        if (!activePicker?.selectedRow)
+            return;
+        switch (activePicker.id) {
+            case "resource":
+                handlers.onSelectResource(activePicker.selectedRow.id);
+                break;
+            case "region":
+                handlers.onSelectRegion(activePicker.selectedRow.id);
+                break;
+            case "profile":
+                handlers.onSelectProfile(activePicker.selectedRow.id);
+                break;
+        }
+        activePicker.closePicker();
+    };
+    return {
+        region: regionEntry,
+        profile: profileEntry,
+        resource: resourceEntry,
+        activePicker,
+        openPicker,
+        closeActivePicker,
+        resetPicker,
+        confirmActivePickerSelection,
+    };
+}

package/dist/src/hooks/usePickerState.js

@@ -0,0 +1,47 @@
+import { useState, useCallback } from "react";
+export function usePickerState() {
+    const [open, setOpen] = useState(false);
+    const [filter, setFilter] = useState("");
+    const [searchEntry, setSearchEntry] = useState(null);
+    const [pickerMode, setPickerMode] = useState("navigate");
+    const openPicker = useCallback(() => {
+        setOpen(true);
+        setFilter("");
+        setSearchEntry(null);
+        setPickerMode("navigate");
+    }, []);
+    const closePicker = useCallback(() => {
+        setOpen(false);
+        setFilter("");
+        setSearchEntry(null);
+        setPickerMode("navigate");
+    }, []);
+    const startSearch = useCallback(() => {
+        setSearchEntry((prev) => prev ?? filter);
+        setPickerMode("search");
+    }, [filter]);
+    const cancelSearch = useCallback(() => {
+        setFilter((current) => {
+            const restored = searchEntry !== null && current !== "" ? searchEntry : current;
+            setSearchEntry(null);
+            setPickerMode("navigate");
+            return restored;
+        });
+    }, [searchEntry]);
+    const confirmSearch = useCallback(() => {
+        setSearchEntry(null);
+        setPickerMode("navigate");
+    }, []);
+    return {
+        open,
+        filter,
+        searchEntry,
+        pickerMode,
+        setFilter,
+        openPicker,
+        closePicker,
+        startSearch,
+        cancelSearch,
+        confirmSearch,
+    };
+}

package/dist/src/hooks/usePickerTable.js

@@ -0,0 +1,20 @@
+import { useMemo } from "react";
+import { useNavigation } from "./useNavigation.js";
+export function usePickerTable({ rows, filterText, maxHeight }) {
+    const filteredRows = useMemo(() => {
+        if (!filterText)
+            return rows;
+        const lower = filterText.toLowerCase();
+        return rows.filter((row) => Object.values(row.cells).some((cell) => {
+            const value = typeof cell === "string" ? cell : cell.displayName;
+            return value.toLowerCase().includes(lower);
+        }));
+    }, [filterText, rows]);
+    const nav = useNavigation(filteredRows.length, maxHeight);
+    const selectedRow = filteredRows[nav.selectedIndex] ?? null;
+    return {
+        filteredRows,
+        selectedRow,
+        ...nav,
+    };
+}

package/dist/src/hooks/useServiceView.js

@@ -0,0 +1,226 @@
+import { useCallback, useEffect, useLayoutEffect, useReducer } from "react";
+import { useAtomValue } from "jotai";
+import open from "open";
+import { extname } from "path";
+import { execSync } from "child_process";
+import { stat } from "fs/promises";
+import { debugLog } from "../utils/debugLogger.js";
+import { adapterSessionAtom } from "../state/atoms.js";
+const TEXT_EXTENSIONS = new Set([
+    ".txt",
+    ".json",
+    ".yaml",
+    ".yml",
+    ".xml",
+    ".html",
+    ".htm",
+    ".css",
+    ".js",
+    ".ts",
+    ".tsx",
+    ".jsx",
+    ".py",
+    ".rb",
+    ".go",
+    ".java",
+    ".c",
+    ".cpp",
+    ".h",
+    ".sh",
+    ".bash",
+    ".zsh",
+    ".fish",
+    ".md",
+    ".markdown",
+    ".rst",
+    ".sql",
+    ".sql",
+    ".toml",
+    ".ini",
+    ".env",
+    ".log",
+    ".csv",
+    ".tsv",
+    ".properties",
+    ".gradle",
+    ".maven",
+    ".dockerfile",
+    ".gitignore",
+    ".npmrc",
+    ".editorconfig",
+]);
+function isTextFile(filePath) {
+    const ext = extname(filePath).toLowerCase();
+    return TEXT_EXTENSIONS.has(ext) || !ext;
+}
+async function openFile(filePath) {
+    try {
+        if (isTextFile(filePath)) {
+            const editor = process.env["EDITOR"] || "vim";
+            // execSync blocks and lets editor take full control of terminal
+            // Ink will automatically suspend and resume when this completes
+            execSync(`${editor} "${filePath}"`, { stdio: "inherit" });
+        }
+        else {
+            await open(filePath);
+        }
+    }
+    catch (err) {
+        console.error("Failed to open file:", err.message);
+    }
+}
+function dataReducer(state, action) {
+    switch (action.type) {
+        case "ADAPTER_CHANGED":
+            return {
+                adapterId: action.adapterId,
+                rows: [],
+                columns: [],
+                loadingCount: 0,
+                error: null,
+            };
+        case "BEGIN_LOADING":
+            return { ...state, loadingCount: state.loadingCount + 1 };
+        case "END_LOADING":
+            return { ...state, loadingCount: Math.max(0, state.loadingCount - 1) };
+        case "SET_DATA":
+            return { ...state, rows: action.rows, columns: action.columns };
+        case "SET_ERROR":
+            return { ...state, error: action.error };
+    }
+}
+export function useServiceView(adapter, navKey) {
+    const adapterId = adapter.id;
+    const adapterSession = useAtomValue(adapterSessionAtom);
+    const [state, dispatch] = useReducer(dataReducer, {
+        adapterId,
+        rows: [],
+        columns: [],
+        loadingCount: 0,
+        error: null,
+    });
+    // Clear data atomically when adapter session changes (before paint)
+    useLayoutEffect(() => {
+        if (state.adapterId !== adapterId) {
+            debugLog(adapterId, "useLayoutEffect: adapter changed, clearing data");
+            dispatch({ type: "ADAPTER_CHANGED", adapterId });
+            // Reset adapter-specific state
+            adapter.reset?.();
+        }
+    }, [adapterSession, adapterId, state.adapterId]);
+    const beginLoading = useCallback(() => {
+        debugLog(adapterId, "beginLoading");
+        dispatch({ type: "BEGIN_LOADING" });
+    }, [adapterId]);
+    const endLoading = useCallback(() => {
+        debugLog(adapterId, "endLoading");
+        dispatch({ type: "END_LOADING" });
+    }, [adapterId]);
+    const runWithLoading = useCallback(async (fn, clearError = false) => {
+        beginLoading();
+        if (clearError)
+            dispatch({ type: "SET_ERROR", error: null });
+        try {
+            return await fn();
+        }
+        finally {
+            endLoading();
+        }
+    }, [beginLoading, endLoading]);
+    const refresh = useCallback(async () => {
+        debugLog(adapterId, "refresh() called");
+        return runWithLoading(async () => {
+            debugLog(adapterId, "fetching rows...");
+            const columns = adapter.getColumns();
+            dispatch({ type: "SET_ERROR", error: null });
+            try {
+                const r = await adapter.getRows();
+                debugLog(adapterId, `got ${r.length} rows from adapter`);
+                dispatch({ type: "SET_DATA", rows: r, columns });
+            }
+            catch (e) {
+                debugLog(adapterId, "fetch error", e.message);
+                dispatch({ type: "SET_ERROR", error: e.message });
+            }
+        }, true);
+    }, [adapter, runWithLoading, adapterId]);
+    useEffect(() => {
+        debugLog(adapterId, "useEffect: adapter changed, fetching data");
+        void (async () => {
+            dispatch({ type: "BEGIN_LOADING" });
+            dispatch({ type: "SET_ERROR", error: null });
+            debugLog(adapterId, "fetching rows...");
+            const columns = adapter.getColumns();
+            try {
+                const r = await adapter.getRows();
+                debugLog(adapterId, `got ${r.length} rows from adapter`);
+                dispatch({ type: "SET_DATA", rows: r, columns });
+            }
+            catch (e) {
+                debugLog(adapterId, "fetch error", e.message);
+                dispatch({ type: "SET_ERROR", error: e.message });
+            }
+            finally {
+                dispatch({ type: "END_LOADING" });
+            }
+        })();
+    }, [adapter, navKey, adapterId]);
+    const processResult = useCallback(async (result) => {
+        if (result.action === "navigate")
+            await refresh();
+        if (result.action === "edit") {
+            // Get file modification time before opening
+            const before = await stat(result.filePath).catch(() => null);
+            const beforeMtime = before?.mtimeMs;
+            // Open file in editor
+            await openFile(result.filePath);
+            // Check if file was modified
+            const after = await stat(result.filePath).catch(() => null);
+            const afterMtime = after?.mtimeMs;
+            if (beforeMtime &&
+                afterMtime &&
+                beforeMtime !== afterMtime &&
+                adapter.capabilities?.edit &&
+                result.metadata) {
+                return { ...result, needsUpload: true };
+            }
+        }
+        return result;
+    }, [adapter, refresh]);
+    const select = useCallback(async (row) => {
+        debugLog(adapterId, "select() called for row", row.id);
+        return runWithLoading(async () => {
+            const result = await adapter.onSelect(row);
+            return processResult(result);
+        });
+    }, [adapter, processResult, runWithLoading, adapterId]);
+    const edit = useCallback(async (row) => {
+        return runWithLoading(async () => {
+            const result = adapter.capabilities?.edit
+                ? await adapter.capabilities.edit.onEdit(row)
+                : await adapter.onSelect(row);
+            return processResult(result);
+        });
+    }, [adapter, processResult, runWithLoading]);
+    const goBack = useCallback(async () => {
+        if (!adapter.canGoBack())
+            return;
+        await runWithLoading(async () => {
+            adapter.goBack();
+            await refresh();
+        });
+    }, [adapter, refresh, runWithLoading]);
+    // Derive effective values: detect if reducer state is stale (adapter changed but ADAPTER_CHANGED not yet processed)
+    const isTransitioning = state.adapterId !== adapterId;
+    return {
+        rows: isTransitioning ? [] : state.rows,
+        columns: isTransitioning ? [] : state.columns,
+        isLoading: isTransitioning || state.loadingCount > 0,
+        error: isTransitioning ? null : state.error,
+        select,
+        edit,
+        goBack,
+        refresh,
+        path: adapter.getPath(),
+    };
+}

package/dist/src/hooks/useUiHints.js

@@ -0,0 +1,60 @@
+import { useMemo } from "react";
+import { COMMAND_MODE_HINT } from "../constants/commands.js";
+import { buildScopeHint } from "../constants/keybindings.js";
+export function useUiHints({ mode, helpOpen, pickers, pendingAction, uploadPending, describeState, yankMode, adapterBindings, yankHint, context, }) {
+    const uiScope = useMemo(() => {
+        if (helpOpen)
+            return "help";
+        if (pickers.activePicker)
+            return "picker";
+        if (pendingAction)
+            return "adapter-action";
+        if (uploadPending)
+            return "upload";
+        if (describeState)
+            return "details";
+        if (yankMode)
+            return "yank";
+        if (mode === "search")
+            return "search";
+        if (mode === "command")
+            return "command";
+        return "navigate";
+    }, [describeState, helpOpen, mode, pendingAction, pickers.activePicker, uploadPending, yankMode]);
+    const bottomHint = useMemo(() => {
+        switch (uiScope) {
+            case "help":
+                return buildScopeHint("help", adapterBindings, 8, context);
+            case "picker":
+                return pickers.activePicker?.pickerMode === "search"
+                    ? buildScopeHint("search", adapterBindings, 8, context)
+                    : buildScopeHint("picker", adapterBindings, 8, context);
+            case "adapter-action":
+                if (pendingAction?.effect.type === "prompt") {
+                    return " Enter value  •  Esc cancel";
+                }
+                if (pendingAction?.effect.type === "confirm") {
+                    return " y confirm  •  n/Esc cancel";
+                }
+                return "";
+            case "upload":
+                return buildScopeHint("upload", adapterBindings, 8, context);
+            case "details":
+                return buildScopeHint("details", adapterBindings, 8, context);
+            case "yank":
+                return ` ${yankHint}`;
+            case "search":
+                return buildScopeHint("search", adapterBindings, 8, context);
+            case "command":
+                return COMMAND_MODE_HINT;
+            case "navigate":
+                return buildScopeHint("navigate", adapterBindings, 8, context);
+            default:
+                return "";
+        }
+    }, [adapterBindings, context, pendingAction, pickers.activePicker, uiScope, yankHint]);
+    return {
+        uiScope,
+        bottomHint,
+    };
+}

package/dist/src/hooks/useYankMode.js

@@ -0,0 +1,24 @@
+import { useState, useCallback, useEffect } from "react";
+export function useYankMode() {
+    const [yankMode, setYankMode] = useState(false);
+    const [yankFeedback, setYankFeedback] = useState(null);
+    useEffect(() => {
+        return () => {
+            if (yankFeedback?.timer)
+                clearTimeout(yankFeedback.timer);
+        };
+    }, [yankFeedback]);
+    const pushYankFeedback = useCallback((message, durationMs = 1500) => {
+        const timer = setTimeout(() => setYankFeedback(null), durationMs);
+        setYankFeedback({ message, timer });
+    }, []);
+    const clearYankFeedback = useCallback(() => setYankFeedback(null), []);
+    return {
+        yankMode,
+        setYankMode,
+        yankFeedback,
+        setYankFeedback,
+        pushYankFeedback,
+        clearYankFeedback,
+    };
+}