dexto 1.3.0 → 1.5.0

package/dist/cli/ink-cli/hooks/useCLIState.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Shared CLI State Hook
+ *
+ * Contains all common state and logic shared between rendering modes.
+ * Both AlternateBufferCLI and StaticCLI use this hook.
+ */
+import React from 'react';
+import { type DextoAgent, type QueuedMessage } from '@dexto/core';
+import type { Message, StartupInfo, UIState, InputState, SessionState } from '../state/types.js';
+import type { ApprovalRequest } from '../components/ApprovalPrompt.js';
+import { InputService, MessageService } from '../services/index.js';
+import type { OverlayContainerHandle } from '../containers/OverlayContainer.js';
+import { type TextBuffer } from '../components/shared/text-buffer.js';
+export type { UIState, InputState, SessionState } from '../state/types.js';
+export interface UseCLIStateProps {
+    agent: DextoAgent;
+    initialSessionId: string | null;
+    startupInfo: StartupInfo;
+    /** Optional keyboard scroll handler for alternate buffer mode */
+    onKeyboardScroll?: (direction: 'up' | 'down') => void;
+}
+export interface CLIStateReturn {
+    messages: Message[];
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    pendingMessages: Message[];
+    setPendingMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    dequeuedBuffer: Message[];
+    setDequeuedBuffer: React.Dispatch<React.SetStateAction<Message[]>>;
+    queuedMessages: QueuedMessage[];
+    setQueuedMessages: React.Dispatch<React.SetStateAction<QueuedMessage[]>>;
+    ui: UIState;
+    setUi: React.Dispatch<React.SetStateAction<UIState>>;
+    input: InputState;
+    setInput: React.Dispatch<React.SetStateAction<InputState>>;
+    session: SessionState;
+    setSession: React.Dispatch<React.SetStateAction<SessionState>>;
+    approval: ApprovalRequest | null;
+    setApproval: React.Dispatch<React.SetStateAction<ApprovalRequest | null>>;
+    approvalQueue: ApprovalRequest[];
+    setApprovalQueue: React.Dispatch<React.SetStateAction<ApprovalRequest[]>>;
+    buffer: TextBuffer;
+    inputService: InputService;
+    messageService: MessageService;
+    overlayContainerRef: React.RefObject<OverlayContainerHandle | null>;
+    visibleMessages: Message[];
+    agent: DextoAgent;
+    startupInfo: StartupInfo;
+}
+export declare function useCLIState({ agent, initialSessionId, startupInfo, onKeyboardScroll: _onKeyboardScroll, }: UseCLIStateProps): CLIStateReturn;
+//# sourceMappingURL=useCLIState.d.ts.map

package/dist/cli/ink-cli/hooks/useCLIState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCLIState.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/hooks/useCLIState.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAA4D,MAAM,OAAO,CAAC;AAEjF,OAAO,EAAuB,KAAK,UAAU,EAAE,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AAGvE,OAAO,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEpE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAChF,OAAO,EAAiB,KAAK,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAGrF,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE3E,MAAM,WAAW,gBAAgB;IAC7B,KAAK,EAAE,UAAU,CAAC;IAClB,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,CAAC,SAAS,EAAE,IAAI,GAAG,MAAM,KAAK,IAAI,CAAC;CACzD;AAED,MAAM,WAAW,cAAc;IAE3B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAE7D,eAAe,EAAE,OAAO,EAAE,CAAC;IAC3B,kBAAkB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAGpE,cAAc,EAAE,OAAO,EAAE,CAAC;IAC1B,iBAAiB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAEnE,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,iBAAiB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC;IACzE,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IACrD,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;IAC3D,OAAO,EAAE,YAAY,CAAC;IACtB,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC,CAAC;IAC/D,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC;IAC1E,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,gBAAgB,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,eAAe,EAAE,CAAC,CAAC,CAAC;IAG1E,MAAM,EAAE,UAAU,CAAC;IAGnB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAG/B,mBAAmB,EAAE,KAAK,CAAC,SAAS,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAAC;IAGpE,eAAe,EAAE,OAAO,EAAE,CAAC;IAG3B,KAAK,EAAE,UAAU,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;CAC5B;AAED,wBAAgB,WAAW,CAAC,EACxB,KAAK,EACL,gBAAgB,EAChB,WAAW,EACX,gBAAgB,EAAE,iBAAiB,GACtC,EAAE,gBAAgB,GAAG,cAAc,CAgMnC"}

package/dist/cli/ink-cli/hooks/useCLIState.js

@@ -0,0 +1,190 @@
+/**
+ * Shared CLI State Hook
+ *
+ * Contains all common state and logic shared between rendering modes.
+ * Both AlternateBufferCLI and StaticCLI use this hook.
+ */
+import { useState, useMemo, useEffect, useRef, useCallback } from 'react';
+import { useStdout } from 'ink';
+import { getModelDisplayName } from '@dexto/core';
+import { useAgentEvents } from './useAgentEvents.js';
+import { useInputOrchestrator } from './useInputOrchestrator.js';
+import { InputService, MessageService } from '../services/index.js';
+import { convertHistoryToUIMessages } from '../utils/messageFormatting.js';
+import { useTextBuffer } from '../components/shared/text-buffer.js';
+export function useCLIState({ agent, initialSessionId, startupInfo, onKeyboardScroll: _onKeyboardScroll, }) {
+    // Messages state - finalized messages (rendered in <Static>)
+    const [messages, setMessages] = useState([]);
+    // Pending messages - streaming/in-progress (rendered dynamically outside <Static>)
+    const [pendingMessages, setPendingMessages] = useState([]);
+    // Dequeued buffer - user messages rendered after pending (guarantees visual order)
+    const [dequeuedBuffer, setDequeuedBuffer] = useState([]);
+    // Queued messages - messages waiting to be processed (uses core type)
+    const [queuedMessages, setQueuedMessages] = useState([]);
+    // UI state
+    const [ui, setUi] = useState({
+        isProcessing: false,
+        isCancelling: false,
+        isThinking: false,
+        activeOverlay: 'none',
+        exitWarningShown: false,
+        exitWarningTimestamp: null,
+        mcpWizardServerType: null,
+        copyModeEnabled: false,
+        pendingModelSwitch: null,
+        selectedMcpServer: null,
+        historySearch: {
+            isActive: false,
+            query: '',
+            matchIndex: 0,
+            originalInput: '',
+            lastMatch: '',
+        },
+        promptAddWizard: null,
+        autoApproveEdits: false,
+    });
+    // Input state
+    const [input, setInput] = useState({
+        value: '',
+        history: [],
+        historyIndex: -1,
+        draftBeforeHistory: '',
+        images: [],
+        pastedBlocks: [],
+        pasteCounter: 0,
+    });
+    // Session state - use display name for built-in models at startup
+    const initialConfig = agent.getCurrentLLMConfig();
+    const [session, setSession] = useState({
+        id: initialSessionId,
+        hasActiveSession: initialSessionId !== null,
+        modelName: getModelDisplayName(initialConfig.model, initialConfig.provider),
+    });
+    // Approval state
+    const [approval, setApproval] = useState(null);
+    const [approvalQueue, setApprovalQueue] = useState([]);
+    // Initialize services (memoized)
+    const inputService = useMemo(() => new InputService(), []);
+    const messageService = useMemo(() => new MessageService(), []);
+    // Get terminal dimensions for buffer
+    const { stdout } = useStdout();
+    const terminalWidth = stdout?.columns || 80;
+    const inputWidth = Math.max(20, terminalWidth - 4);
+    // Memoize onChange to prevent infinite loops (useTextBuffer has onChange in deps)
+    const handleBufferChange = useCallback((text) => {
+        setInput((prev) => ({ ...prev, value: text }));
+    }, []);
+    // Create text buffer (source of truth for input)
+    const buffer = useTextBuffer({
+        initialText: '',
+        viewport: { width: inputWidth, height: 10 },
+        onChange: handleBufferChange,
+    });
+    // Update viewport on terminal resize
+    useEffect(() => {
+        buffer.setViewport(inputWidth, 10);
+    }, [inputWidth, buffer.setViewport]);
+    // Ref for overlay container (input no longer needs ref)
+    const overlayContainerRef = useRef(null);
+    // Setup event bus subscriptions for non-streaming events
+    // (streaming events are handled directly via agent.stream() iterator in InputContainer)
+    useAgentEvents({
+        agent,
+        setMessages,
+        setUi,
+        setSession,
+        setApproval,
+        setApprovalQueue,
+        setQueuedMessages,
+    });
+    // Create input handlers for the orchestrator
+    // Note: Main input is NOT routed through orchestrator - TextBufferInput handles it directly
+    const approvalHandler = useCallback((inputStr, key) => {
+        return overlayContainerRef.current?.handleInput(inputStr, key) ?? false;
+    }, []);
+    const overlayHandler = useCallback((inputStr, key) => {
+        return overlayContainerRef.current?.handleInput(inputStr, key) ?? false;
+    }, []);
+    // Setup unified input orchestrator (handles global shortcuts, approval, overlay only)
+    useInputOrchestrator({
+        ui,
+        approval,
+        input,
+        session,
+        queuedMessages,
+        buffer,
+        setUi,
+        setInput,
+        setMessages,
+        setPendingMessages,
+        setQueuedMessages,
+        agent,
+        handlers: {
+            approval: approvalHandler,
+            overlay: overlayHandler,
+        },
+    });
+    // Hydrate conversation history when resuming a session
+    useEffect(() => {
+        if (!initialSessionId || !session.hasActiveSession || messages.length > 0) {
+            return;
+        }
+        let cancelled = false;
+        (async () => {
+            try {
+                const history = await agent.getSessionHistory(initialSessionId);
+                if (!history?.length || cancelled)
+                    return;
+                const historyMessages = convertHistoryToUIMessages(history, initialSessionId);
+                setMessages(historyMessages);
+            }
+            catch (error) {
+                if (cancelled)
+                    return;
+                setMessages((prev) => [
+                    ...prev,
+                    {
+                        id: `error-${Date.now()}`,
+                        role: 'system',
+                        content: `Error: ${error instanceof Error ? error.message : String(error)}`,
+                        timestamp: new Date(),
+                    },
+                ]);
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [agent, initialSessionId, messages.length, session.hasActiveSession]);
+    // Get visible messages - no limit needed
+    // Static mode: items are permanent in terminal scrollback, Ink only renders NEW keys
+    // AlternateBuffer mode: VirtualizedList handles its own virtualization
+    const visibleMessages = messages;
+    return {
+        messages,
+        setMessages,
+        pendingMessages,
+        setPendingMessages,
+        dequeuedBuffer,
+        setDequeuedBuffer,
+        queuedMessages,
+        setQueuedMessages,
+        ui,
+        setUi,
+        input,
+        setInput,
+        session,
+        setSession,
+        approval,
+        setApproval,
+        approvalQueue,
+        setApprovalQueue,
+        buffer,
+        inputService,
+        messageService,
+        overlayContainerRef,
+        visibleMessages,
+        agent,
+        startupInfo,
+    };
+}

package/dist/cli/ink-cli/hooks/useElapsedTime.d.ts

@@ -0,0 +1,24 @@
+/**
+ * useElapsedTime Hook
+ * Tracks elapsed time during processing with live updates
+ */
+export interface ElapsedTimeOptions {
+    /** Whether timing is active (should only run during processing) */
+    isActive: boolean;
+    /** Update interval in milliseconds (default: 100ms) */
+    intervalMs?: number;
+}
+export interface ElapsedTimeResult {
+    /** Elapsed time in milliseconds */
+    elapsedMs: number;
+    /** Formatted elapsed time string (e.g., "1.2s", "1m 23s") */
+    formatted: string;
+}
+/**
+ * Hook that tracks elapsed time during processing
+ *
+ * @param options - Configuration options
+ * @returns Elapsed time in ms and formatted string
+ */
+export declare function useElapsedTime({ isActive, intervalMs, }: ElapsedTimeOptions): ElapsedTimeResult;
+//# sourceMappingURL=useElapsedTime.d.ts.map

package/dist/cli/ink-cli/hooks/useElapsedTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useElapsedTime.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/hooks/useElapsedTime.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,kBAAkB;IAC/B,mEAAmE;IACnE,QAAQ,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAC9B,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;CACrB;AA4BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAC3B,QAAQ,EACR,UAAgB,GACnB,EAAE,kBAAkB,GAAG,iBAAiB,CAuCxC"}

package/dist/cli/ink-cli/hooks/useElapsedTime.js

@@ -0,0 +1,69 @@
+/**
+ * useElapsedTime Hook
+ * Tracks elapsed time during processing with live updates
+ */
+import { useState, useEffect, useRef } from 'react';
+/**
+ * Format milliseconds into a human-readable string
+ * - Under 1 minute: "1.2s"
+ * - 1+ minutes: "1m 23s"
+ * - 1+ hours: "1h 2m 3s"
+ */
+function formatElapsedTime(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const tenths = Math.floor((ms % 1000) / 100);
+    if (seconds < 60) {
+        return `${seconds}.${tenths}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    if (minutes < 60) {
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    const hours = Math.floor(minutes / 60);
+    const remainingMinutes = minutes % 60;
+    return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+}
+/**
+ * Hook that tracks elapsed time during processing
+ *
+ * @param options - Configuration options
+ * @returns Elapsed time in ms and formatted string
+ */
+export function useElapsedTime({ isActive, intervalMs = 100, }) {
+    const [elapsedMs, setElapsedMs] = useState(0);
+    const startTimeRef = useRef(null);
+    const intervalRef = useRef(null);
+    useEffect(() => {
+        if (isActive) {
+            // Start timing
+            startTimeRef.current = Date.now();
+            setElapsedMs(0);
+            // Update elapsed time at regular intervals
+            intervalRef.current = setInterval(() => {
+                if (startTimeRef.current !== null) {
+                    setElapsedMs(Date.now() - startTimeRef.current);
+                }
+            }, intervalMs);
+        }
+        else {
+            // Stop timing
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+            startTimeRef.current = null;
+            setElapsedMs(0);
+        }
+        return () => {
+            if (intervalRef.current) {
+                clearInterval(intervalRef.current);
+                intervalRef.current = null;
+            }
+        };
+    }, [isActive, intervalMs]);
+    return {
+        elapsedMs,
+        formatted: formatElapsedTime(elapsedMs),
+    };
+}

package/dist/cli/ink-cli/hooks/useHistorySearch.d.ts

@@ -0,0 +1,61 @@
+/**
+ * useHistorySearch - Hook for Ctrl+R reverse history search
+ *
+ * Manages search state and provides handlers for search operations.
+ */
+import { type Dispatch, type SetStateAction } from 'react';
+import type { InputState, UIState } from '../state/types.js';
+import type { TextBuffer } from '../components/shared/text-buffer.js';
+interface UseHistorySearchProps {
+    ui: UIState;
+    input: InputState;
+    buffer: TextBuffer;
+    setUi: Dispatch<SetStateAction<UIState>>;
+    setInput: Dispatch<SetStateAction<InputState>>;
+}
+interface UseHistorySearchReturn {
+    /** Whether search mode is active */
+    isActive: boolean;
+    /** Current search query */
+    query: string;
+    /** Current match (or last valid match if no current results) */
+    currentMatch: string | null;
+    /** Whether there's a match for the current query */
+    hasMatch: boolean;
+    /** Original input to potentially restore */
+    originalInput: string;
+    /** Enter search mode */
+    enter: () => void;
+    /** Exit search mode (keep current input) */
+    exit: (showRestoreHint?: boolean) => void;
+    /** Cancel search mode (restore original - used by Escape) */
+    cancel: () => void;
+    /** Update search query */
+    updateQuery: (query: string) => void;
+    /** Add character to query */
+    appendToQuery: (char: string) => void;
+    /** Remove last character from query */
+    backspace: () => void;
+    /** Cycle to next (older) match - Ctrl+R */
+    cycleNext: () => void;
+    /** Cycle to previous (newer) match - Ctrl+Shift+R */
+    cyclePrev: () => void;
+    /** Accept current match (for Enter - also exits search mode) */
+    accept: () => void;
+    /** Handle a keypress - returns true if consumed */
+    handleKey: (inputStr: string, key: {
+        ctrl: boolean;
+        shift: boolean;
+        return: boolean;
+        backspace: boolean;
+        delete: boolean;
+        escape: boolean;
+        meta: boolean;
+    }) => boolean;
+}
+/**
+ * Hook for managing reverse history search
+ */
+export declare function useHistorySearch({ ui, input, buffer, setUi, setInput, }: UseHistorySearchProps): UseHistorySearchReturn;
+export {};
+//# sourceMappingURL=useHistorySearch.d.ts.map

package/dist/cli/ink-cli/hooks/useHistorySearch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHistorySearch.d.ts","sourceRoot":"","sources":["../../../../src/cli/ink-cli/hooks/useHistorySearch.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAwB,KAAK,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,OAAO,CAAC;AACjF,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qCAAqC,CAAC;AAEtE,UAAU,qBAAqB;IAC3B,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,EAAE,UAAU,CAAC;IAClB,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;IACzC,QAAQ,EAAE,QAAQ,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC,CAAC;CAClD;AAED,UAAU,sBAAsB;IAC5B,oCAAoC;IACpC,QAAQ,EAAE,OAAO,CAAC;IAClB,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,oDAAoD;IACpD,QAAQ,EAAE,OAAO,CAAC;IAClB,4CAA4C;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,wBAAwB;IACxB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,4CAA4C;IAC5C,IAAI,EAAE,CAAC,eAAe,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAC1C,6DAA6D;IAC7D,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,0BAA0B;IAC1B,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,6BAA6B;IAC7B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,uCAAuC;IACvC,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,2CAA2C;IAC3C,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,qDAAqD;IACrD,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,gEAAgE;IAChE,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,mDAAmD;IACnD,SAAS,EAAE,CACP,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE;QACD,IAAI,EAAE,OAAO,CAAC;QACd,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,SAAS,EAAE,OAAO,CAAC;QACnB,MAAM,EAAE,OAAO,CAAC;QAChB,MAAM,EAAE,OAAO,CAAC;QAChB,IAAI,EAAE,OAAO,CAAC;KACjB,KACA,OAAO,CAAC;CAChB;AAWD;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAC7B,EAAE,EACF,KAAK,EACL,MAAM,EACN,KAAK,EACL,QAAQ,GACX,EAAE,qBAAqB,GAAG,sBAAsB,CAqPhD"}

package/dist/cli/ink-cli/hooks/useHistorySearch.js

@@ -0,0 +1,210 @@
+/**
+ * useHistorySearch - Hook for Ctrl+R reverse history search
+ *
+ * Manages search state and provides handlers for search operations.
+ */
+import { useCallback, useMemo } from 'react';
+/**
+ * Find matches in history for a query (reversed so newest is first)
+ */
+function findMatches(history, query) {
+    if (!query)
+        return [];
+    const lowerQuery = query.toLowerCase();
+    return history.filter((item) => item.toLowerCase().includes(lowerQuery)).reverse();
+}
+/**
+ * Hook for managing reverse history search
+ */
+export function useHistorySearch({ ui, input, buffer, setUi, setInput, }) {
+    const { historySearch } = ui;
+    const { history } = input;
+    // Compute current matches and whether we have a match
+    const matches = useMemo(() => findMatches(history, historySearch.query), [history, historySearch.query]);
+    const hasMatch = matches.length > 0;
+    const currentMatch = hasMatch
+        ? matches[Math.min(historySearch.matchIndex, matches.length - 1)] || null
+        : historySearch.lastMatch || null;
+    // Enter search mode
+    const enter = useCallback(() => {
+        const currentText = buffer.text;
+        setUi((prev) => ({
+            ...prev,
+            historySearch: {
+                isActive: true,
+                query: '',
+                matchIndex: 0,
+                originalInput: currentText,
+                lastMatch: '',
+            },
+        }));
+    }, [buffer, setUi]);
+    // Exit search mode (keep current input)
+    const exit = useCallback(() => {
+        setUi((prev) => ({
+            ...prev,
+            historySearch: {
+                isActive: false,
+                query: '',
+                matchIndex: 0,
+                originalInput: '',
+                lastMatch: '',
+            },
+        }));
+    }, [setUi]);
+    // Cancel search mode (restore original) - kept for potential future use
+    const cancel = useCallback(() => {
+        const originalInput = historySearch.originalInput;
+        buffer.setText(originalInput);
+        setInput((prev) => ({ ...prev, value: originalInput }));
+        exit();
+    }, [historySearch.originalInput, buffer, setInput, exit]);
+    // Apply a match to the input buffer
+    const applyMatch = useCallback((match) => {
+        if (match) {
+            buffer.setText(match);
+            setInput((prev) => ({ ...prev, value: match }));
+        }
+    }, [buffer, setInput]);
+    // Update query and apply resulting match
+    const updateQuery = useCallback((newQuery) => {
+        const newMatches = findMatches(history, newQuery);
+        const newHasMatch = newMatches.length > 0;
+        const newMatch = newHasMatch ? newMatches[0] : null;
+        setUi((prev) => ({
+            ...prev,
+            historySearch: {
+                ...prev.historySearch,
+                query: newQuery,
+                matchIndex: 0,
+                // Update lastMatch only if we have a new match
+                lastMatch: newMatch || prev.historySearch.lastMatch,
+            },
+        }));
+        // Apply match (or keep last match if no new match)
+        if (newMatch) {
+            applyMatch(newMatch);
+        }
+        // If no match, keep whatever is currently in input (the last match)
+    }, [history, setUi, applyMatch]);
+    // Append character to query
+    const appendToQuery = useCallback((char) => {
+        updateQuery(historySearch.query + char);
+    }, [historySearch.query, updateQuery]);
+    // Backspace - remove last character
+    const backspace = useCallback(() => {
+        if (historySearch.query.length > 0) {
+            updateQuery(historySearch.query.slice(0, -1));
+        }
+    }, [historySearch.query, updateQuery]);
+    // Cycle to next (older) match - Ctrl+R
+    const cycleNext = useCallback(() => {
+        if (matches.length === 0)
+            return;
+        const newIndex = Math.min(historySearch.matchIndex + 1, matches.length - 1);
+        const newMatch = matches[newIndex];
+        setUi((prev) => ({
+            ...prev,
+            historySearch: {
+                ...prev.historySearch,
+                matchIndex: newIndex,
+                lastMatch: newMatch || prev.historySearch.lastMatch,
+            },
+        }));
+        if (newMatch) {
+            applyMatch(newMatch);
+        }
+    }, [matches, historySearch.matchIndex, setUi, applyMatch]);
+    // Cycle to previous (newer) match - Ctrl+Shift+R
+    const cyclePrev = useCallback(() => {
+        if (matches.length === 0)
+            return;
+        const newIndex = Math.max(0, historySearch.matchIndex - 1);
+        const newMatch = matches[newIndex];
+        setUi((prev) => ({
+            ...prev,
+            historySearch: {
+                ...prev.historySearch,
+                matchIndex: newIndex,
+                lastMatch: newMatch || prev.historySearch.lastMatch,
+            },
+        }));
+        if (newMatch) {
+            applyMatch(newMatch);
+        }
+    }, [matches, historySearch.matchIndex, setUi, applyMatch]);
+    // Accept current match and exit
+    const accept = useCallback(() => {
+        // Input already has the match, just exit
+        exit();
+    }, [exit]);
+    // Handle keypress - returns true if consumed
+    const handleKey = useCallback((inputStr, key) => {
+        if (!historySearch.isActive) {
+            // Not in search mode - check if Ctrl+R to enter
+            if (key.ctrl && inputStr === 'r') {
+                enter();
+                return true;
+            }
+            return false;
+        }
+        // In search mode - handle all keys
+        // Ctrl+E: cycle to previous (newer) match
+        if (key.ctrl && inputStr === 'e') {
+            cyclePrev();
+            return true;
+        }
+        // Ctrl+R: cycle to next (older) match
+        if (key.ctrl && inputStr === 'r') {
+            cycleNext();
+            return true;
+        }
+        // Enter: accept match and exit (keep matched text, don't submit)
+        if (key.return) {
+            accept();
+            return true; // Consume - don't submit
+        }
+        // Escape: restore original and exit
+        if (key.escape) {
+            cancel();
+            return true;
+        }
+        // Backspace: remove character from query
+        if (key.backspace || key.delete) {
+            backspace();
+            return true;
+        }
+        // Regular typing: add to query
+        if (inputStr && !key.ctrl && !key.meta) {
+            appendToQuery(inputStr);
+            return true;
+        }
+        return true; // Consume other keys while in search mode
+    }, [
+        historySearch.isActive,
+        enter,
+        cycleNext,
+        cyclePrev,
+        accept,
+        cancel,
+        backspace,
+        appendToQuery,
+    ]);
+    return {
+        isActive: historySearch.isActive,
+        query: historySearch.query,
+        currentMatch,
+        hasMatch,
+        originalInput: historySearch.originalInput,
+        enter,
+        exit,
+        cancel,
+        updateQuery,
+        appendToQuery,
+        backspace,
+        cycleNext,
+        cyclePrev,
+        accept,
+        handleKey,
+    };
+}