@aria-cli/cli 1.0.57 → 1.0.59

package/dist/ui/hooks/index.js

@@ -1,6 +0,0 @@
-// 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

@@ -1,93 +0,0 @@
-// 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

@@ -1,37 +0,0 @@
-// 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

@@ -1,55 +0,0 @@
-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

@@ -1,23 +0,0 @@
-// 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

@@ -1,127 +0,0 @@
-// 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

@@ -1,55 +0,0 @@
-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

@@ -1,117 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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