wave-code 0.0.2

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

@@ -0,0 +1 @@
+{"version":3,"file":"CompressDisplay.d.ts","sourceRoot":"","sources":["../../src/components/CompressDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAEvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAEpD,UAAU,oBAAoB;IAC5B,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAgD1D,CAAC"}

package/dist/components/CompressDisplay.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Box, Text } from "ink";
+export const CompressDisplay = ({ block, isExpanded = false, }) => {
+    const { content } = block;
+    const MAX_LINES = 3; // Set maximum display lines for compressed content
+    const { displayContent, isOverflowing } = useMemo(() => {
+        if (!content) {
+            return { displayContent: "", isOverflowing: false };
+        }
+        const lines = content.split("\n");
+        const overflow = !isExpanded && lines.length > MAX_LINES;
+        const display = overflow ? lines.slice(0, MAX_LINES).join("\n") : content;
+        return { displayContent: display, isOverflowing: overflow };
+    }, [content, isExpanded]);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { children: _jsx(Text, { children: "\uD83D\uDCE6 Compressed Messages" }) }), content && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Box, { paddingLeft: 2, borderLeft: true, borderColor: "gray", flexDirection: "column", children: _jsx(Text, { color: "white", children: displayContent }) }), isOverflowing && (_jsx(Box, { paddingLeft: 2, marginTop: 1, children: _jsxs(Text, { color: "yellow", dimColor: true, children: ["Content truncated (", content.split("\n").length, " lines total, showing first ", MAX_LINES, " lines. Press Ctrl+O to expand."] }) }))] }))] }));
+};

package/dist/components/DiffViewer.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DiffViewer.d.ts","sourceRoot":"","sources":["../../src/components/DiffViewer.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAC;AAGvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,UAAU,eAAe;IACvB,KAAK,EAAE,SAAS,CAAC;IACjB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAwCD,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CAgRhD,CAAC"}

package/dist/components/DiffViewer.js

@@ -0,0 +1,221 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { Text, Box } from "ink";
+import { diffWords } from "diff";
+// Render word-level diff
+const renderWordLevelDiff = (removedLine, addedLine) => {
+    const changes = diffWords(removedLine, addedLine);
+    const removedParts = [];
+    const addedParts = [];
+    changes.forEach((part, index) => {
+        if (part.removed) {
+            removedParts.push(_jsx(Text, { color: "black", backgroundColor: "red", children: part.value }, `removed-${index}`));
+        }
+        else if (part.added) {
+            addedParts.push(_jsx(Text, { color: "black", backgroundColor: "green", children: part.value }, `added-${index}`));
+        }
+        else {
+            // Unchanged parts, need to display on both sides
+            removedParts.push(_jsx(Text, { color: "red", children: part.value }, `removed-unchanged-${index}`));
+            addedParts.push(_jsx(Text, { color: "green", children: part.value }, `added-unchanged-${index}`));
+        }
+    });
+    return { removedParts, addedParts };
+};
+export const DiffViewer = ({ block, isExpanded = false, }) => {
+    const { diffResult } = block;
+    const diffLines = useMemo(() => {
+        if (!diffResult)
+            return [];
+        const lines = [];
+        let originalLineNum = 1;
+        let modifiedLineNum = 1;
+        const maxContext = 3; // Show at most 3 lines of context
+        // Buffer for storing context
+        let contextBuffer = [];
+        let hasAnyChanges = false;
+        let afterChangeContext = 0;
+        // Temporarily store adjacent deleted and added lines for word-level comparison
+        let pendingRemovedLines = [];
+        const flushPendingLines = () => {
+            pendingRemovedLines.forEach((line) => {
+                lines.push({
+                    content: line.content,
+                    type: "removed",
+                    lineNumber: line.lineNumber,
+                    rawContent: line.rawContent,
+                });
+            });
+            pendingRemovedLines = [];
+        };
+        diffResult.forEach((part) => {
+            const partLines = part.value.split("\n");
+            // Remove the last empty line (produced by split)
+            if (partLines[partLines.length - 1] === "") {
+                partLines.pop();
+            }
+            if (part.removed) {
+                // If this is the first change encountered, add preceding context
+                if (!hasAnyChanges) {
+                    // Take the last few lines from the buffer as preceding context
+                    const preContext = contextBuffer.slice(-maxContext);
+                    if (contextBuffer.length > maxContext) {
+                        lines.push({
+                            content: "...",
+                            type: "separator",
+                        });
+                    }
+                    lines.push(...preContext);
+                }
+                else if (afterChangeContext > maxContext) {
+                    // If there's too much context after the previous change, add a separator
+                    lines.push({
+                        content: "...",
+                        type: "separator",
+                    });
+                }
+                // Temporarily store deleted lines, waiting for possible added lines for word-level comparison
+                partLines.forEach((line) => {
+                    pendingRemovedLines.push({
+                        content: `- ${line}`,
+                        rawContent: line,
+                        lineNumber: originalLineNum++,
+                    });
+                });
+                hasAnyChanges = true;
+                afterChangeContext = 0;
+                contextBuffer = []; // Clear buffer
+            }
+            else if (part.added) {
+                // If this is the first change encountered, add preceding context
+                if (!hasAnyChanges) {
+                    const preContext = contextBuffer.slice(-maxContext);
+                    if (contextBuffer.length > maxContext) {
+                        lines.push({
+                            content: "...",
+                            type: "separator",
+                        });
+                    }
+                    lines.push(...preContext);
+                }
+                else if (afterChangeContext > maxContext) {
+                    lines.push({
+                        content: "...",
+                        type: "separator",
+                    });
+                }
+                // Process added lines, try to do word-level comparison with pending deleted lines
+                partLines.forEach((line, index) => {
+                    if (index < pendingRemovedLines.length) {
+                        // Has corresponding deleted line, perform word-level comparison
+                        const removedLine = pendingRemovedLines[index];
+                        const wordDiff = renderWordLevelDiff(removedLine.rawContent, line);
+                        // Add deleted line (with word-level highlighting)
+                        lines.push({
+                            content: `- ${removedLine.rawContent}`,
+                            type: "removed",
+                            lineNumber: removedLine.lineNumber,
+                            rawContent: removedLine.rawContent,
+                            wordDiff: {
+                                removedParts: wordDiff.removedParts,
+                                addedParts: [],
+                            },
+                        });
+                        // Add added line (with word-level highlighting)
+                        lines.push({
+                            content: `+ ${line}`,
+                            type: "added",
+                            lineNumber: modifiedLineNum++,
+                            rawContent: line,
+                            wordDiff: { removedParts: [], addedParts: wordDiff.addedParts },
+                        });
+                    }
+                    else {
+                        // No corresponding deleted line, directly add the added line
+                        lines.push({
+                            content: `+ ${line}`,
+                            type: "added",
+                            lineNumber: modifiedLineNum++,
+                            rawContent: line,
+                        });
+                    }
+                });
+                // If there are more deleted lines than added lines, add remaining deleted lines
+                for (let i = partLines.length; i < pendingRemovedLines.length; i++) {
+                    const removedLine = pendingRemovedLines[i];
+                    lines.push({
+                        content: removedLine.content,
+                        type: "removed",
+                        lineNumber: removedLine.lineNumber,
+                        rawContent: removedLine.rawContent,
+                    });
+                }
+                pendingRemovedLines = []; // Clear pending deleted lines
+                hasAnyChanges = true;
+                afterChangeContext = 0;
+                contextBuffer = [];
+            }
+            else {
+                // Before processing unchanged lines, first clear pending deleted lines
+                flushPendingLines();
+                // Process unchanged lines
+                partLines.forEach((line) => {
+                    const contextLine = {
+                        content: `  ${line}`,
+                        type: "unchanged",
+                        lineNumber: originalLineNum,
+                    };
+                    if (hasAnyChanges) {
+                        // If there are already changes, these are post-change context
+                        if (afterChangeContext < maxContext) {
+                            lines.push(contextLine);
+                            afterChangeContext++;
+                        }
+                    }
+                    else {
+                        // If no changes yet, add to buffer
+                        contextBuffer.push(contextLine);
+                    }
+                    originalLineNum++;
+                    modifiedLineNum++;
+                });
+            }
+        });
+        // Handle remaining deleted lines at the end
+        flushPendingLines();
+        // Only limit displayed lines in collapsed state
+        if (!isExpanded) {
+            const MAX_DISPLAY_LINES = 50;
+            if (lines.length > MAX_DISPLAY_LINES) {
+                const truncatedLines = lines.slice(0, MAX_DISPLAY_LINES);
+                truncatedLines.push({
+                    content: `... (${lines.length - MAX_DISPLAY_LINES} more lines truncated, press Ctrl+O to expand)`,
+                    type: "separator",
+                });
+                return truncatedLines;
+            }
+        }
+        return lines;
+    }, [diffResult, isExpanded]);
+    if (!diffResult || diffResult.length === 0) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { color: "gray", children: "No changes detected" }) }));
+    }
+    return (_jsx(Box, { flexDirection: "column", children: _jsx(Box, { flexDirection: "column", children: _jsx(Box, { flexDirection: "column", children: diffLines.map((line, index) => {
+                    // If has word-level diff, render special effects
+                    if (line.wordDiff) {
+                        const prefix = line.type === "removed" ? "- " : "+ ";
+                        const parts = line.type === "removed"
+                            ? line.wordDiff.removedParts
+                            : line.wordDiff.addedParts;
+                        return (_jsxs(Box, { flexDirection: "row", children: [_jsx(Text, { color: line.type === "removed" ? "red" : "green", children: prefix }), _jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: parts })] }, index));
+                    }
+                    // Normal rendering
+                    return (_jsx(Text, { color: line.type === "added"
+                            ? "green"
+                            : line.type === "removed"
+                                ? "red"
+                                : line.type === "separator"
+                                    ? "gray"
+                                    : "white", dimColor: line.type === "separator", children: line.content }, index));
+                }) }) }) }));
+};

package/dist/components/FileSelector.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export interface FileItem {
+    path: string;
+    type: "file" | "directory";
+}
+export interface FileSelectorProps {
+    files: FileItem[];
+    searchQuery: string;
+    onSelect: (filePath: string) => void;
+    onCancel: () => void;
+}
+export declare const FileSelector: React.FC<FileSelectorProps>;
+//# sourceMappingURL=FileSelector.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FileSelector.d.ts","sourceRoot":"","sources":["../../src/components/FileSelector.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAGxC,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CAC5B;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAED,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,iBAAiB,CAyHpD,CAAC"}

package/dist/components/FileSelector.js

@@ -0,0 +1,48 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+export const FileSelector = ({ files, searchQuery, onSelect, onCancel, }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    useInput((input, key) => {
+        if (key.return) {
+            if (files.length > 0 && selectedIndex < files.length) {
+                onSelect(files[selectedIndex].path);
+            }
+            return;
+        }
+        if (key.escape) {
+            onCancel();
+            return;
+        }
+        if (key.upArrow) {
+            setSelectedIndex(Math.max(0, selectedIndex - 1));
+            return;
+        }
+        if (key.downArrow) {
+            setSelectedIndex(Math.min(files.length - 1, selectedIndex + 1));
+            return;
+        }
+    });
+    if (files.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "yellow", padding: 1, marginBottom: 1, children: [_jsxs(Text, { color: "yellow", children: ["\uD83D\uDCC1 No files found for \"", searchQuery, "\""] }), _jsx(Text, { dimColor: true, children: "Press Escape to cancel" })] }));
+    }
+    const maxDisplay = 10;
+    // Calculate display window start and end positions
+    const getDisplayWindow = () => {
+        const startIndex = Math.max(0, Math.min(selectedIndex - Math.floor(maxDisplay / 2), files.length - maxDisplay));
+        const endIndex = Math.min(files.length, startIndex + maxDisplay);
+        const adjustedStartIndex = Math.max(0, endIndex - maxDisplay);
+        return {
+            startIndex: adjustedStartIndex,
+            endIndex: endIndex,
+            displayFiles: files.slice(adjustedStartIndex, endIndex),
+        };
+    };
+    const { startIndex, endIndex, displayFiles } = getDisplayWindow();
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", padding: 1, marginBottom: 1, children: [_jsxs(Text, { color: "cyan", bold: true, children: ["\uD83D\uDCC1 Select File/Directory", " ", searchQuery && `(filtering: "${searchQuery}")`] }), startIndex > 0 && (_jsxs(Text, { dimColor: true, children: ["... ", startIndex, " more files above"] })), displayFiles.map((fileItem, displayIndex) => {
+                const actualIndex = startIndex + displayIndex;
+                const isSelected = actualIndex === selectedIndex;
+                const icon = fileItem.type === "directory" ? "📁" : "📄";
+                return (_jsx(Box, { children: _jsxs(Text, { color: isSelected ? "black" : "white", backgroundColor: isSelected ? "cyan" : undefined, children: [isSelected ? "▶ " : "  ", icon, " ", fileItem.path] }) }, fileItem.path));
+            }), endIndex < files.length && (_jsxs(Text, { dimColor: true, children: ["... ", files.length - endIndex, " more files below"] })), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "Use \u2191\u2193 to navigate, Enter to select, Escape to cancel" }), _jsxs(Text, { dimColor: true, children: ["File ", selectedIndex + 1, " of ", files.length] })] })] }));
+};

package/dist/components/InputBox.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import type { McpServerStatus, SlashCommand } from "wave-agent-sdk";
+export declare const INPUT_PLACEHOLDER_TEXT = "Type your message (use @ to reference files, / for commands, ! for bash history, # to add memory)...";
+export declare const INPUT_PLACEHOLDER_TEXT_PREFIX: string;
+export interface InputBoxProps {
+    isLoading?: boolean;
+    isCommandRunning?: boolean;
+    workdir?: string;
+    userInputHistory?: string[];
+    sendMessage?: (message: string, images?: Array<{
+        path: string;
+        mimeType: string;
+    }>) => void;
+    abortMessage?: () => void;
+    saveMemory?: (message: string, type: "project" | "user") => Promise<void>;
+    mcpServers?: McpServerStatus[];
+    connectMcpServer?: (serverName: string) => Promise<boolean>;
+    disconnectMcpServer?: (serverName: string) => Promise<boolean>;
+    slashCommands?: SlashCommand[];
+    hasSlashCommand?: (commandId: string) => boolean;
+}
+export declare const InputBox: React.FC<InputBoxProps>;
+//# sourceMappingURL=InputBox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InputBox.d.ts","sourceRoot":"","sources":["../../src/components/InputBox.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAgC,MAAM,OAAO,CAAC;AAgBrD,OAAO,KAAK,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEpE,eAAO,MAAM,sBAAsB,yGACqE,CAAC;AAEzG,eAAO,MAAM,6BAA6B,QAGzC,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,CAAC,EAAE,CACZ,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,KAC/C,IAAI,CAAC;IACV,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;IAC1B,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1E,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;IAC/B,gBAAgB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5D,mBAAmB,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAE/D,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;IAC/B,eAAe,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC;CAClD;AAED,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAuQ5C,CAAC"}

package/dist/components/InputBox.js

@@ -0,0 +1,124 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text } from "ink";
+import { FileSelector } from "./FileSelector.js";
+import { CommandSelector } from "./CommandSelector.js";
+import { BashHistorySelector } from "./BashHistorySelector.js";
+import { MemoryTypeSelector } from "./MemoryTypeSelector.js";
+import { BashShellManager } from "./BashShellManager.js";
+import { McpManager } from "./McpManager.js";
+import { useInputState } from "../hooks/useInputState.js";
+import { useFileSelector } from "../hooks/useFileSelector.js";
+import { useCommandSelector } from "../hooks/useCommandSelector.js";
+import { useBashHistorySelector } from "../hooks/useBashHistorySelector.js";
+import { useMemoryTypeSelector } from "../hooks/useMemoryTypeSelector.js";
+import { useInputHistory } from "../hooks/useInputHistory.js";
+import { useInputKeyboardHandler } from "../hooks/useInputKeyboardHandler.js";
+import { useImageManager } from "../hooks/useImageManager.js";
+export const INPUT_PLACEHOLDER_TEXT = "Type your message (use @ to reference files, / for commands, ! for bash history, # to add memory)...";
+export const INPUT_PLACEHOLDER_TEXT_PREFIX = INPUT_PLACEHOLDER_TEXT.substring(0, 10);
+export const InputBox = ({ isLoading = false, isCommandRunning = false, workdir, userInputHistory = [], sendMessage = () => { }, abortMessage = () => { }, saveMemory = async () => { }, mcpServers = [], connectMcpServer = async () => false, disconnectMcpServer = async () => false, slashCommands = [], hasSlashCommand = () => false, }) => {
+    // Get current working directory
+    const currentWorkdir = workdir || process.cwd();
+    // Bash shell manager state
+    const [showBashManager, setShowBashManager] = useState(false);
+    // MCP manager state
+    const [showMcpManager, setShowMcpManager] = useState(false);
+    // Basic input state
+    const { inputText, setInputText, cursorPosition, setCursorPosition, insertTextAtCursor, deleteCharAtCursor, clearInput, moveCursorLeft, moveCursorRight, moveCursorToStart, moveCursorToEnd, } = useInputState();
+    // File selector functionality
+    const { showFileSelector, filteredFiles, searchQuery, activateFileSelector, handleFileSelect: handleFileSelectorSelect, handleCancelFileSelect, updateSearchQuery, checkForAtDeletion, atPosition, } = useFileSelector();
+    // Command selector functionality
+    const { showCommandSelector, commandSearchQuery, activateCommandSelector, handleCommandSelect: handleCommandSelectorSelect, handleCommandInsert: handleCommandSelectorInsert, handleCancelCommandSelect, updateCommandSearchQuery, checkForSlashDeletion, slashPosition, } = useCommandSelector({
+        onShowBashManager: () => setShowBashManager(true),
+        onShowMcpManager: () => setShowMcpManager(true),
+        sendMessage: async (content) => {
+            await sendMessage(content);
+        },
+        hasSlashCommand,
+    });
+    // Bash history selector functionality
+    const { showBashHistorySelector, bashHistorySearchQuery, activateBashHistorySelector, handleBashHistorySelect: handleBashHistorySelectorSelect, handleBashHistoryExecute, handleCancelBashHistorySelect, updateBashHistorySearchQuery, checkForExclamationDeletion, exclamationPosition, } = useBashHistorySelector();
+    // Memory type selector functionality
+    const { showMemoryTypeSelector, memoryMessage, activateMemoryTypeSelector, handleMemoryTypeSelect: handleMemoryTypeSelectorSelect, handleCancelMemoryTypeSelect, } = useMemoryTypeSelector();
+    // Input history functionality
+    const { resetHistoryNavigation, navigateHistory } = useInputHistory({
+        userInputHistory,
+    });
+    // Image management functionality (includes clipboard paste)
+    const { attachedImages, clearImages, handlePasteImage } = useImageManager(insertTextAtCursor);
+    // Keyboard handling
+    const { handleFileSelect, handleCommandSelect, handleBashHistorySelect, handleBashHistoryExecute: keyboardHandleBashHistoryExecute, handleMemoryTypeSelect, } = useInputKeyboardHandler({
+        inputText,
+        setInputText,
+        cursorPosition,
+        setCursorPosition,
+        moveCursorLeft,
+        moveCursorRight,
+        moveCursorToStart,
+        moveCursorToEnd,
+        deleteCharAtCursor,
+        insertTextAtCursor,
+        clearInput,
+        resetHistoryNavigation,
+        navigateHistory,
+        handlePasteImage,
+        attachedImages,
+        clearImages,
+        showFileSelector,
+        activateFileSelector,
+        handleFileSelect: handleFileSelectorSelect,
+        handleCancelFileSelect,
+        updateSearchQuery,
+        checkForAtDeletion,
+        atPosition,
+        showCommandSelector,
+        activateCommandSelector,
+        handleCommandSelect: handleCommandSelectorSelect,
+        handleCommandInsert: handleCommandSelectorInsert,
+        handleCancelCommandSelect,
+        updateCommandSearchQuery,
+        checkForSlashDeletion,
+        slashPosition,
+        showBashHistorySelector,
+        activateBashHistorySelector,
+        handleBashHistorySelect: handleBashHistorySelectorSelect,
+        handleBashHistoryExecute,
+        handleCancelBashHistorySelect,
+        updateBashHistorySearchQuery,
+        checkForExclamationDeletion,
+        exclamationPosition,
+        showMemoryTypeSelector,
+        activateMemoryTypeSelector,
+        handleMemoryTypeSelect: handleMemoryTypeSelectorSelect,
+        showBashManager,
+        showMcpManager,
+        isCommandRunning,
+        isLoading,
+        sendMessage,
+        abortMessage,
+        saveMemory,
+    });
+    const isPlaceholder = !inputText;
+    const placeholderText = INPUT_PLACEHOLDER_TEXT;
+    // Create adapter function for CommandSelector
+    const handleCommandInsert = useCallback((command) => {
+        const result = handleCommandSelectorInsert(command, inputText, cursorPosition);
+        setInputText(result.newInput);
+        setCursorPosition(result.newCursorPosition);
+    }, [
+        handleCommandSelectorInsert,
+        inputText,
+        cursorPosition,
+        setInputText,
+        setCursorPosition,
+    ]);
+    // Split text into three parts: before cursor, cursor position, after cursor
+    const displayText = isPlaceholder ? placeholderText : inputText;
+    const beforeCursor = displayText.substring(0, cursorPosition);
+    const atCursor = cursorPosition < displayText.length ? displayText[cursorPosition] : " ";
+    const afterCursor = displayText.substring(cursorPosition + 1);
+    // Always show cursor, allow user to continue input during loading
+    const shouldShowCursor = true;
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", children: [showFileSelector && (_jsx(FileSelector, { files: filteredFiles, searchQuery: searchQuery, onSelect: handleFileSelect, onCancel: handleCancelFileSelect })), showCommandSelector && (_jsx(CommandSelector, { searchQuery: commandSearchQuery, onSelect: handleCommandSelect, onInsert: handleCommandInsert, onCancel: handleCancelCommandSelect, commands: slashCommands })), showBashHistorySelector && (_jsx(BashHistorySelector, { searchQuery: bashHistorySearchQuery, workdir: currentWorkdir, onSelect: handleBashHistorySelect, onExecute: keyboardHandleBashHistoryExecute, onCancel: handleCancelBashHistorySelect })), showMemoryTypeSelector && (_jsx(MemoryTypeSelector, { message: memoryMessage, onSelect: handleMemoryTypeSelect, onCancel: handleCancelMemoryTypeSelect })), showBashManager && (_jsx(BashShellManager, { onCancel: () => setShowBashManager(false) })), showMcpManager && (_jsx(McpManager, { onCancel: () => setShowMcpManager(false), servers: mcpServers, onConnectServer: connectMcpServer, onDisconnectServer: disconnectMcpServer })), showBashManager || showMcpManager || (_jsx(Box, { borderStyle: "single", borderColor: "gray", paddingX: 1, children: _jsx(Box, { width: "100%", flexDirection: "row", justifyContent: "space-between", children: _jsx(Text, { color: isPlaceholder ? "gray" : "white", children: shouldShowCursor ? (_jsxs(_Fragment, { children: [beforeCursor, _jsx(Text, { backgroundColor: "white", color: "black", children: atCursor }), afterCursor] })) : (displayText) }) }) }))] }));
+};

package/dist/components/McpManager.d.ts

@@ -0,0 +1,10 @@
+import React from "react";
+import { McpServerStatus } from "wave-agent-sdk";
+export interface McpManagerProps {
+    onCancel: () => void;
+    servers: McpServerStatus[];
+    onConnectServer: (serverName: string) => Promise<boolean>;
+    onDisconnectServer: (serverName: string) => Promise<boolean>;
+}
+export declare const McpManager: React.FC<McpManagerProps>;
+//# sourceMappingURL=McpManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"McpManager.d.ts","sourceRoot":"","sources":["../../src/components/McpManager.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAC;AAExC,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1D,kBAAkB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9D;AAED,eAAO,MAAM,UAAU,EAAE,KAAK,CAAC,EAAE,CAAC,eAAe,CA4ThD,CAAC"}

package/dist/components/McpManager.js

@@ -0,0 +1,123 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+export const McpManager = ({ onCancel, servers, onConnectServer, onDisconnectServer, }) => {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const [viewMode, setViewMode] = useState("list");
+    // Dynamically calculate selectedServer based on selectedIndex and servers
+    const selectedServer = viewMode === "detail" &&
+        servers.length > 0 &&
+        selectedIndex < servers.length
+        ? servers[selectedIndex]
+        : null;
+    const formatTime = (timestamp) => {
+        return new Date(timestamp).toLocaleTimeString();
+    };
+    const getStatusColor = (status) => {
+        switch (status) {
+            case "connected":
+                return "green";
+            case "connecting":
+                return "yellow";
+            case "error":
+                return "red";
+            default:
+                return "gray";
+        }
+    };
+    const getStatusIcon = (status) => {
+        switch (status) {
+            case "connected":
+                return "✓";
+            case "connecting":
+                return "⟳";
+            case "error":
+                return "✗";
+            default:
+                return "○";
+        }
+    };
+    const handleConnect = async (serverName) => {
+        await onConnectServer(serverName);
+    };
+    const handleDisconnect = async (serverName) => {
+        await onDisconnectServer(serverName);
+    };
+    useInput((input, key) => {
+        if (viewMode === "list") {
+            // List mode navigation
+            if (key.return) {
+                if (servers.length > 0 && selectedIndex < servers.length) {
+                    setViewMode("detail");
+                }
+                return;
+            }
+            if (key.escape) {
+                onCancel();
+                return;
+            }
+            if (key.upArrow) {
+                setSelectedIndex(Math.max(0, selectedIndex - 1));
+                return;
+            }
+            if (key.downArrow) {
+                setSelectedIndex(Math.min(servers.length - 1, selectedIndex + 1));
+                return;
+            }
+            // Hotkeys for server actions
+            if (input === "c" &&
+                servers.length > 0 &&
+                selectedIndex < servers.length) {
+                const server = servers[selectedIndex];
+                if (server.status === "disconnected" || server.status === "error") {
+                    handleConnect(server.name);
+                }
+                return;
+            }
+            if (input === "d" &&
+                servers.length > 0 &&
+                selectedIndex < servers.length) {
+                const server = servers[selectedIndex];
+                if (server.status === "connected") {
+                    handleDisconnect(server.name);
+                }
+                return;
+            }
+        }
+        else if (viewMode === "detail") {
+            // Detail mode navigation
+            if (key.escape) {
+                setViewMode("list");
+                return;
+            }
+            if (selectedServer) {
+                if (input === "c" &&
+                    (selectedServer.status === "disconnected" ||
+                        selectedServer.status === "error")) {
+                    handleConnect(selectedServer.name);
+                    return;
+                }
+                if (input === "d" && selectedServer.status === "connected") {
+                    handleDisconnect(selectedServer.name);
+                    return;
+                }
+            }
+        }
+    });
+    if (viewMode === "detail" && selectedServer) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", padding: 1, gap: 1, marginBottom: 1, children: [_jsx(Box, { children: _jsxs(Text, { color: "cyan", bold: true, children: ["MCP Server Details: ", selectedServer.name] }) }), _jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Status:" }), " ", _jsxs(Text, { color: getStatusColor(selectedServer.status), children: [getStatusIcon(selectedServer.status), " ", selectedServer.status] })] }) }), _jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Command:" }), " ", selectedServer.config.command] }) }), selectedServer.config.args && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Args:" }), " ", selectedServer.config.args.join(" ")] }) })), selectedServer.toolCount !== undefined && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Tools:" }), " ", selectedServer.toolCount, " ", "tools"] }) })), selectedServer.capabilities && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Capabilities:" }), " ", selectedServer.capabilities.join(", ")] }) })), selectedServer.lastConnected && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "blue", children: "Last Connected:" }), " ", formatTime(selectedServer.lastConnected)] }) })), selectedServer.error && (_jsx(Box, { children: _jsxs(Text, { children: [_jsx(Text, { color: "red", children: "Error:" }), " ", selectedServer.error] }) }))] }), selectedServer.config.env &&
+                    Object.keys(selectedServer.config.env).length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "blue", bold: true, children: "Environment Variables:" }), _jsx(Box, { borderStyle: "single", borderColor: "blue", padding: 1, children: Object.entries(selectedServer.config.env).map(([key, value]) => (_jsxs(Text, { children: [key, "=", value] }, key))) })] })), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [selectedServer.status === "disconnected" ||
+                                selectedServer.status === "error"
+                                ? "c to connect · "
+                                : "", selectedServer.status === "connected" ? "d to disconnect · " : "", "Esc to go back"] }) })] }));
+    }
+    if (servers.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", padding: 1, marginBottom: 1, children: [_jsx(Text, { color: "cyan", bold: true, children: "Manage MCP servers" }), _jsx(Text, { children: "No MCP servers configured" }), _jsx(Text, { dimColor: true, children: "Create a .mcp.json file in your project root to add servers" }), _jsx(Text, { dimColor: true, children: "Press Escape to close" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "cyan", padding: 1, gap: 1, marginBottom: 1, children: [_jsx(Box, { children: _jsx(Text, { color: "cyan", bold: true, children: "Manage MCP servers" }) }), _jsx(Text, { dimColor: true, children: "Select a server to view details" }), servers.map((server, index) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { color: index === selectedIndex ? "black" : "white", backgroundColor: index === selectedIndex ? "cyan" : undefined, children: [index === selectedIndex ? "▶ " : "  ", index + 1, ".", " ", _jsx(Text, { color: getStatusColor(server.status), children: getStatusIcon(server.status) }), " ", server.name, server.status === "connected" && server.toolCount && (_jsxs(Text, { color: "green", children: [" \u00B7 ", server.toolCount, " tools"] }))] }), index === selectedIndex && (_jsxs(Box, { marginLeft: 4, flexDirection: "column", children: [_jsxs(Text, { color: "gray", dimColor: true, children: [server.config.command, server.config.args ? ` ${server.config.args.join(" ")}` : ""] }), server.lastConnected && (_jsxs(Text, { color: "gray", dimColor: true, children: ["Last connected: ", formatTime(server.lastConnected)] }))] }))] }, server.name))), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["\u2191/\u2193 to select \u00B7 Enter to view \u00B7", " ", servers[selectedIndex]?.status === "disconnected" ||
+                            servers[selectedIndex]?.status === "error"
+                            ? "c to connect · "
+                            : "", servers[selectedIndex]?.status === "connected"
+                            ? "d to disconnect · "
+                            : "", "Esc to close"] }) })] }));
+};

package/dist/components/MemoryDisplay.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { MemoryBlock } from "wave-agent-sdk";
+interface MemoryDisplayProps {
+    block: MemoryBlock;
+}
+export declare const MemoryDisplay: React.FC<MemoryDisplayProps>;
+export {};
+//# sourceMappingURL=MemoryDisplay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MemoryDisplay.d.ts","sourceRoot":"","sources":["../../src/components/MemoryDisplay.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,UAAU,kBAAkB;IAC1B,KAAK,EAAE,WAAW,CAAC;CACpB;AAED,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC,kBAAkB,CAqDtD,CAAC"}