wave-code 0.0.4 → 0.0.6

package/dist/components/ToolResultDisplay.js

@@ -1,11 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 export const ToolResultDisplay = ({ block, isExpanded = false, }) => {
-    const { parameters, result, compactParams, isRunning, success, error, name } = block;
+    const { parameters, result, compactParams, stage, success, error, name } = block;
     // Directly use compactParams
     // (no change needed as we destructured it above)
     const getStatusColor = () => {
-        if (isRunning)
+        if (stage === "running")
             return "yellow";
         if (success)
             return "green";
@@ -14,12 +14,12 @@ export const ToolResultDisplay = ({ block, isExpanded = false, }) => {
         return "gray"; // Unknown state or no state information
     };
     const getStatusText = () => {
-        if (isRunning)
+        if (stage === "running")
             return "🔄";
         if (success)
             return "";
         if (error || success === false)
-            return "❌ Failed";
+            return "❌";
         return ""; // Don't display text for unknown state
     };
     const hasImages = () => {
@@ -48,5 +48,5 @@ export const ToolResultDisplay = ({ block, isExpanded = false, }) => {
         return null;
     };
     const shortResult = getShortResult();
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "magenta", children: "\uD83D\uDD27 " }), _jsx(Text, { color: "white", children: toolName }), !isExpanded && compactParams && (_jsxs(Text, { color: "gray", children: [" (", compactParams, ")"] })), _jsxs(Text, { color: getStatusColor(), children: [" ", getStatusText()] }), hasImages() && _jsxs(Text, { color: "blue", children: [" ", getImageIndicator()] })] }), !isExpanded && shortResult && (_jsx(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: shortResult.split("\n").map((line, index) => (_jsx(Text, { color: "white", children: line }, index))) })), isExpanded && parameters && (_jsxs(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "Parameters:" }), _jsx(Text, { color: "gray", children: parameters })] })), isExpanded && result && (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { paddingLeft: 2, borderLeft: true, borderColor: "green", flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "Result:" }), _jsx(Text, { color: "white", children: result })] }) })), error && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", typeof error === "string" ? error : String(error)] }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "magenta", children: "\uD83D\uDD27 " }), _jsx(Text, { color: "white", children: toolName }), !isExpanded && compactParams && (_jsxs(Text, { color: "gray", children: [" ", compactParams] })), _jsxs(Text, { color: getStatusColor(), children: [" ", getStatusText()] }), hasImages() && _jsxs(Text, { color: "blue", children: [" ", getImageIndicator()] })] }), !isExpanded && shortResult && !error && (_jsx(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: shortResult.split("\n").map((line, index) => (_jsx(Text, { color: "white", children: line }, index))) })), isExpanded && parameters && (_jsxs(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "Parameters:" }), _jsx(Text, { color: "gray", children: parameters })] })), isExpanded && result && (_jsx(Box, { flexDirection: "column", children: _jsxs(Box, { paddingLeft: 2, borderLeft: true, borderColor: "green", flexDirection: "column", children: [_jsx(Text, { color: "cyan", bold: true, children: "Result:" }), _jsx(Text, { color: "white", children: result })] }) })), error && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["Error: ", typeof error === "string" ? error : String(error)] }) }))] }));
 };

package/dist/contexts/useChat.d.ts

@@ -27,6 +27,7 @@ export interface ChatContextType {
     killBackgroundShell: (shellId: string) => boolean;
     slashCommands: SlashCommand[];
     hasSlashCommand: (commandId: string) => boolean;
+    subagentMessages: Record<string, Message[]>;
 }
 export declare const useChat: () => ChatContextType;
 export interface ChatProviderProps {

package/dist/contexts/useChat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useChat.d.ts","sourceRoot":"","sources":["../../src/contexts/useChat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAON,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EACV,OAAO,EACP,eAAe,EACf,eAAe,EACf,YAAY,EACb,MAAM,gBAAgB,CAAC;AAKxB,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAE3B,UAAU,EAAE,OAAO,CAAC;IAEpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,CACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAC/C,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAE1B,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzE,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,gBAAgB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,wBAAwB,EAAE,CACxB,OAAO,EAAE,MAAM,KACZ;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/D,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAElD,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CACjD;AAID,eAAO,MAAM,OAAO,uBAMnB,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAwOpD,CAAC"}
+{"version":3,"file":"useChat.d.ts","sourceRoot":"","sources":["../../src/contexts/useChat.tsx"],"names":[],"mappings":"AAAA,OAAO,KAON,MAAM,OAAO,CAAC;AAGf,OAAO,KAAK,EACV,OAAO,EACP,eAAe,EACf,eAAe,EACf,YAAY,EACb,MAAM,gBAAgB,CAAC;AAMxB,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,aAAa,EAAE,OAAO,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAE3B,UAAU,EAAE,OAAO,CAAC;IAEpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,CACX,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAC/C,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,iBAAiB,EAAE,MAAM,CAAC;IAE1B,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzE,UAAU,EAAE,eAAe,EAAE,CAAC;IAC9B,gBAAgB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,mBAAmB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAE9D,gBAAgB,EAAE,eAAe,EAAE,CAAC;IACpC,wBAAwB,EAAE,CACxB,OAAO,EAAE,MAAM,KACZ;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/D,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC;IAElD,aAAa,EAAE,YAAY,EAAE,CAAC;IAC9B,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;IAEhD,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;CAC7C;AAID,eAAO,MAAM,OAAO,uBAMnB,CAAC;AAEF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAqQpD,CAAC"}

package/dist/contexts/useChat.js

@@ -4,6 +4,7 @@ import { useInput } from "ink";
 import { useAppConfig } from "./useAppConfig.js";
 import { Agent } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
+import { displayUsageSummary } from "../utils/usageSummary.js";
 const ChatContext = createContext(null);
 export const useChat = () => {
     const context = useContext(ChatContext);
@@ -30,11 +31,19 @@ export const ChatProvider = ({ children }) => {
     const [backgroundShells, setBackgroundShells] = useState([]);
     // Command state
     const [slashCommands, setSlashCommands] = useState([]);
+    // Subagent messages state
+    const [subagentMessages, setSubagentMessages] = useState({});
     const agentRef = useRef(null);
     // Listen for Ctrl+O hotkey to toggle collapse/expand state
     useInput((input, key) => {
         if (key.ctrl && input === "o") {
-            setIsExpanded((prev) => !prev);
+            // Clear terminal screen when expanded state changes
+            process.stdout.write("\x1Bc", () => {
+                setIsExpanded((prev) => {
+                    const newExpanded = !prev;
+                    return newExpanded;
+                });
+            });
         }
     });
     // Initialize AI manager
@@ -48,7 +57,9 @@ export const ChatProvider = ({ children }) => {
                     setMcpServers([...servers]);
                 },
                 onSessionIdChange: (sessionId) => {
-                    setSessionId(sessionId);
+                    process.stdout.write("\x1Bc", () => {
+                        setSessionId(sessionId);
+                    });
                 },
                 onLatestTotalTokensChange: (tokens) => {
                     setlatestTotalTokens(tokens);
@@ -62,6 +73,12 @@ export const ChatProvider = ({ children }) => {
                 onShellsChange: (shells) => {
                     setBackgroundShells([...shells]);
                 },
+                onSubagentMessagesChange: (subagentId, messages) => {
+                    setSubagentMessages((prev) => ({
+                        ...prev,
+                        [subagentId]: [...messages],
+                    }));
+                },
             };
             try {
                 const agent = await Agent.create({
@@ -96,6 +113,15 @@ export const ChatProvider = ({ children }) => {
     useEffect(() => {
         return () => {
             if (agentRef.current) {
+                try {
+                    // Display usage summary before cleanup
+                    const usages = agentRef.current.usages;
+                    const sessionFilePath = agentRef.current.sessionFilePath;
+                    displayUsageSummary(usages, sessionFilePath);
+                }
+                catch {
+                    // Silently ignore usage summary errors during cleanup
+                }
                 agentRef.current.destroy();
             }
         };
@@ -203,6 +229,7 @@ export const ChatProvider = ({ children }) => {
         killBackgroundShell,
         slashCommands,
         hasSlashCommand,
+        subagentMessages,
     };
     return (_jsx(ChatContext.Provider, { value: contextValue, children: children }));
 };

package/dist/hooks/useInputManager.d.ts

@@ -0,0 +1,93 @@
+import { Key } from "ink";
+import { InputManager, InputManagerCallbacks, AttachedImage } from "../managers/InputManager.js";
+import { FileItem } from "../components/FileSelector.js";
+export declare const useInputManager: (callbacks?: Partial<InputManagerCallbacks>) => {
+    inputText: string;
+    cursorPosition: number;
+    showFileSelector: boolean;
+    filteredFiles: FileItem[];
+    fileSearchQuery: string;
+    atPosition: number;
+    showCommandSelector: boolean;
+    commandSearchQuery: string;
+    slashPosition: number;
+    showBashHistorySelector: boolean;
+    bashHistorySearchQuery: string;
+    exclamationPosition: number;
+    showMemoryTypeSelector: boolean;
+    memoryMessage: string;
+    showBashManager: boolean;
+    showMcpManager: boolean;
+    attachedImages: AttachedImage[];
+    isManagerReady: boolean;
+    insertTextAtCursor: (text: string, callback?: (newText: string, newCursorPosition: number) => void) => void;
+    deleteCharAtCursor: (callback?: (newText: string, newCursorPosition: number) => void) => void;
+    clearInput: () => void;
+    moveCursorLeft: () => void;
+    moveCursorRight: () => void;
+    moveCursorToStart: () => void;
+    moveCursorToEnd: () => void;
+    activateFileSelector: (position: number) => void;
+    handleFileSelect: (filePath: string) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelFileSelect: () => void;
+    updateFileSearchQuery: (query: string) => void;
+    checkForAtDeletion: (cursorPos: number) => boolean;
+    activateCommandSelector: (position: number) => void;
+    handleCommandSelect: (command: string) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCommandInsert: (command: string) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelCommandSelect: () => void;
+    updateCommandSearchQuery: (query: string) => void;
+    checkForSlashDeletion: (cursorPos: number) => boolean;
+    activateBashHistorySelector: (position: number) => void;
+    handleBashHistorySelect: (command: string) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelBashHistorySelect: () => void;
+    updateBashHistorySearchQuery: (query: string) => void;
+    handleBashHistoryExecute: (command: string) => string;
+    checkForExclamationDeletion: (cursorPos: number) => boolean;
+    activateMemoryTypeSelector: (message: string) => void;
+    handleMemoryTypeSelect: (type: "project" | "user") => Promise<void>;
+    handleCancelMemoryTypeSelect: () => void;
+    setUserInputHistory: (history: string[]) => void;
+    navigateHistory: (direction: "up" | "down", currentInput: string) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    resetHistoryNavigation: () => void;
+    handleSpecialCharInput: (char: string) => void;
+    setShowBashManager: (show: boolean) => void;
+    setShowMcpManager: (show: boolean) => void;
+    addImage: (imagePath: string, mimeType: string) => AttachedImage | undefined;
+    removeImage: (imageId: number) => void;
+    clearImages: () => void;
+    handlePasteImage: () => Promise<boolean>;
+    handlePasteInput: (input: string) => void;
+    handleSubmit: (attachedImages: Array<{
+        id: number;
+        path: string;
+        mimeType: string;
+    }>, isLoading?: boolean, isCommandRunning?: boolean) => Promise<void>;
+    expandLongTextPlaceholders: (text: string) => string;
+    clearLongTextMap: () => void;
+    handleBashHistoryExecuteAndSend: (command: string) => void;
+    handleInput: (input: string, key: Key, attachedImages: Array<{
+        id: number;
+        path: string;
+        mimeType: string;
+    }>, isLoading?: boolean, isCommandRunning?: boolean, clearImages?: () => void) => Promise<boolean>;
+    setInputText: (text: string) => void;
+    setCursorPosition: (position: number) => void;
+    manager: InputManager | null;
+};
+//# sourceMappingURL=useInputManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInputManager.d.ts","sourceRoot":"","sources":["../../src/hooks/useInputManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAC;AAC1B,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,aAAa,EACd,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAEzD,eAAO,MAAM,eAAe,GAC1B,YAAW,OAAO,CAAC,qBAAqB,CAAM;;;;;;;;;;;;;;;;;;;+BA4GpC,MAAM,aACD,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,IAAI;oCAQrD,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,KAAK,IAAI;;;;;;qCA2Bd,MAAM;iCAK7C,MAAM;;;;;mCAe+B,MAAM;oCAIL,MAAM;wCAKF,MAAM;mCAKjD,MAAM;;;;mCAYN,MAAM;;;;;sCAemC,MAAM;uCAIL,MAAM;4CAKD,MAAM;uCAKrD,MAAM;;;;;0CAeuC,MAAM;wCAIR,MAAM;6CAID,MAAM;0CAKT,MAAM;mCAKhD,SAAS,GAAG,MAAM;;mCAWiB,MAAM,EAAE;iCAK5C,IAAI,GAAG,MAAM,gBAAgB,MAAM;;;;;mCAgBC,MAAM;+BAsFf,OAAO;8BAGR,OAAO;0BAKX,MAAM,YAAY,MAAM;2BAGvB,MAAM;;;8BAWH,MAAM;mCAKxB,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,cAC1D,OAAO,qBACA,OAAO;uCAUkB,MAAM;;+CA/GO,MAAM;yBA4HvD,MAAM,OACR,GAAG,kBACQ,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,cAC1D,OAAO,qBACA,OAAO,gBACX,MAAM,IAAI;yBA1IgB,MAAM;kCAIG,MAAM;;CA6J9D,CAAC"}

package/dist/hooks/useInputManager.js

@@ -0,0 +1,332 @@
+import { useEffect, useRef, useState, useCallback } from "react";
+import { InputManager, } from "../managers/InputManager.js";
+export const useInputManager = (callbacks = {}) => {
+    const managerRef = useRef(null);
+    const [isManagerReady, setIsManagerReady] = useState(false);
+    // React state that mirrors InputManager state
+    const [inputText, setInputText] = useState("");
+    const [cursorPosition, setCursorPosition] = useState(0);
+    const [fileSelectorState, setFileSelectorState] = useState({
+        show: false,
+        files: [],
+        query: "",
+        position: -1,
+    });
+    const [commandSelectorState, setCommandSelectorState] = useState({
+        show: false,
+        query: "",
+        position: -1,
+    });
+    const [bashHistorySelectorState, setBashHistorySelectorState] = useState({
+        show: false,
+        query: "",
+        position: -1,
+    });
+    const [memoryTypeSelectorState, setMemoryTypeSelectorState] = useState({
+        show: false,
+        message: "",
+    });
+    const [showBashManager, setShowBashManager] = useState(false);
+    const [showMcpManager, setShowMcpManager] = useState(false);
+    const [attachedImages, setAttachedImages] = useState([]);
+    // Create InputManager on mount and update callbacks when they change
+    useEffect(() => {
+        if (!managerRef.current) {
+            // Create InputManager on first mount
+            const manager = new InputManager({
+                onInputTextChange: setInputText,
+                onCursorPositionChange: setCursorPosition,
+                onFileSelectorStateChange: (show, files, query, position) => {
+                    setFileSelectorState({ show, files, query, position });
+                },
+                onCommandSelectorStateChange: (show, query, position) => {
+                    setCommandSelectorState({ show, query, position });
+                },
+                onBashHistorySelectorStateChange: (show, query, position) => {
+                    setBashHistorySelectorState({ show, query, position });
+                },
+                onMemoryTypeSelectorStateChange: (show, message) => {
+                    setMemoryTypeSelectorState({ show, message });
+                },
+                onBashManagerStateChange: (show) => {
+                    setShowBashManager(show);
+                },
+                onMcpManagerStateChange: (show) => {
+                    setShowMcpManager(show);
+                },
+                onImagesStateChange: setAttachedImages,
+                onShowBashManager: () => setShowBashManager(true),
+                onShowMcpManager: () => setShowMcpManager(true),
+                ...callbacks,
+            });
+            managerRef.current = manager;
+            setIsManagerReady(true);
+        }
+        else {
+            // Update callbacks on existing manager
+            managerRef.current.updateCallbacks({
+                onInputTextChange: setInputText,
+                onCursorPositionChange: setCursorPosition,
+                onFileSelectorStateChange: (show, files, query, position) => {
+                    setFileSelectorState({ show, files, query, position });
+                },
+                onCommandSelectorStateChange: (show, query, position) => {
+                    setCommandSelectorState({ show, query, position });
+                },
+                onBashHistorySelectorStateChange: (show, query, position) => {
+                    setBashHistorySelectorState({ show, query, position });
+                },
+                onMemoryTypeSelectorStateChange: (show, message) => {
+                    setMemoryTypeSelectorState({ show, message });
+                },
+                onBashManagerStateChange: (show) => {
+                    setShowBashManager(show);
+                },
+                onMcpManagerStateChange: (show) => {
+                    setShowMcpManager(show);
+                },
+                onImagesStateChange: setAttachedImages,
+                onShowBashManager: () => setShowBashManager(true),
+                onShowMcpManager: () => setShowMcpManager(true),
+                ...callbacks,
+            });
+        }
+    }, [callbacks]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (managerRef.current) {
+                managerRef.current.destroy();
+            }
+        };
+    }, []);
+    // Expose manager methods
+    const insertTextAtCursor = useCallback((text, callback) => {
+        managerRef.current?.insertTextAtCursor(text, callback);
+    }, []);
+    const deleteCharAtCursor = useCallback((callback) => {
+        managerRef.current?.deleteCharAtCursor(callback);
+    }, []);
+    const clearInput = useCallback(() => {
+        managerRef.current?.clearInput();
+    }, []);
+    const moveCursorLeft = useCallback(() => {
+        managerRef.current?.moveCursorLeft();
+    }, []);
+    const moveCursorRight = useCallback(() => {
+        managerRef.current?.moveCursorRight();
+    }, []);
+    const moveCursorToStart = useCallback(() => {
+        managerRef.current?.moveCursorToStart();
+    }, []);
+    const moveCursorToEnd = useCallback(() => {
+        managerRef.current?.moveCursorToEnd();
+    }, []);
+    // File selector methods
+    const activateFileSelector = useCallback((position) => {
+        managerRef.current?.activateFileSelector(position);
+    }, []);
+    const handleFileSelect = useCallback((filePath) => {
+        return (managerRef.current?.handleFileSelect(filePath) || {
+            newInput: inputText,
+            newCursorPosition: cursorPosition,
+        });
+    }, [inputText, cursorPosition]);
+    const handleCancelFileSelect = useCallback(() => {
+        managerRef.current?.handleCancelFileSelect();
+    }, []);
+    const updateFileSearchQuery = useCallback((query) => {
+        managerRef.current?.updateFileSearchQuery(query);
+    }, []);
+    const checkForAtDeletion = useCallback((cursorPos) => {
+        return managerRef.current?.checkForAtDeletion(cursorPos) || false;
+    }, []);
+    // Command selector methods
+    const activateCommandSelector = useCallback((position) => {
+        managerRef.current?.activateCommandSelector(position);
+    }, []);
+    const handleCommandSelect = useCallback((command) => {
+        return (managerRef.current?.handleCommandSelect(command) || {
+            newInput: inputText,
+            newCursorPosition: cursorPosition,
+        });
+    }, [inputText, cursorPosition]);
+    const handleCommandInsert = useCallback((command) => {
+        return (managerRef.current?.handleCommandInsert(command) || {
+            newInput: inputText,
+            newCursorPosition: cursorPosition,
+        });
+    }, [inputText, cursorPosition]);
+    const handleCancelCommandSelect = useCallback(() => {
+        managerRef.current?.handleCancelCommandSelect();
+    }, []);
+    const updateCommandSearchQuery = useCallback((query) => {
+        managerRef.current?.updateCommandSearchQuery(query);
+    }, []);
+    const checkForSlashDeletion = useCallback((cursorPos) => {
+        return managerRef.current?.checkForSlashDeletion(cursorPos) || false;
+    }, []);
+    // Bash history selector methods
+    const activateBashHistorySelector = useCallback((position) => {
+        managerRef.current?.activateBashHistorySelector(position);
+    }, []);
+    const handleBashHistorySelect = useCallback((command) => {
+        return (managerRef.current?.handleBashHistorySelect(command) || {
+            newInput: inputText,
+            newCursorPosition: cursorPosition,
+        });
+    }, [inputText, cursorPosition]);
+    const handleCancelBashHistorySelect = useCallback(() => {
+        managerRef.current?.handleCancelBashHistorySelect();
+    }, []);
+    const updateBashHistorySearchQuery = useCallback((query) => {
+        managerRef.current?.updateBashHistorySearchQuery(query);
+    }, []);
+    const handleBashHistoryExecute = useCallback((command) => {
+        return managerRef.current?.handleBashHistoryExecute(command) || command;
+    }, []);
+    const checkForExclamationDeletion = useCallback((cursorPos) => {
+        return managerRef.current?.checkForExclamationDeletion(cursorPos) || false;
+    }, []);
+    // Memory type selector methods
+    const activateMemoryTypeSelector = useCallback((message) => {
+        managerRef.current?.activateMemoryTypeSelector(message);
+    }, []);
+    const handleMemoryTypeSelect = useCallback(async (type) => {
+        await managerRef.current?.handleMemoryTypeSelect(type);
+    }, []);
+    const handleCancelMemoryTypeSelect = useCallback(() => {
+        managerRef.current?.handleCancelMemoryTypeSelect();
+    }, []);
+    // Input history methods
+    const setUserInputHistory = useCallback((history) => {
+        managerRef.current?.setUserInputHistory(history);
+    }, []);
+    const navigateHistory = useCallback((direction, currentInput) => {
+        return (managerRef.current?.navigateHistory(direction, currentInput) || {
+            newInput: currentInput,
+            newCursorPosition: currentInput.length,
+        });
+    }, []);
+    const resetHistoryNavigation = useCallback(() => {
+        managerRef.current?.resetHistoryNavigation();
+    }, []);
+    // Special character handling
+    const handleSpecialCharInput = useCallback((char) => {
+        managerRef.current?.handleSpecialCharInput(char);
+    }, []);
+    // Direct state access methods (for compatibility with existing code)
+    const setInputTextDirect = useCallback((text) => {
+        managerRef.current?.setInputText(text);
+    }, []);
+    const setCursorPositionDirect = useCallback((position) => {
+        managerRef.current?.setCursorPosition(position);
+    }, []);
+    // Complex handlers that combine multiple operations
+    const handleBashHistoryExecuteAndSend = useCallback((command) => {
+        managerRef.current?.handleBashHistoryExecuteAndSend(command);
+    }, []);
+    return {
+        // State
+        inputText,
+        cursorPosition,
+        showFileSelector: fileSelectorState.show,
+        filteredFiles: fileSelectorState.files,
+        fileSearchQuery: fileSelectorState.query,
+        atPosition: fileSelectorState.position,
+        showCommandSelector: commandSelectorState.show,
+        commandSearchQuery: commandSelectorState.query,
+        slashPosition: commandSelectorState.position,
+        showBashHistorySelector: bashHistorySelectorState.show,
+        bashHistorySearchQuery: bashHistorySelectorState.query,
+        exclamationPosition: bashHistorySelectorState.position,
+        showMemoryTypeSelector: memoryTypeSelectorState.show,
+        memoryMessage: memoryTypeSelectorState.message,
+        showBashManager,
+        showMcpManager,
+        attachedImages,
+        isManagerReady,
+        // Methods
+        insertTextAtCursor,
+        deleteCharAtCursor,
+        clearInput,
+        moveCursorLeft,
+        moveCursorRight,
+        moveCursorToStart,
+        moveCursorToEnd,
+        // File selector
+        activateFileSelector,
+        handleFileSelect,
+        handleCancelFileSelect,
+        updateFileSearchQuery,
+        checkForAtDeletion,
+        // Command selector
+        activateCommandSelector,
+        handleCommandSelect,
+        handleCommandInsert,
+        handleCancelCommandSelect,
+        updateCommandSearchQuery,
+        checkForSlashDeletion,
+        // Bash history selector
+        activateBashHistorySelector,
+        handleBashHistorySelect,
+        handleCancelBashHistorySelect,
+        updateBashHistorySearchQuery,
+        handleBashHistoryExecute,
+        checkForExclamationDeletion,
+        // Memory type selector
+        activateMemoryTypeSelector,
+        handleMemoryTypeSelect,
+        handleCancelMemoryTypeSelect,
+        // Input history
+        setUserInputHistory,
+        navigateHistory,
+        resetHistoryNavigation,
+        // Special handling
+        handleSpecialCharInput,
+        // Bash/MCP Manager
+        setShowBashManager: useCallback((show) => {
+            managerRef.current?.setShowBashManager(show);
+        }, []),
+        setShowMcpManager: useCallback((show) => {
+            managerRef.current?.setShowMcpManager(show);
+        }, []),
+        // Image management
+        addImage: useCallback((imagePath, mimeType) => {
+            return managerRef.current?.addImage(imagePath, mimeType);
+        }, []),
+        removeImage: useCallback((imageId) => {
+            managerRef.current?.removeImage(imageId);
+        }, []),
+        clearImages: useCallback(() => {
+            managerRef.current?.clearImages();
+        }, []),
+        handlePasteImage: useCallback(async () => {
+            return (await managerRef.current?.handlePasteImage()) || false;
+        }, []),
+        // Paste and text handling
+        handlePasteInput: useCallback((input) => {
+            managerRef.current?.handlePasteInput(input);
+        }, []),
+        handleSubmit: useCallback(async (attachedImages, isLoading = false, isCommandRunning = false) => {
+            await managerRef.current?.handleSubmit(attachedImages, isLoading, isCommandRunning);
+        }, []),
+        expandLongTextPlaceholders: useCallback((text) => {
+            return managerRef.current?.expandLongTextPlaceholders(text) || text;
+        }, []),
+        clearLongTextMap: useCallback(() => {
+            managerRef.current?.clearLongTextMap();
+        }, []),
+        // Complex handlers combining multiple operations
+        handleBashHistoryExecuteAndSend,
+        // Main input handler
+        handleInput: useCallback(async (input, key, attachedImages, isLoading = false, isCommandRunning = false, clearImages) => {
+            return ((await managerRef.current?.handleInput(input, key, attachedImages, isLoading, isCommandRunning, clearImages)) || false);
+        }, []),
+        // Direct state setters (for React compatibility)
+        setInputText: setInputTextDirect,
+        setCursorPosition: setCursorPositionDirect,
+        // Manager reference for advanced usage
+        manager: managerRef.current,
+    };
+};

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,wBAAsB,IAAI,kBA+EzB;AAGD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,wBAAsB,IAAI,kBAyFzB;AAGD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGpC,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAG3C,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,KAAK,oBAAoB,GAC1B,MAAM,sBAAsB,CAAC"}

package/dist/index.js

@@ -1,7 +1,7 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { startCli } from "./cli.js";
-import { listSessions } from "wave-agent-sdk";
+import { listSessions, getSessionFilePath } from "wave-agent-sdk";
 // Export main function for external use
 export async function main() {
     const argv = await yargs(hideBin(process.argv))
@@ -15,10 +15,14 @@ export async function main() {
         description: "Continue from last session",
         type: "boolean",
     })
-        .option("plain", {
+        .option("print", {
         alias: "p",
-        description: "Plain mode with message to send",
+        description: "Print response without interactive mode",
         type: "string",
+    })
+        .option("show-stats", {
+        description: "Show timing and usage statistics in print mode",
+        type: "boolean",
     })
         .option("list-sessions", {
         description: "List all available sessions",
@@ -29,8 +33,8 @@ export async function main() {
         .example("$0", "Start CLI with default settings")
         .example("$0 --restore session_123", "Restore specific session")
         .example("$0 --continue", "Continue from last session")
-        .example("$0 --plain 'Hello'", "Send message in plain mode")
-        .example("$0 -p 'Hello'", "Send message in plain mode (short)")
+        .example("$0 --print 'Hello'", "Send message in print mode")
+        .example("$0 -p 'Hello' --show-stats", "Send message in print mode with statistics")
         .example("$0 --list-sessions", "List all available sessions")
         .help("h")
         .parseAsync();
@@ -48,8 +52,10 @@ export async function main() {
             for (const session of sessions) {
                 const startedAt = new Date(session.startedAt).toLocaleString();
                 const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
+                const filePath = await getSessionFilePath(session.id, session.workdir);
                 console.log(`ID: ${session.id}`);
                 console.log(`  Workdir: ${session.workdir}`);
+                console.log(`  File Path: ${filePath}`);
                 console.log(`  Started: ${startedAt}`);
                 console.log(`  Last Active: ${lastActiveAt}`);
                 console.log(`  Last Message Tokens: ${session.latestTotalTokens}`);
@@ -62,13 +68,14 @@ export async function main() {
             process.exit(1);
         }
     }
-    // Handle plain mode directly
-    if (argv.plain !== undefined) {
-        const { startPlainCli } = await import("./plain-cli.js");
-        return startPlainCli({
+    // Handle print mode directly
+    if (argv.print !== undefined) {
+        const { startPrintCli } = await import("./print-cli.js");
+        return startPrintCli({
             restoreSessionId: argv.restore,
             continueLastSession: argv.continue,
-            message: argv.plain,
+            message: argv.print,
+            showStats: argv.showStats,
         });
     }
     await startCli({