wave-code 0.0.2

package/dist/components/MemoryDisplay.js

@@ -0,0 +1,25 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+export const MemoryDisplay = ({ block }) => {
+    const { content, isSuccess, memoryType, storagePath } = block;
+    const getStatusIcon = () => {
+        return isSuccess ? "💾" : "⚠️";
+    };
+    const getStatusColor = () => {
+        return isSuccess ? "green" : "red";
+    };
+    const getStatusText = () => {
+        return isSuccess ? "Added to memory" : "Failed to add memory";
+    };
+    const getStorageText = () => {
+        if (!isSuccess)
+            return null;
+        if (memoryType === "user") {
+            return `Memory saved to ${storagePath || "user-memory.md"}`;
+        }
+        else {
+            return `Memory saved to ${storagePath || "WAVE.md"}`;
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: getStatusColor(), children: [getStatusIcon(), " "] }), _jsx(Text, { color: getStatusColor(), children: getStatusText() })] }), content && (_jsx(Box, { marginTop: 1, paddingLeft: 2, children: _jsx(Box, { borderLeft: true, borderColor: isSuccess ? "green" : "red", paddingLeft: 1, children: _jsx(Text, { color: "gray", children: content }) }) })), isSuccess && (_jsx(Box, { paddingLeft: 2, marginTop: 1, children: _jsx(Text, { color: "yellow", dimColor: true, children: getStorageText() }) }))] }));
+};

package/dist/components/MemoryTypeSelector.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+export interface MemoryTypeSelectorProps {
+    message: string;
+    onSelect: (type: "project" | "user") => void;
+    onCancel: () => void;
+}
+export declare const MemoryTypeSelector: React.FC<MemoryTypeSelectorProps>;
+//# sourceMappingURL=MemoryTypeSelector.d.ts.map

package/dist/components/MemoryTypeSelector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryTypeSelector.d.ts","sourceRoot":"","sources":["../../src/components/MemoryTypeSelector.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAGxC,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,IAAI,CAAC;IAC7C,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,kBAAkB,EAAE,KAAK,CAAC,EAAE,CAAC,uBAAuB,CAsFhE,CAAC"}

package/dist/components/MemoryTypeSelector.js

@@ -0,0 +1,38 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+export const MemoryTypeSelector = ({ message, onSelect, onCancel, }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const options = [
+        {
+            type: "project",
+            label: "Project Memory",
+            description: "Save to current project (WAVE.md)",
+        },
+        {
+            type: "user",
+            label: "User Memory",
+            description: "Save to user global memory",
+        },
+    ];
+    useInput((input, key) => {
+        if (key.return) {
+            const selectedOption = options[selectedIndex];
+            onSelect(selectedOption.type);
+            return;
+        }
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(Math.max(0, selectedIndex - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex(Math.min(options.length - 1, selectedIndex + 1));
+            return;
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "green", padding: 1, gap: 1, marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: "green", bold: true, children: ["Save Memory: \"", message.substring(1).trim(), "\""] }) }), _jsx(Text, { color: "gray", children: "Choose where to save this memory:" }), options.map((option, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: index === selectedIndex ? "black" : "white", backgroundColor: index === selectedIndex ? "green" : undefined, bold: index === selectedIndex, children: option.label }), index === selectedIndex && (_jsx(Box, { marginLeft: 2, children: _jsx(Text, { color: "gray", dimColor: true, children: option.description }) }))] }, option.type))), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: "Use \u2191\u2193 to navigate, Enter to select, Escape to cancel" }) })] }));
+};

package/dist/components/MessageList.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+import type { Message } from "wave-agent-sdk";
+export interface MessageListProps {
+    messages: Message[];
+    isLoading?: boolean;
+    isCommandRunning?: boolean;
+    isCompressing?: boolean;
+    latestTotalTokens?: number;
+    isExpanded?: boolean;
+}
+export declare const MessageList: React.FC<MessageListProps>;
+//# sourceMappingURL=MessageList.d.ts.map

package/dist/components/MessageList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageList.d.ts","sourceRoot":"","sources":["../../src/components/MessageList.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAkG9C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAyGlD,CAAC"}

package/dist/components/MessageList.js

@@ -0,0 +1,36 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Box, Text } from "ink";
+import { DiffViewer } from "./DiffViewer.js";
+import { CommandOutputDisplay } from "./CommandOutputDisplay.js";
+import { ToolResultDisplay } from "./ToolResultDisplay.js";
+import { MemoryDisplay } from "./MemoryDisplay.js";
+import { CompressDisplay } from "./CompressDisplay.js";
+import { usePagination } from "../hooks/usePagination.js";
+// Function to render a single message
+const renderMessageItem = (message, originalIndex, isExpanded, previousMessage) => {
+    const shouldShowHeader = previousMessage?.role !== message.role;
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [shouldShowHeader && (_jsx(Box, { children: _jsxs(Text, { color: message.role === "user" ? "cyan" : "green", bold: true, children: [message.role === "user" ? "👤 You" : "🤖 Assistant", _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "#", originalIndex + 1] })] }) })), _jsx(Box, { marginLeft: 2, flexDirection: "column", gap: 1, marginTop: shouldShowHeader ? 1 : 0, children: message.blocks.map((block, blockIndex) => (_jsxs(Box, { children: [block.type === "text" && block.content.trim() && (_jsx(Box, { children: _jsx(Text, { children: block.content }) })), block.type === "error" && (_jsx(Box, { children: _jsxs(Text, { color: "red", children: ["\u274C Error: ", block.content] }) })), block.type === "diff" && (_jsx(DiffViewer, { block: block, isExpanded: isExpanded })), block.type === "command_output" && (_jsx(CommandOutputDisplay, { block: block, isExpanded: isExpanded })), block.type === "tool" && (_jsx(ToolResultDisplay, { block: block, isExpanded: isExpanded })), block.type === "image" && (_jsxs(Box, { children: [_jsx(Text, { color: "magenta", bold: true, children: "\uD83D\uDCF7 Image" }), block.imageUrls && block.imageUrls.length > 0 && (_jsxs(Text, { color: "gray", dimColor: true, children: [" ", "(", block.imageUrls.length, ")"] }))] })), block.type === "memory" && _jsx(MemoryDisplay, { block: block }), block.type === "compress" && (_jsx(CompressDisplay, { block: block, isExpanded: isExpanded })), block.type === "custom_command" && (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: "\u26A1" }), _jsx(Text, { children: block.originalInput || `/${block.commandName}` })] }))] }, blockIndex))) })] }, `message-${originalIndex}`));
+};
+export const MessageList = ({ messages, isLoading = false, isCommandRunning = false, isCompressing = false, latestTotalTokens = 0, isExpanded = false, }) => {
+    // Use original messages for pagination calculation
+    const { displayInfo } = usePagination(messages);
+    // Get current page messages while preserving original index information
+    const currentMessagesWithIndex = useMemo(() => {
+        return messages
+            .slice(displayInfo.startIndex, displayInfo.endIndex)
+            .map((message, index) => ({
+            message,
+            originalIndex: displayInfo.startIndex + index,
+        }));
+    }, [messages, displayInfo.startIndex, displayInfo.endIndex]);
+    // Empty message state
+    if (messages.length === 0) {
+        return (_jsx(Box, { flexDirection: "column", paddingY: 1, children: _jsx(Text, { color: "gray", children: "Welcome to WAVE Code Assistant!" }) }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { flexDirection: "column", children: currentMessagesWithIndex.map(({ message, originalIndex }) => {
+                    // Get previous message
+                    const previousMessage = originalIndex > 0 ? messages[originalIndex - 1] : undefined;
+                    return renderMessageItem(message, originalIndex, isExpanded, previousMessage);
+                }) }), !isExpanded && (isLoading || isCommandRunning || isCompressing) && (_jsxs(Box, { marginTop: 1, flexDirection: "column", gap: 1, children: [isLoading && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "\uD83D\uDCAD AI is thinking... " }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "|", " "] }), _jsx(Text, { color: "blue", bold: true, children: latestTotalTokens.toLocaleString() }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "tokens |", " "] }), _jsx(Text, { color: "red", bold: true, children: "Esc" }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "to abort"] })] })), isCommandRunning && (_jsx(Text, { color: "blue", children: "\uD83D\uDE80 Command is running..." })), isCompressing && (_jsx(Text, { color: "magenta", children: "\uD83D\uDDDC\uFE0F Compressing message history..." }))] })), messages.length > 0 && (_jsx(Box, { marginTop: 1, children: _jsxs(Box, { justifyContent: "space-between", width: "100%", children: [_jsxs(Box, { children: [_jsxs(Text, { color: "gray", children: ["Messages ", messages.length, " Page ", displayInfo.currentPage, "/", displayInfo.totalPages] }), _jsxs(Text, { color: "gray", dimColor: true, children: [" ", "\u2190 ", _jsx(Text, { color: "cyan", children: "Ctrl+U/D" }), " Navigate"] })] }), _jsxs(Text, { color: "gray", dimColor: true, children: [_jsx(Text, { color: "cyan", children: "Ctrl+O" }), " Toggle", " ", isExpanded ? "Collapse" : "Expand"] })] }) }))] }));
+};

package/dist/components/ToolResultDisplay.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+import type { ToolBlock } from "wave-agent-sdk";
+interface ToolResultDisplayProps {
+    block: ToolBlock;
+    isExpanded?: boolean;
+}
+export declare const ToolResultDisplay: React.FC<ToolResultDisplayProps>;
+export {};
+//# sourceMappingURL=ToolResultDisplay.d.ts.map

package/dist/components/ToolResultDisplay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolResultDisplay.d.ts","sourceRoot":"","sources":["../../src/components/ToolResultDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,UAAU,sBAAsB;IAC9B,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAgI9D,CAAC"}

package/dist/components/ToolResultDisplay.js

@@ -0,0 +1,52 @@
+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;
+    // Directly use compactParams
+    // (no change needed as we destructured it above)
+    const getStatusColor = () => {
+        if (isRunning)
+            return "yellow";
+        if (success)
+            return "green";
+        if (error || success === false)
+            return "red";
+        return "gray"; // Unknown state or no state information
+    };
+    const getStatusText = () => {
+        if (isRunning)
+            return "🔄";
+        if (success)
+            return "";
+        if (error || success === false)
+            return "❌ Failed";
+        return ""; // Don't display text for unknown state
+    };
+    const hasImages = () => {
+        return block.images && block.images.length > 0;
+    };
+    const getImageIndicator = () => {
+        if (!hasImages())
+            return "";
+        const imageCount = block.images.length;
+        return imageCount === 1 ? "🖼️" : `🖼️×${imageCount}`;
+    };
+    const toolName = name ? String(name) : "Tool";
+    // Get shortResult, if not available show last 5 lines of result
+    const getShortResult = () => {
+        if (block.shortResult) {
+            return block.shortResult;
+        }
+        // If no shortResult but has result, return last 5 lines
+        if (block.result) {
+            const lines = block.result.split("\n");
+            if (lines.length > 5) {
+                return lines.slice(-5).join("\n");
+            }
+            return block.result;
+        }
+        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)] }) }))] }));
+};

package/dist/contexts/useAppConfig.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+export interface AppConfig {
+    restoreSessionId?: string;
+    continueLastSession?: boolean;
+}
+export declare const useAppConfig: () => AppConfig;
+export interface AppProviderProps extends AppConfig {
+    children: React.ReactNode;
+}
+export declare const AppProvider: React.FC<AppProviderProps>;
+//# sourceMappingURL=useAppConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAppConfig.d.ts","sourceRoot":"","sources":["../../src/contexts/useAppConfig.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAoC,MAAM,OAAO,CAAC;AAEzD,MAAM,WAAW,SAAS;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAID,eAAO,MAAM,YAAY,iBAMxB,CAAC;AAEF,MAAM,WAAW,gBAAiB,SAAQ,SAAS;IACjD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,WAAW,EAAE,KAAK,CAAC,EAAE,CAAC,gBAAgB,CAUlD,CAAC"}

package/dist/contexts/useAppConfig.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const AppContext = createContext(null);
+export const useAppConfig = () => {
+    const context = useContext(AppContext);
+    if (!context) {
+        throw new Error("useAppConfig must be used within AppProvider");
+    }
+    return context;
+};
+export const AppProvider = ({ restoreSessionId, continueLastSession, children, }) => {
+    return (_jsx(AppContext.Provider, { value: { restoreSessionId, continueLastSession }, children: children }));
+};

package/dist/contexts/useChat.d.ts

@@ -0,0 +1,36 @@
+import React from "react";
+import type { Message, McpServerStatus, BackgroundShell, SlashCommand } from "wave-agent-sdk";
+export interface ChatContextType {
+    messages: Message[];
+    isLoading: boolean;
+    isCommandRunning: boolean;
+    isCompressing: boolean;
+    userInputHistory: string[];
+    isExpanded: boolean;
+    sessionId: string;
+    sendMessage: (content: string, images?: Array<{
+        path: string;
+        mimeType: string;
+    }>) => Promise<void>;
+    abortMessage: () => void;
+    latestTotalTokens: number;
+    saveMemory: (message: string, type: "project" | "user") => Promise<void>;
+    mcpServers: McpServerStatus[];
+    connectMcpServer: (serverName: string) => Promise<boolean>;
+    disconnectMcpServer: (serverName: string) => Promise<boolean>;
+    backgroundShells: BackgroundShell[];
+    getBackgroundShellOutput: (shellId: string) => {
+        stdout: string;
+        stderr: string;
+        status: string;
+    } | null;
+    killBackgroundShell: (shellId: string) => boolean;
+    slashCommands: SlashCommand[];
+    hasSlashCommand: (commandId: string) => boolean;
+}
+export declare const useChat: () => ChatContextType;
+export interface ChatProviderProps {
+    children: React.ReactNode;
+}
+export declare const ChatProvider: React.FC<ChatProviderProps>;
+//# sourceMappingURL=useChat.d.ts.map

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

@@ -0,0 +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"}

package/dist/contexts/useChat.js

@@ -0,0 +1,208 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useCallback, useRef, useEffect, useState, } from "react";
+import { useInput } from "ink";
+import { useAppConfig } from "./useAppConfig.js";
+import { Agent } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
+const ChatContext = createContext(null);
+export const useChat = () => {
+    const context = useContext(ChatContext);
+    if (!context) {
+        throw new Error("useChat must be used within ChatProvider");
+    }
+    return context;
+};
+export const ChatProvider = ({ children }) => {
+    const { restoreSessionId, continueLastSession } = useAppConfig();
+    // Message Display State
+    const [isExpanded, setIsExpanded] = useState(false);
+    // AI State
+    const [messages, setMessages] = useState([]);
+    const [isLoading, setIsLoading] = useState(false);
+    const [latestTotalTokens, setlatestTotalTokens] = useState(0);
+    const [sessionId, setSessionId] = useState("");
+    const [isCommandRunning, setIsCommandRunning] = useState(false);
+    const [isCompressing, setIsCompressing] = useState(false);
+    const [userInputHistory, setUserInputHistory] = useState([]);
+    // MCP State
+    const [mcpServers, setMcpServers] = useState([]);
+    // Background bash shells state
+    const [backgroundShells, setBackgroundShells] = useState([]);
+    // Command state
+    const [slashCommands, setSlashCommands] = 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);
+        }
+    });
+    // Initialize AI manager
+    useEffect(() => {
+        const initializeAgent = async () => {
+            const callbacks = {
+                onMessagesChange: (newMessages) => {
+                    setMessages([...newMessages]);
+                },
+                onServersChange: (servers) => {
+                    setMcpServers([...servers]);
+                },
+                onSessionIdChange: (sessionId) => {
+                    setSessionId(sessionId);
+                },
+                onLatestTotalTokensChange: (tokens) => {
+                    setlatestTotalTokens(tokens);
+                },
+                onUserInputHistoryChange: (history) => {
+                    setUserInputHistory([...history]);
+                },
+                onCompressionStateChange: (isCompressingState) => {
+                    setIsCompressing(isCompressingState);
+                },
+                onShellsChange: (shells) => {
+                    setBackgroundShells([...shells]);
+                },
+            };
+            try {
+                const agent = await Agent.create({
+                    callbacks,
+                    restoreSessionId,
+                    continueLastSession,
+                    logger,
+                });
+                agentRef.current = agent;
+                // Get initial state
+                setSessionId(agent.sessionId);
+                setMessages(agent.messages);
+                setIsLoading(agent.isLoading);
+                setlatestTotalTokens(agent.latestTotalTokens);
+                setIsCommandRunning(agent.isCommandRunning);
+                setIsCompressing(agent.isCompressing);
+                setUserInputHistory(agent.userInputHistory);
+                // Get initial MCP servers state
+                const mcpServers = agent.getMcpServers?.() || [];
+                setMcpServers(mcpServers);
+                // Get initial commands
+                const agentSlashCommands = agent.getSlashCommands?.() || [];
+                setSlashCommands(agentSlashCommands);
+            }
+            catch (error) {
+                console.error("Failed to initialize AI manager:", error);
+            }
+        };
+        initializeAgent();
+    }, [restoreSessionId, continueLastSession]);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (agentRef.current) {
+                agentRef.current.destroy();
+            }
+        };
+    }, []);
+    // Send message function (including judgment logic)
+    const sendMessage = useCallback(async (content, images) => {
+        // Check if there's content to send (text content or image attachments)
+        const hasTextContent = content.trim();
+        const hasImageAttachments = images && images.length > 0;
+        if (!hasTextContent && !hasImageAttachments)
+            return;
+        try {
+            // Handle memory mode - check if it's a memory message (starts with # and only one line)
+            if (content.startsWith("#") && !content.includes("\n")) {
+                const memoryText = content.substring(1).trim();
+                if (!memoryText)
+                    return;
+                // In memory mode, don't add user message, only wait for user to choose memory type then add assistant message
+                // Don't auto-save, wait for user to choose memory type
+                return;
+            }
+            // Handle bash mode - check if it's a bash command (starts with ! and only one line)
+            if (content.startsWith("!") && !content.includes("\n")) {
+                const command = content.substring(1).trim();
+                if (!command)
+                    return;
+                // In bash mode, don't add user message to UI, directly execute command
+                // Executing bash command will automatically add assistant message
+                // Set command running state
+                setIsCommandRunning(true);
+                try {
+                    await agentRef.current?.executeBashCommand(command);
+                }
+                finally {
+                    // Clear command running state
+                    setIsCommandRunning(false);
+                }
+                return;
+            }
+            // Handle normal AI message and slash commands
+            // Slash commands are now handled internally in agent.sendMessage
+            // Set loading state
+            setIsLoading(true);
+            try {
+                await agentRef.current?.sendMessage(content, images);
+            }
+            finally {
+                // Clear loading state
+                setIsLoading(false);
+            }
+        }
+        catch (error) {
+            console.error("Failed to send message:", error);
+            // Loading state will be automatically updated by the useEffect that watches messages
+        }
+    }, []);
+    // Unified interrupt method, interrupt both AI messages and command execution
+    const abortMessage = useCallback(() => {
+        agentRef.current?.abortMessage();
+    }, []);
+    // Memory save function - delegate to Agent
+    const saveMemory = useCallback(async (message, type) => {
+        await agentRef.current?.saveMemory(message, type);
+    }, []);
+    // MCP management methods - delegate to Agent
+    const connectMcpServer = useCallback(async (serverName) => {
+        return (await agentRef.current?.connectMcpServer(serverName)) ?? false;
+    }, []);
+    const disconnectMcpServer = useCallback(async (serverName) => {
+        return (await agentRef.current?.disconnectMcpServer(serverName)) ?? false;
+    }, []);
+    // Background bash management methods - delegate to Agent
+    const getBackgroundShellOutput = useCallback((shellId) => {
+        if (!agentRef.current)
+            return null;
+        return agentRef.current.getBackgroundShellOutput(shellId);
+    }, []);
+    const killBackgroundShell = useCallback((shellId) => {
+        if (!agentRef.current)
+            return false;
+        return agentRef.current.killBackgroundShell(shellId);
+    }, []);
+    const hasSlashCommand = useCallback((commandId) => {
+        if (!agentRef.current)
+            return false;
+        return agentRef.current.hasSlashCommand(commandId);
+    }, []);
+    const contextValue = {
+        messages,
+        isLoading,
+        isCommandRunning,
+        userInputHistory,
+        isExpanded,
+        sessionId,
+        sendMessage,
+        abortMessage,
+        latestTotalTokens,
+        isCompressing,
+        saveMemory,
+        mcpServers,
+        connectMcpServer,
+        disconnectMcpServer,
+        backgroundShells,
+        getBackgroundShellOutput,
+        killBackgroundShell,
+        slashCommands,
+        hasSlashCommand,
+    };
+    return (_jsx(ChatContext.Provider, { value: contextValue, children: children }));
+};

package/dist/hooks/useBashHistorySelector.d.ts

@@ -0,0 +1,15 @@
+export declare const useBashHistorySelector: () => {
+    showBashHistorySelector: boolean;
+    bashHistorySearchQuery: string;
+    activateBashHistorySelector: (position: number) => void;
+    handleBashHistorySelect: (command: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleBashHistoryExecute: (command: string) => string;
+    handleCancelBashHistorySelect: () => void;
+    updateBashHistorySearchQuery: (query: string) => void;
+    checkForExclamationDeletion: (cursorPosition: number) => boolean;
+    exclamationPosition: number;
+};
+//# sourceMappingURL=useBashHistorySelector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useBashHistorySelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useBashHistorySelector.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB;;;4CAK0B,MAAM;uCAOrD,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;wCAyBN,MAAM;;0CAOJ,MAAM;kDAK5C,MAAM;;CAyB1B,CAAC"}

package/dist/hooks/useBashHistorySelector.js

@@ -0,0 +1,61 @@
+import { useState, useCallback } from "react";
+export const useBashHistorySelector = () => {
+    const [showBashHistorySelector, setShowBashHistorySelector] = useState(false);
+    const [exclamationPosition, setExclamationPosition] = useState(-1);
+    const [bashHistorySearchQuery, setBashHistorySearchQuery] = useState("");
+    const activateBashHistorySelector = useCallback((position) => {
+        setShowBashHistorySelector(true);
+        setExclamationPosition(position);
+        setBashHistorySearchQuery("");
+    }, []);
+    const handleBashHistorySelect = useCallback((command, inputText, cursorPosition) => {
+        if (exclamationPosition >= 0) {
+            // Replace ! and search query with selected command
+            const beforeExclamation = inputText.substring(0, exclamationPosition);
+            const afterQuery = inputText.substring(cursorPosition);
+            const newInput = beforeExclamation + `!${command}` + afterQuery;
+            const newCursorPosition = beforeExclamation.length + command.length + 1;
+            setShowBashHistorySelector(false);
+            setExclamationPosition(-1);
+            setBashHistorySearchQuery("");
+            return { newInput, newCursorPosition };
+        }
+        return { newInput: inputText, newCursorPosition: cursorPosition };
+    }, [exclamationPosition]);
+    const handleCancelBashHistorySelect = useCallback(() => {
+        setShowBashHistorySelector(false);
+        setExclamationPosition(-1);
+        setBashHistorySearchQuery("");
+    }, []);
+    const handleBashHistoryExecute = useCallback((command) => {
+        setShowBashHistorySelector(false);
+        setExclamationPosition(-1);
+        setBashHistorySearchQuery("");
+        return command; // Return command to execute
+    }, []);
+    const updateBashHistorySearchQuery = useCallback((query) => {
+        setBashHistorySearchQuery(query);
+    }, []);
+    const checkForExclamationDeletion = useCallback((cursorPosition) => {
+        if (showBashHistorySelector && cursorPosition <= exclamationPosition) {
+            handleCancelBashHistorySelect();
+            return true;
+        }
+        return false;
+    }, [
+        showBashHistorySelector,
+        exclamationPosition,
+        handleCancelBashHistorySelect,
+    ]);
+    return {
+        showBashHistorySelector,
+        bashHistorySearchQuery,
+        activateBashHistorySelector,
+        handleBashHistorySelect,
+        handleBashHistoryExecute,
+        handleCancelBashHistorySelect,
+        updateBashHistorySearchQuery,
+        checkForExclamationDeletion,
+        exclamationPosition,
+    };
+};

package/dist/hooks/useCommandSelector.d.ts

@@ -0,0 +1,24 @@
+export interface UseCommandSelectorParams {
+    onShowBashManager?: () => void;
+    onShowMcpManager?: () => void;
+    sendMessage?: (content: string) => Promise<void>;
+    hasSlashCommand?: (commandId: string) => boolean;
+}
+export declare const useCommandSelector: ({ onShowBashManager, onShowMcpManager, sendMessage, hasSlashCommand, }: UseCommandSelectorParams) => {
+    showCommandSelector: boolean;
+    commandSearchQuery: string;
+    activateCommandSelector: (position: number) => void;
+    handleCommandSelect: (command: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCommandInsert: (command: string, inputText: string, cursorPosition: number) => {
+        newInput: string;
+        newCursorPosition: number;
+    };
+    handleCancelCommandSelect: () => void;
+    updateCommandSearchQuery: (query: string) => void;
+    checkForSlashDeletion: (cursorPosition: number) => boolean;
+    slashPosition: number;
+};
+//# sourceMappingURL=useCommandSelector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useCommandSelector.d.ts","sourceRoot":"","sources":["../../src/hooks/useCommandSelector.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,wBAAwB;IACvC,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,gBAAgB,CAAC,EAAE,MAAM,IAAI,CAAC;IAC9B,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACjD,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CAClD;AAED,eAAO,MAAM,kBAAkB,GAAI,wEAKhC,wBAAwB;;;wCAK8B,MAAM;mCA2BjD,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;mCApBjD,MAAM,aAAa,MAAM,kBAAkB,MAAM;;;;;sCA8ER,MAAM;4CAKxC,MAAM;;CAqB1B,CAAC"}