@aria-cli/cli 1.0.50 → 1.0.51

package/dist/ui/hooks/index.js

@@ -0,0 +1,6 @@
+// packages/cli/src/ui/hooks/index.ts
+export { useKeyboardShortcuts } from "./useKeyboardShortcuts.js";
+export { useDoublePress } from "./useDoublePress.js";
+export { useCommandAutocomplete, } from "./useCommandAutocomplete.js";
+export { useTerminalSize } from "./useTerminalSize.js";
+//# sourceMappingURL=index.js.map

package/dist/ui/hooks/useCommandAutocomplete.js

@@ -0,0 +1,93 @@
+// packages/cli/src/ui/hooks/useCommandAutocomplete.ts
+import { useState, useMemo, useCallback, useEffect } from "react";
+import { useInput } from "ink";
+import { fuzzySort } from "../utils/fuzzy.js";
+import { isEscapeInput } from "../utils/keys.js";
+// Helper function to compute suggestions from input
+function computeSuggestions(input, commands, maxSuggestions) {
+    if (!input.startsWith("/") || input.includes(" ")) {
+        return { suggestions: [], isOpen: false };
+    }
+    const query = input.slice(1); // Remove leading /
+    if (!query) {
+        // Show all commands when just "/" is typed
+        const all = commands
+            .map((cmd) => ({
+            command: cmd.name,
+            args: cmd.args,
+            description: cmd.description,
+            score: 1,
+        }))
+            .slice(0, maxSuggestions);
+        return { suggestions: all, isOpen: true };
+    }
+    const matches = fuzzySort(commands, query, (cmd) => cmd.name)
+        .slice(0, maxSuggestions)
+        .map((cmd) => ({
+        command: cmd.name,
+        args: cmd.args,
+        description: cmd.description,
+        score: cmd.score,
+    }));
+    return { suggestions: matches, isOpen: matches.length > 0 };
+}
+export function useCommandAutocomplete(input, { commands, maxSuggestions = 5, isActive = true }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [manuallyClosedFor, setManuallyClosedFor] = useState(null);
+    // Compute suggestions synchronously using useMemo
+    const { suggestions, isOpen: shouldBeOpen } = useMemo(() => computeSuggestions(input, commands, maxSuggestions), [input, commands, maxSuggestions]);
+    // Reset selection when suggestions change
+    useEffect(() => {
+        setSelectedIndex(0);
+        // Reset manually closed state when input changes
+        if (manuallyClosedFor !== input) {
+            setManuallyClosedFor(null);
+        }
+    }, [input, suggestions.length, manuallyClosedFor]);
+    // Check if manually closed for current input
+    const isOpen = shouldBeOpen && manuallyClosedFor !== input;
+    const selectNext = useCallback(() => {
+        setSelectedIndex((i) => Math.min(i + 1, suggestions.length - 1));
+    }, [suggestions.length]);
+    const selectPrev = useCallback(() => {
+        setSelectedIndex((i) => Math.max(i - 1, 0));
+    }, []);
+    const complete = useCallback(() => {
+        if (!isOpen || suggestions.length === 0)
+            return null;
+        const selected = suggestions[selectedIndex];
+        const completed = `/${selected.command}`;
+        // Add space if command takes arguments
+        if (selected.args.length > 0) {
+            return completed + " ";
+        }
+        return completed;
+    }, [isOpen, suggestions, selectedIndex]);
+    const close = useCallback(() => {
+        setManuallyClosedFor(input);
+    }, [input]);
+    // Handle keyboard input for navigation
+    useInput((input, key) => {
+        if (!isOpen)
+            return;
+        if (key.downArrow) {
+            selectNext();
+        }
+        else if (key.upArrow) {
+            selectPrev();
+        }
+        else if (isEscapeInput(input, key)) {
+            close();
+        }
+    }, { isActive: isActive && isOpen });
+    return {
+        suggestions,
+        selectedIndex,
+        isOpen,
+        selectNext,
+        selectPrev,
+        complete,
+        close,
+    };
+}
+//# sourceMappingURL=useCommandAutocomplete.js.map

package/dist/ui/hooks/useDoublePress.js

@@ -0,0 +1,37 @@
+// packages/cli/src/ui/hooks/useDoublePress.ts
+import { useRef, useCallback, useEffect } from "react";
+/**
+ * Hook to detect double key presses (e.g., Ctrl+C twice to exit)
+ */
+export function useDoublePress({ timeout = 500, onFirstPress, onDoublePress, }) {
+    const lastPressTime = useRef(0);
+    const timeoutRef = useRef(undefined);
+    // Cleanup timer on unmount
+    useEffect(() => {
+        return () => {
+            clearTimeout(timeoutRef.current);
+        };
+    }, []);
+    const handlePress = useCallback(() => {
+        const now = Date.now();
+        const elapsed = now - lastPressTime.current;
+        if (elapsed < timeout) {
+            // Double press detected
+            clearTimeout(timeoutRef.current);
+            lastPressTime.current = 0;
+            onDoublePress();
+        }
+        else {
+            // First press
+            lastPressTime.current = now;
+            onFirstPress?.();
+            // Reset after timeout
+            clearTimeout(timeoutRef.current);
+            timeoutRef.current = setTimeout(() => {
+                lastPressTime.current = 0;
+            }, timeout);
+        }
+    }, [timeout, onFirstPress, onDoublePress]);
+    return handlePress;
+}
+//# sourceMappingURL=useDoublePress.js.map

package/dist/ui/hooks/useIndicatorState.js

@@ -0,0 +1,55 @@
+import { useReducer, useEffect, useRef } from "react";
+import { transition, initialState } from "../indicator-state.js";
+import { pickRandomVerbPair, toolDisplayName } from "../verb-pairs.js";
+export function useIndicatorState(obsCtx, isStreaming) {
+    const [state, dispatch] = useReducer(transition, initialState);
+    const prevStreaming = useRef(false);
+    useEffect(() => {
+        if (isStreaming && !prevStreaming.current) {
+            dispatch({ type: "STREAM_START", verb: pickRandomVerbPair() });
+        }
+        else if (!isStreaming && prevStreaming.current) {
+            dispatch({ type: "STREAM_END" });
+        }
+        prevStreaming.current = isStreaming;
+    }, [isStreaming]);
+    // Reset state when obsCtx changes (new run session). Without this, the state
+    // machine retains stale state from the previous obsCtx's events.
+    const prevObsCtx = useRef(null);
+    useEffect(() => {
+        if (obsCtx !== prevObsCtx.current) {
+            if (prevObsCtx.current !== null) {
+                dispatch({ type: "STREAM_END" });
+            }
+            prevObsCtx.current = obsCtx;
+        }
+    }, [obsCtx]);
+    useEffect(() => {
+        if (!obsCtx)
+            return;
+        const onThinkingStart = () => dispatch({ type: "THINKING_START", verb: pickRandomVerbPair(), startedAt: Date.now() });
+        const onThinkingEnd = (data) => dispatch({
+            type: "THINKING_END",
+            verb: pickRandomVerbPair(),
+            durationSeconds: Math.round(data.durationMs / 1000),
+        });
+        const onToolStart = (event) => dispatch({
+            type: "TOOL_START",
+            callId: event.id,
+            displayName: toolDisplayName(event.name, true),
+        });
+        const onToolResult = (record) => dispatch({ type: "TOOL_END", callId: record.id, verb: pickRandomVerbPair() });
+        obsCtx.on("thinking_start", onThinkingStart);
+        obsCtx.on("thinking_end", onThinkingEnd);
+        obsCtx.on("tool_start", onToolStart);
+        obsCtx.on("tool_result", onToolResult);
+        return () => {
+            obsCtx.off("thinking_start", onThinkingStart);
+            obsCtx.off("thinking_end", onThinkingEnd);
+            obsCtx.off("tool_start", onToolStart);
+            obsCtx.off("tool_result", onToolResult);
+        };
+    }, [obsCtx]);
+    return state;
+}
+//# sourceMappingURL=useIndicatorState.js.map

package/dist/ui/hooks/useInterval.js

@@ -0,0 +1,23 @@
+// packages/cli/src/ui/hooks/useInterval.ts
+import { useEffect, useRef } from "react";
+/**
+ * A custom hook that runs a callback at a specified interval.
+ * The interval is cleared when the component unmounts.
+ * The interval is also cleared and restarted if the delay changes.
+ */
+export function useInterval(callback, delay) {
+    const savedCallback = useRef(callback);
+    // Remember the latest callback
+    useEffect(() => {
+        savedCallback.current = callback;
+    }, [callback]);
+    // Set up the interval
+    useEffect(() => {
+        function tick() {
+            savedCallback.current();
+        }
+        const id = setInterval(tick, delay);
+        return () => clearInterval(id);
+    }, [delay]);
+}
+//# sourceMappingURL=useInterval.js.map

package/dist/ui/hooks/useKeyboardShortcuts.js

@@ -0,0 +1,127 @@
+// packages/cli/src/ui/hooks/useKeyboardShortcuts.ts
+import { useInput } from "ink";
+import { Cursor } from "../utils/cursor.js";
+/**
+ * Hook providing Emacs-style keyboard shortcuts
+ */
+export function useKeyboardShortcuts({ cursor, setCursor, history, onExit, isActive = true, }) {
+    useInput((input, key) => {
+        // Ctrl key combinations
+        if (key.ctrl) {
+            switch (input.toLowerCase()) {
+                // Navigation
+                case "a":
+                    setCursor(cursor.moveToStart());
+                    return;
+                case "e":
+                    setCursor(cursor.moveToEnd());
+                    return;
+                case "b":
+                    setCursor(cursor.moveLeft());
+                    return;
+                case "f":
+                    setCursor(cursor.moveRight());
+                    return;
+                // Deletion
+                case "k":
+                    setCursor(cursor.deleteToEnd());
+                    return;
+                case "u":
+                    setCursor(cursor.deleteToStart());
+                    return;
+                case "w":
+                    setCursor(cursor.deletePrevWord());
+                    return;
+                case "h":
+                    setCursor(cursor.deleteLeft());
+                    return;
+                case "d":
+                    if (cursor.isEmpty && onExit) {
+                        onExit();
+                    }
+                    else {
+                        setCursor(cursor.deleteRight());
+                    }
+                    return;
+                // History
+                case "p":
+                    if (history && history.index < history.items.length - 1) {
+                        const newIndex = history.index + 1;
+                        history.setIndex(newIndex);
+                        setCursor(new Cursor(history.items[newIndex], history.items[newIndex].length));
+                    }
+                    return;
+                case "n":
+                    if (history && history.index > 0) {
+                        const newIndex = history.index - 1;
+                        history.setIndex(newIndex);
+                        setCursor(new Cursor(history.items[newIndex], history.items[newIndex].length));
+                    }
+                    else if (history && history.index === 0) {
+                        history.setIndex(-1);
+                        setCursor(new Cursor("", 0));
+                    }
+                    return;
+                // Clear
+                case "l":
+                    setCursor(cursor.clear());
+                    return;
+            }
+        }
+        // Meta/Alt key combinations
+        if (key.meta) {
+            switch (input.toLowerCase()) {
+                case "b":
+                    setCursor(cursor.moveToPrevWord());
+                    return;
+                case "f":
+                    setCursor(cursor.moveToNextWord());
+                    return;
+                case "d":
+                    setCursor(cursor.deleteNextWord());
+                    return;
+            }
+        }
+        // Arrow keys (with modifiers for word navigation)
+        if (key.leftArrow) {
+            if (key.ctrl || key.meta) {
+                setCursor(cursor.moveToPrevWord());
+            }
+            else {
+                setCursor(cursor.moveLeft());
+            }
+            return;
+        }
+        if (key.rightArrow) {
+            if (key.ctrl || key.meta) {
+                setCursor(cursor.moveToNextWord());
+            }
+            else {
+                setCursor(cursor.moveRight());
+            }
+            return;
+        }
+        // History with arrow keys
+        if (key.upArrow && history) {
+            if (history.index < history.items.length - 1) {
+                const newIndex = history.index + 1;
+                history.setIndex(newIndex);
+                setCursor(new Cursor(history.items[newIndex], history.items[newIndex].length));
+            }
+            return;
+        }
+        if (key.downArrow && history) {
+            if (history.index > 0) {
+                const newIndex = history.index - 1;
+                history.setIndex(newIndex);
+                setCursor(new Cursor(history.items[newIndex], history.items[newIndex].length));
+            }
+            else if (history.index === 0) {
+                history.setIndex(-1);
+                setCursor(new Cursor("", 0));
+            }
+            return;
+        }
+    }, { isActive });
+}
+//# sourceMappingURL=useKeyboardShortcuts.js.map

package/dist/ui/hooks/useTerminalSize.js

@@ -0,0 +1,55 @@
+import { useSyncExternalStore } from "react";
+function readTerminalSize() {
+    return {
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24,
+    };
+}
+let snapshot = readTerminalSize();
+let isListening = false;
+const subscribers = new Set();
+function syncSnapshotWithTerminal() {
+    const next = readTerminalSize();
+    if (next.columns === snapshot.columns && next.rows === snapshot.rows)
+        return false;
+    snapshot = next;
+    return true;
+}
+function notifySubscribers() {
+    for (const subscriber of subscribers)
+        subscriber();
+}
+function handleResize() {
+    if (!syncSnapshotWithTerminal())
+        return;
+    notifySubscribers();
+}
+function ensureListener() {
+    if (isListening)
+        return;
+    process.stdout.on("resize", handleResize);
+    isListening = true;
+}
+function releaseListener() {
+    if (!isListening || subscribers.size !== 0)
+        return;
+    process.stdout.off("resize", handleResize);
+    isListening = false;
+}
+function subscribe(onStoreChange) {
+    subscribers.add(onStoreChange);
+    syncSnapshotWithTerminal();
+    ensureListener();
+    return () => {
+        subscribers.delete(onStoreChange);
+        releaseListener();
+    };
+}
+function getSnapshot() {
+    syncSnapshotWithTerminal();
+    return snapshot;
+}
+export function useTerminalSize() {
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+//# sourceMappingURL=useTerminalSize.js.map

package/dist/ui/hooks/useUnifiedMessages.js

@@ -0,0 +1,117 @@
+/**
+ * Unified message state — single array + streaming cursor.
+ *
+ * Replaces the dual messages/previewMessages state machine that caused
+ * preview-committed race conditions (text cutoff, ghost preview, abort freeze).
+ *
+ * Invariant: `isStreaming === (streamCursor !== null)` — derived, never separate state.
+ *
+ * Generic over item type T (defaults to RenderItem for rendering, but can be
+ * used with ConversationMessage for state management in ink-repl).
+ */
+import { useReducer, useMemo, useCallback } from "react";
+// ---------------------------------------------------------------------------
+// Reducer
+// ---------------------------------------------------------------------------
+export function turnReducer(state, action) {
+    switch (action.type) {
+        case "START_TURN":
+            return {
+                items: state.items,
+                streamCursor: state.items.length,
+            };
+        case "UPDATE_STREAM": {
+            if (state.streamCursor === null)
+                return state;
+            return {
+                items: [...state.items.slice(0, state.streamCursor), ...action.snapshot],
+                streamCursor: state.streamCursor,
+            };
+        }
+        case "COMMIT_TURN": {
+            const cursor = state.streamCursor ?? state.items.length;
+            const committed = [...state.items.slice(0, cursor), ...action.flushed];
+            return {
+                items: committed,
+                streamCursor: committed.length,
+            };
+        }
+        case "END_TURN":
+            return {
+                items: state.items,
+                streamCursor: null,
+            };
+        case "APPEND_COMMITTED": {
+            if (state.streamCursor !== null) {
+                // Insert before the streaming zone so committed items stay in Static
+                const before = state.items.slice(0, state.streamCursor);
+                const streaming = state.items.slice(state.streamCursor);
+                return {
+                    items: [...before, ...action.items, ...streaming],
+                    streamCursor: state.streamCursor + action.items.length,
+                };
+            }
+            return {
+                items: [...state.items, ...action.items],
+                streamCursor: null,
+            };
+        }
+        case "RESET":
+            return {
+                items: action.items ?? [],
+                streamCursor: null,
+            };
+        case "DISCARD_STREAMING": {
+            if (state.streamCursor === null)
+                return state;
+            return {
+                items: state.items.slice(0, state.streamCursor),
+                streamCursor: null,
+            };
+        }
+        case "FUNCTIONAL_UPDATE": {
+            if (state.streamCursor !== null) {
+                const committed = state.items.slice(0, state.streamCursor);
+                const streaming = state.items.slice(state.streamCursor);
+                const updated = action.updater(committed);
+                return {
+                    items: [...updated, ...streaming],
+                    streamCursor: updated.length,
+                };
+            }
+            return {
+                items: action.updater(state.items),
+                streamCursor: null,
+            };
+        }
+        case "COMMIT_AND_END": {
+            const cursor = state.streamCursor ?? state.items.length;
+            return {
+                items: [...state.items.slice(0, cursor), ...action.flushed],
+                streamCursor: null,
+            };
+        }
+        default:
+            return state;
+    }
+}
+export function useUnifiedMessages(initialItems) {
+    const initial = initialItems
+        ? { items: initialItems, streamCursor: null }
+        : { items: [], streamCursor: null };
+    const reducer = turnReducer;
+    const [state, dispatch] = useReducer(reducer, initial);
+    const committedItems = useMemo(() => (state.streamCursor !== null ? state.items.slice(0, state.streamCursor) : state.items), [state.items, state.streamCursor]);
+    const streamingItems = useMemo(() => (state.streamCursor !== null ? state.items.slice(state.streamCursor) : []), [state.items, state.streamCursor]);
+    const isStreaming = state.streamCursor !== null;
+    const setItems = useCallback((action) => {
+        if (typeof action === "function") {
+            dispatch({ type: "FUNCTIONAL_UPDATE", updater: action });
+        }
+        else {
+            dispatch({ type: "RESET", items: action });
+        }
+    }, [dispatch]);
+    return { items: state.items, committedItems, streamingItems, isStreaming, dispatch, setItems };
+}
+//# sourceMappingURL=useUnifiedMessages.js.map

package/dist/ui/indicator-state.js

@@ -0,0 +1,44 @@
+export const initialState = { kind: "idle" };
+/**
+ * Pure state machine transition function.
+ * All randomness (verb selection, timestamps) must be computed by the caller
+ * and passed in the event payload. This keeps the reducer deterministic and
+ * safe for React StrictMode double-invocation.
+ */
+export function transition(state, event) {
+    switch (event.type) {
+        case "STREAM_START":
+            return { kind: "composing", verb: event.verb };
+        case "THINKING_START":
+            // Allowed from composing (normal) and idle (race safety net: obsCtx may fire
+            // thinking_start before the React useEffect dispatches STREAM_START).
+            // Guarded from tool_running to avoid dropping tool tracking state.
+            if (state.kind !== "composing" && state.kind !== "idle")
+                return state;
+            return { kind: "thinking", verb: event.verb, startedAt: event.startedAt };
+        case "THINKING_END":
+            if (state.kind !== "thinking")
+                return state;
+            return { kind: "composing", verb: event.verb, thoughtForSeconds: event.durationSeconds };
+        case "TOOL_START": {
+            const tools = new Map(state.kind === "tool_running" ? state.tools : []);
+            tools.set(event.callId, event.displayName);
+            return { kind: "tool_running", tools };
+        }
+        case "TOOL_END": {
+            if (state.kind !== "tool_running")
+                return state;
+            const tools = new Map(state.tools);
+            tools.delete(event.callId);
+            if (tools.size === 0) {
+                return { kind: "composing", verb: event.verb };
+            }
+            return { kind: "tool_running", tools };
+        }
+        case "STREAM_END":
+            return { kind: "idle" };
+        default:
+            return state;
+    }
+}
+//# sourceMappingURL=indicator-state.js.map

package/dist/ui/markdown/highlight.js

@@ -0,0 +1,44 @@
+import { highlight, supportsLanguage } from "cli-highlight";
+/**
+ * Highlight code with syntax coloring
+ */
+export function highlightCode(code, language) {
+    const lang = normalizeLanguage(language);
+    if (!supportsLanguage(lang)) {
+        if (supportsLanguage("markdown")) {
+            return highlight(code, { language: "markdown" });
+        }
+        return code;
+    }
+    return highlight(code, { language: lang });
+}
+/**
+ * Normalize language aliases to cli-highlight supported names
+ */
+function normalizeLanguage(lang) {
+    const aliases = {
+        js: "javascript",
+        jsx: "javascript",
+        ts: "typescript",
+        tsx: "typescript",
+        sh: "bash",
+        shell: "bash",
+        zsh: "bash",
+        yml: "yaml",
+        py: "python",
+        rb: "ruby",
+        rs: "rust",
+        go: "go",
+        md: "markdown",
+        dockerfile: "docker",
+    };
+    const normalized = lang.toLowerCase().trim();
+    return aliases[normalized] ?? normalized;
+}
+/**
+ * Check if a language is supported for highlighting
+ */
+export function isLanguageSupported(language) {
+    return supportsLanguage(normalizeLanguage(language));
+}
+//# sourceMappingURL=highlight.js.map