wave-code 0.0.2

package/dist/hooks/useInputKeyboardHandler.js

@@ -0,0 +1,507 @@
+import { useCallback, useRef, useEffect } from "react";
+import { useInput } from "ink";
+import { logger } from "../utils/logger.js";
+export const useInputKeyboardHandler = (props) => {
+    const { inputText, setInputText, cursorPosition, setCursorPosition, moveCursorLeft, moveCursorRight, moveCursorToStart, moveCursorToEnd, deleteCharAtCursor, insertTextAtCursor, clearInput, resetHistoryNavigation, navigateHistory, handlePasteImage, attachedImages, clearImages, showFileSelector, activateFileSelector, handleFileSelect, handleCancelFileSelect, updateSearchQuery, checkForAtDeletion, atPosition, showCommandSelector, activateCommandSelector, handleCommandSelect, handleCommandInsert, handleCancelCommandSelect, updateCommandSearchQuery, checkForSlashDeletion, slashPosition, showBashHistorySelector, activateBashHistorySelector, handleBashHistorySelect, handleBashHistoryExecute, handleCancelBashHistorySelect, updateBashHistorySearchQuery, checkForExclamationDeletion, exclamationPosition, showMemoryTypeSelector, activateMemoryTypeSelector, handleMemoryTypeSelect, showBashManager, showMcpManager, isCommandRunning, isLoading, sendMessage, abortMessage, saveMemory, } = props;
+    // Debounce for paste operations
+    const pasteDebounceRef = useRef({
+        timer: null,
+        buffer: "",
+        initialCursorPosition: 0,
+        isPasting: false,
+    });
+    // Long text compression management
+    const longTextCounterRef = useRef(0);
+    const longTextMapRef = useRef(new Map());
+    const generateCompressedText = (originalText) => {
+        longTextCounterRef.current += 1;
+        const compressedLabel = `[LongText#${longTextCounterRef.current}]`;
+        longTextMapRef.current.set(compressedLabel, originalText);
+        return compressedLabel;
+    };
+    const expandLongTextPlaceholders = (text) => {
+        let expandedText = text;
+        const longTextRegex = /\[LongText#(\d+)\]/g;
+        const matches = [...text.matchAll(longTextRegex)];
+        for (const match of matches) {
+            const placeholder = match[0];
+            const originalText = longTextMapRef.current.get(placeholder);
+            if (originalText) {
+                expandedText = expandedText.replace(placeholder, originalText);
+            }
+        }
+        return expandedText;
+    };
+    // Cleanup on unmount
+    useEffect(() => {
+        const currentDebounceRef = pasteDebounceRef.current;
+        return () => {
+            if (currentDebounceRef.timer) {
+                clearTimeout(currentDebounceRef.timer);
+            }
+        };
+    }, []);
+    const handleSelectorInput = useCallback((input, key) => {
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                const newInput = inputText.substring(0, cursorPosition - 1) +
+                    inputText.substring(cursorPosition);
+                setInputText(newInput);
+                setCursorPosition(cursorPosition - 1);
+                // Update search query
+                if (atPosition >= 0) {
+                    const queryStart = atPosition + 1;
+                    const queryEnd = cursorPosition - 1;
+                    if (queryEnd <= atPosition) {
+                        // Deleted @ symbol, close file selector
+                        handleCancelFileSelect();
+                    }
+                    else {
+                        const newQuery = newInput.substring(queryStart, queryEnd);
+                        updateSearchQuery(newQuery);
+                    }
+                }
+                else if (slashPosition >= 0) {
+                    const queryStart = slashPosition + 1;
+                    const queryEnd = cursorPosition - 1;
+                    if (queryEnd <= slashPosition) {
+                        // Deleted / symbol, close command selector
+                        handleCancelCommandSelect();
+                    }
+                    else {
+                        const newQuery = newInput.substring(queryStart, queryEnd);
+                        updateCommandSearchQuery(newQuery);
+                    }
+                }
+                else if (exclamationPosition >= 0) {
+                    const queryStart = exclamationPosition + 1;
+                    const queryEnd = cursorPosition - 1;
+                    if (queryEnd <= exclamationPosition) {
+                        // Deleted ! symbol, close bash history selector
+                        handleCancelBashHistorySelect();
+                    }
+                    else {
+                        const newQuery = newInput.substring(queryStart, queryEnd);
+                        updateBashHistorySearchQuery(newQuery);
+                    }
+                }
+            }
+            return;
+        }
+        // Arrow keys should be handled by selector components, no need to filter here
+        if (key.upArrow || key.downArrow) {
+            // Let selector component handle arrow key navigation
+            return;
+        }
+        if (input &&
+            !key.ctrl &&
+            !("alt" in key && key.alt) &&
+            !key.meta &&
+            !key.return &&
+            !key.escape &&
+            !key.leftArrow &&
+            !key.rightArrow &&
+            !("home" in key && key.home) &&
+            !("end" in key && key.end)) {
+            // Handle character input for search
+            const char = input;
+            const newInput = inputText.substring(0, cursorPosition) +
+                char +
+                inputText.substring(cursorPosition);
+            setInputText(newInput);
+            setCursorPosition(cursorPosition + input.length);
+            // Update search query
+            if (atPosition >= 0) {
+                const queryStart = atPosition + 1;
+                const queryEnd = cursorPosition + input.length;
+                const newQuery = newInput.substring(queryStart, queryEnd);
+                updateSearchQuery(newQuery);
+            }
+            else if (slashPosition >= 0) {
+                const queryStart = slashPosition + 1;
+                const queryEnd = cursorPosition + input.length;
+                const newQuery = newInput.substring(queryStart, queryEnd);
+                updateCommandSearchQuery(newQuery);
+            }
+            else if (exclamationPosition >= 0) {
+                const queryStart = exclamationPosition + 1;
+                const queryEnd = cursorPosition + input.length;
+                const newQuery = newInput.substring(queryStart, queryEnd);
+                updateBashHistorySearchQuery(newQuery);
+            }
+        }
+    }, [
+        inputText,
+        cursorPosition,
+        setInputText,
+        setCursorPosition,
+        atPosition,
+        slashPosition,
+        exclamationPosition,
+        handleCancelFileSelect,
+        handleCancelCommandSelect,
+        handleCancelBashHistorySelect,
+        updateSearchQuery,
+        updateCommandSearchQuery,
+        updateBashHistorySearchQuery,
+    ]);
+    const handleNormalInput = useCallback(async (input, key) => {
+        if (key.return) {
+            // Prevent submission during loading or command execution
+            if (isLoading || isCommandRunning) {
+                return;
+            }
+            if (inputText.trim()) {
+                const trimmedInput = inputText.trim();
+                // Check if it's a memory message (starts with # and only one line)
+                if (trimmedInput.startsWith("#") && !trimmedInput.includes("\n")) {
+                    // Activate memory type selector
+                    activateMemoryTypeSelector(trimmedInput);
+                    return;
+                }
+                // Extract image information
+                const imageRegex = /\[Image #(\d+)\]/g;
+                const matches = [...inputText.matchAll(imageRegex)];
+                const referencedImages = matches
+                    .map((match) => {
+                    const imageId = parseInt(match[1], 10);
+                    return attachedImages.find((img) => img.id === imageId);
+                })
+                    .filter((img) => img !== undefined)
+                    .map((img) => ({ path: img.path, mimeType: img.mimeType }));
+                // Remove image placeholders, expand long text placeholders, send message
+                let cleanContent = inputText.replace(imageRegex, "").trim();
+                cleanContent = expandLongTextPlaceholders(cleanContent);
+                sendMessage(cleanContent, referencedImages.length > 0 ? referencedImages : undefined);
+                clearInput();
+                clearImages();
+                resetHistoryNavigation();
+                // Clear long text mapping
+                longTextMapRef.current.clear();
+            }
+            return;
+        }
+        if (key.escape) {
+            if (showFileSelector) {
+                handleCancelFileSelect();
+            }
+            else if (showCommandSelector) {
+                handleCancelCommandSelect();
+            }
+            else if (showBashHistorySelector) {
+                handleCancelBashHistorySelect();
+            }
+            return;
+        }
+        if (key.backspace || key.delete) {
+            if (cursorPosition > 0) {
+                deleteCharAtCursor();
+                resetHistoryNavigation();
+                // Check if we deleted any special characters
+                const newCursorPosition = cursorPosition - 1;
+                checkForAtDeletion(newCursorPosition);
+                checkForSlashDeletion(newCursorPosition);
+                checkForExclamationDeletion(newCursorPosition);
+            }
+            return;
+        }
+        if (key.leftArrow) {
+            moveCursorLeft();
+            return;
+        }
+        if (key.rightArrow) {
+            moveCursorRight();
+            return;
+        }
+        if (("home" in key && key.home) || (key.ctrl && input === "a")) {
+            moveCursorToStart();
+            return;
+        }
+        if (("end" in key && key.end) || (key.ctrl && input === "e")) {
+            moveCursorToEnd();
+            return;
+        }
+        // Handle Ctrl+V for pasting images
+        if (key.ctrl && input === "v") {
+            handlePasteImage().catch((error) => {
+                console.warn("Failed to handle paste image:", error);
+            });
+            return;
+        }
+        // Handle up/down keys for history navigation (only when no selector is active)
+        if (key.upArrow &&
+            !showFileSelector &&
+            !showCommandSelector &&
+            !showBashHistorySelector) {
+            const { newInput, newCursorPosition } = navigateHistory("up", inputText);
+            setInputText(newInput);
+            setCursorPosition(newCursorPosition);
+            return;
+        }
+        if (key.downArrow &&
+            !showFileSelector &&
+            !showCommandSelector &&
+            !showBashHistorySelector) {
+            const { newInput, newCursorPosition } = navigateHistory("down", inputText);
+            setInputText(newInput);
+            setCursorPosition(newCursorPosition);
+            return;
+        }
+        // Handle typing input
+        if (input &&
+            !key.ctrl &&
+            !("alt" in key && key.alt) &&
+            !key.meta &&
+            !key.return &&
+            !key.escape &&
+            !key.backspace &&
+            !key.delete &&
+            !key.leftArrow &&
+            !key.rightArrow &&
+            !("home" in key && key.home) &&
+            !("end" in key && key.end)) {
+            const inputString = input;
+            // Detect if it's a paste operation (input contains multiple characters or newlines)
+            const isPasteOperation = inputString.length > 1 ||
+                inputString.includes("\n") ||
+                inputString.includes("\r");
+            if (isPasteOperation) {
+                logger.debug("[InputBox] 🔍 Detected paste operation:", {
+                    inputLength: inputString.length,
+                    input: inputString.substring(0, 50) +
+                        (inputString.length > 50 ? "..." : ""),
+                    hasNewlines: inputString.includes("\n") || inputString.includes("\r"),
+                });
+                // Start or continue the debounce handling for paste operation
+                if (!pasteDebounceRef.current.isPasting) {
+                    // Start new paste operation
+                    logger.debug("[InputBox] 🚀 Starting new paste operation - initializing debounce buffer");
+                    pasteDebounceRef.current.isPasting = true;
+                    pasteDebounceRef.current.buffer = inputString;
+                    pasteDebounceRef.current.initialCursorPosition = cursorPosition;
+                }
+                else {
+                    // Continue paste operation, add new input to buffer
+                    logger.debug("[InputBox] 📝 Merging paste content to buffer:", {
+                        previousBufferLength: pasteDebounceRef.current.buffer.length,
+                        newInputLength: inputString.length,
+                        newTotalLength: pasteDebounceRef.current.buffer.length + inputString.length,
+                    });
+                    pasteDebounceRef.current.buffer += inputString;
+                }
+                // Clear previous timer
+                if (pasteDebounceRef.current.timer) {
+                    logger.debug("[InputBox] ⏰ Clearing previous debounce timer, resetting 30ms delay");
+                    clearTimeout(pasteDebounceRef.current.timer);
+                }
+                // Set new 30ms timer
+                pasteDebounceRef.current.timer = setTimeout(() => {
+                    logger.debug("[InputBox] ✅ Debounce complete - processing merged paste content:", {
+                        finalBufferLength: pasteDebounceRef.current.buffer.length,
+                        content: pasteDebounceRef.current.buffer.substring(0, 100) +
+                            (pasteDebounceRef.current.buffer.length > 100 ? "..." : ""),
+                    });
+                    // Process all paste content in buffer
+                    let processedInput = pasteDebounceRef.current.buffer.replace(/\r/g, "\n");
+                    // Check if long text compression is needed (over 200 characters)
+                    if (processedInput.length > 200) {
+                        const originalText = processedInput;
+                        const compressedLabel = generateCompressedText(originalText);
+                        logger.info("[InputBox] 📦 Long text compression: originalLength:", originalText.length, "compressedLabel:", compressedLabel, "preview:", originalText.substring(0, 50) + "...");
+                        processedInput = compressedLabel;
+                    }
+                    insertTextAtCursor(processedInput);
+                    resetHistoryNavigation();
+                    // Reset paste state
+                    pasteDebounceRef.current.isPasting = false;
+                    pasteDebounceRef.current.buffer = "";
+                    pasteDebounceRef.current.timer = null;
+                    logger.debug("[InputBox] 🎯 Paste debounce processing complete, state reset");
+                }, 30);
+            }
+            else {
+                // Handle single character input
+                let char = inputString;
+                // Check if it's Chinese exclamation mark, convert to English if at beginning
+                if (char === "！" && cursorPosition === 0) {
+                    char = "!";
+                }
+                // First update input text and cursor position
+                const newInputText = inputText.substring(0, cursorPosition) +
+                    char +
+                    inputText.substring(cursorPosition);
+                const newCursorPosition = cursorPosition + char.length;
+                insertTextAtCursor(char);
+                resetHistoryNavigation();
+                // Check special characters and set corresponding selectors
+                if (char === "@") {
+                    activateFileSelector(cursorPosition);
+                }
+                else if (char === "/") {
+                    activateCommandSelector(cursorPosition);
+                }
+                else if (char === "!" && cursorPosition === 0) {
+                    // ! must be the first character to trigger bash selector
+                    activateBashHistorySelector(cursorPosition);
+                }
+                else if (char === "#" && cursorPosition === 0) {
+                    // # at beginning position, will be auto-detected as memory message when sent
+                    logger.debug("[InputBox] 📝 Memory message detection, input starts with #");
+                }
+                else if (showFileSelector && atPosition >= 0) {
+                    // Update search query
+                    const queryStart = atPosition + 1;
+                    const queryEnd = newCursorPosition;
+                    const newQuery = newInputText.substring(queryStart, queryEnd);
+                    updateSearchQuery(newQuery);
+                }
+                else if (showCommandSelector && slashPosition >= 0) {
+                    // Update command search query
+                    const queryStart = slashPosition + 1;
+                    const queryEnd = newCursorPosition;
+                    const newQuery = newInputText.substring(queryStart, queryEnd);
+                    updateCommandSearchQuery(newQuery);
+                }
+                else if (showBashHistorySelector && exclamationPosition >= 0) {
+                    // Update bash history search query
+                    const queryStart = exclamationPosition + 1;
+                    const queryEnd = newCursorPosition;
+                    const newQuery = newInputText.substring(queryStart, queryEnd);
+                    updateBashHistorySearchQuery(newQuery);
+                }
+            }
+        }
+    }, [
+        inputText,
+        cursorPosition,
+        sendMessage,
+        clearInput,
+        resetHistoryNavigation,
+        showFileSelector,
+        showCommandSelector,
+        showBashHistorySelector,
+        handleCancelFileSelect,
+        handleCancelCommandSelect,
+        handleCancelBashHistorySelect,
+        deleteCharAtCursor,
+        checkForAtDeletion,
+        checkForSlashDeletion,
+        checkForExclamationDeletion,
+        moveCursorLeft,
+        moveCursorRight,
+        moveCursorToStart,
+        moveCursorToEnd,
+        navigateHistory,
+        setInputText,
+        setCursorPosition,
+        insertTextAtCursor,
+        activateFileSelector,
+        activateCommandSelector,
+        activateBashHistorySelector,
+        atPosition,
+        slashPosition,
+        exclamationPosition,
+        updateSearchQuery,
+        updateCommandSearchQuery,
+        updateBashHistorySearchQuery,
+        attachedImages,
+        clearImages,
+        handlePasteImage,
+        activateMemoryTypeSelector,
+        isLoading,
+        isCommandRunning,
+    ]);
+    useInput((input, key) => {
+        // Handle interrupt request - use Esc key to interrupt AI request or command
+        if (key.escape && (isLoading || isCommandRunning)) {
+            // Unified interrupt for AI message generation and command execution
+            if (typeof abortMessage === "function") {
+                abortMessage();
+            }
+            return;
+        }
+        // During loading or command execution, except for Esc key, other input operations continue normally
+        // but will prevent Enter submission in handleNormalInput
+        if (showFileSelector ||
+            showCommandSelector ||
+            showBashHistorySelector ||
+            showMemoryTypeSelector ||
+            showBashManager ||
+            showMcpManager) {
+            if (showMemoryTypeSelector || showBashManager || showMcpManager) {
+                // Memory type selector, bash manager and MCP manager don't need to handle input, handled by component itself
+                return;
+            }
+            handleSelectorInput(input, key);
+        }
+        else {
+            handleNormalInput(input, key);
+        }
+    });
+    return {
+        handleFileSelect: useCallback((filePath) => {
+            const { newInput, newCursorPosition } = handleFileSelect(filePath, inputText, cursorPosition);
+            setInputText(newInput);
+            setCursorPosition(newCursorPosition);
+        }, [
+            handleFileSelect,
+            inputText,
+            cursorPosition,
+            setInputText,
+            setCursorPosition,
+        ]),
+        handleCommandSelect: useCallback((command) => {
+            const { newInput, newCursorPosition } = handleCommandSelect(command, inputText, cursorPosition);
+            setInputText(newInput);
+            setCursorPosition(newCursorPosition);
+        }, [
+            handleCommandSelect,
+            inputText,
+            cursorPosition,
+            setInputText,
+            setCursorPosition,
+        ]),
+        handleCommandInsert: useCallback((command) => {
+            const { newInput, newCursorPosition } = handleCommandInsert(command, inputText, cursorPosition);
+            setInputText(newInput);
+            setCursorPosition(newCursorPosition);
+        }, [
+            handleCommandInsert,
+            inputText,
+            cursorPosition,
+            setInputText,
+            setCursorPosition,
+        ]),
+        handleBashHistorySelect: useCallback((command) => {
+            const { newInput, newCursorPosition } = handleBashHistorySelect(command, inputText, cursorPosition);
+            setInputText(newInput);
+            setCursorPosition(newCursorPosition);
+        }, [
+            handleBashHistorySelect,
+            inputText,
+            cursorPosition,
+            setInputText,
+            setCursorPosition,
+        ]),
+        handleBashHistoryExecute: useCallback((command) => {
+            const commandToExecute = handleBashHistoryExecute(command);
+            // Clear input box and execute command, ensure command starts with !
+            const bashCommand = commandToExecute.startsWith("!")
+                ? commandToExecute
+                : `!${commandToExecute}`;
+            setInputText("");
+            setCursorPosition(0);
+            sendMessage(bashCommand);
+        }, [handleBashHistoryExecute, setInputText, setCursorPosition, sendMessage]),
+        handleMemoryTypeSelect: useCallback(async (type) => {
+            const currentMessage = inputText.trim();
+            if (currentMessage.startsWith("#")) {
+                await saveMemory(currentMessage, type);
+            }
+            // Call the handler function from useMemoryTypeSelector to close the selector
+            handleMemoryTypeSelect(type);
+            // Clear input box
+            clearInput();
+        }, [inputText, saveMemory, handleMemoryTypeSelect, clearInput]),
+    };
+};

package/dist/hooks/useInputState.d.ts

@@ -0,0 +1,14 @@
+export declare const useInputState: () => {
+    inputText: string;
+    setInputText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    cursorPosition: number;
+    setCursorPosition: import("react").Dispatch<import("react").SetStateAction<number>>;
+    insertTextAtCursor: (text: string) => void;
+    deleteCharAtCursor: () => void;
+    clearInput: () => void;
+    moveCursorLeft: () => void;
+    moveCursorRight: () => void;
+    moveCursorToStart: () => void;
+    moveCursorToEnd: () => void;
+};
+//# sourceMappingURL=useInputState.d.ts.map

package/dist/hooks/useInputState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInputState.d.ts","sourceRoot":"","sources":["../../src/hooks/useInputState.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa;;;;;+BAIsB,MAAM;;;;;;;CA2DrD,CAAC"}

package/dist/hooks/useInputState.js

@@ -0,0 +1,57 @@
+import { useState, useCallback } from "react";
+export const useInputState = () => {
+    const [inputText, setInputText] = useState("");
+    const [cursorPosition, setCursorPosition] = useState(0);
+    const insertTextAtCursor = useCallback((text) => {
+        setCursorPosition((currentCursor) => {
+            setInputText((currentText) => {
+                const beforeCursor = currentText.substring(0, currentCursor);
+                const afterCursor = currentText.substring(currentCursor);
+                return beforeCursor + text + afterCursor;
+            });
+            return currentCursor + text.length;
+        });
+    }, []);
+    const deleteCharAtCursor = useCallback(() => {
+        setCursorPosition((currentCursor) => {
+            if (currentCursor > 0) {
+                setInputText((currentText) => {
+                    const beforeCursor = currentText.substring(0, currentCursor - 1);
+                    const afterCursor = currentText.substring(currentCursor);
+                    return beforeCursor + afterCursor;
+                });
+                return currentCursor - 1;
+            }
+            return currentCursor;
+        });
+    }, []);
+    const clearInput = useCallback(() => {
+        setInputText("");
+        setCursorPosition(0);
+    }, []);
+    const moveCursorLeft = useCallback(() => {
+        setCursorPosition((current) => Math.max(0, current - 1));
+    }, []);
+    const moveCursorRight = useCallback(() => {
+        setCursorPosition((current) => Math.min(inputText.length, current + 1));
+    }, [inputText.length]);
+    const moveCursorToStart = useCallback(() => {
+        setCursorPosition(0);
+    }, []);
+    const moveCursorToEnd = useCallback(() => {
+        setCursorPosition(inputText.length);
+    }, [inputText.length]);
+    return {
+        inputText,
+        setInputText,
+        cursorPosition,
+        setCursorPosition,
+        insertTextAtCursor,
+        deleteCharAtCursor,
+        clearInput,
+        moveCursorLeft,
+        moveCursorRight,
+        moveCursorToStart,
+        moveCursorToEnd,
+    };
+};

package/dist/hooks/useMemoryTypeSelector.d.ts

@@ -0,0 +1,9 @@
+export interface UseMemoryTypeSelectorReturn {
+    showMemoryTypeSelector: boolean;
+    memoryMessage: string;
+    activateMemoryTypeSelector: (message: string) => void;
+    handleMemoryTypeSelect: (type: "project" | "user") => void;
+    handleCancelMemoryTypeSelect: () => void;
+}
+export declare const useMemoryTypeSelector: () => UseMemoryTypeSelectorReturn;
+//# sourceMappingURL=useMemoryTypeSelector.d.ts.map

package/dist/hooks/useMemoryTypeSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryTypeSelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useMemoryTypeSelector.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,2BAA2B;IAC1C,sBAAsB,EAAE,OAAO,CAAC;IAChC,aAAa,EAAE,MAAM,CAAC;IACtB,0BAA0B,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,sBAAsB,EAAE,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,IAAI,CAAC;IAC3D,4BAA4B,EAAE,MAAM,IAAI,CAAC;CAC1C;AAED,eAAO,MAAM,qBAAqB,QAAO,2BA6BxC,CAAC"}

package/dist/hooks/useMemoryTypeSelector.js

@@ -0,0 +1,27 @@
+import { useState } from "react";
+export const useMemoryTypeSelector = () => {
+    const [showMemoryTypeSelector, setShowMemoryTypeSelector] = useState(false);
+    const [memoryMessage, setMemoryMessage] = useState("");
+    const activateMemoryTypeSelector = (message) => {
+        setMemoryMessage(message);
+        setShowMemoryTypeSelector(true);
+    };
+    const handleMemoryTypeSelect = (type) => {
+        setShowMemoryTypeSelector(false);
+        setMemoryMessage("");
+        // Type parameter is passed by external component, here only responsible for closing selector
+        // Actual type handling is completed in useInputKeyboardHandler
+        void type; // Explicitly mark parameter as known but unused
+    };
+    const handleCancelMemoryTypeSelect = () => {
+        setShowMemoryTypeSelector(false);
+        setMemoryMessage("");
+    };
+    return {
+        showMemoryTypeSelector,
+        memoryMessage,
+        activateMemoryTypeSelector,
+        handleMemoryTypeSelect,
+        handleCancelMemoryTypeSelect,
+    };
+};

package/dist/hooks/usePagination.d.ts

@@ -0,0 +1,20 @@
+import type { Message } from "wave-agent-sdk";
+interface PaginationInfo {
+    currentPage: number;
+    totalPages: number;
+    startIndex: number;
+    endIndex: number;
+    messagesPerPage: number;
+}
+export declare const usePagination: (messages: Message[]) => {
+    displayInfo: PaginationInfo;
+    manualPage: number | null;
+    setManualPage: import("react").Dispatch<import("react").SetStateAction<number | null>>;
+    goToPage: (page: number | null) => void;
+    goToPrevPage: () => void;
+    goToNextPage: () => void;
+    goToFirstPage: () => void;
+    goToLastPage: () => void;
+};
+export {};
+//# sourceMappingURL=usePagination.d.ts.map

package/dist/hooks/usePagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePagination.d.ts","sourceRoot":"","sources":["../../src/hooks/usePagination.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAG9C,UAAU,cAAc;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,eAAO,MAAM,aAAa,GAAI,UAAU,OAAO,EAAE;;;;qBAwIvB,MAAM,GAAG,IAAI;;;;;CAqDtC,CAAC"}