wave-code 0.0.2

package/src/components/ToolResultDisplay.tsx

@@ -0,0 +1,138 @@
+import React from "react";
+import { Box, Text } from "ink";
+import type { ToolBlock } from "wave-agent-sdk";
+
+interface ToolResultDisplayProps {
+  block: ToolBlock;
+  isExpanded?: boolean;
+}
+
+export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
+  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 (
+    <Box flexDirection="column" gap={1}>
+      <Box>
+        <Text color="magenta">🔧 </Text>
+        <Text color="white">{toolName}</Text>
+        {/* Display compactParams in collapsed state */}
+        {!isExpanded && compactParams && (
+          <Text color="gray"> ({compactParams})</Text>
+        )}
+        <Text color={getStatusColor()}> {getStatusText()}</Text>
+        {/* Display image indicator */}
+        {hasImages() && <Text color="blue"> {getImageIndicator()}</Text>}
+      </Box>
+
+      {/* Display shortResult in collapsed state */}
+      {!isExpanded && shortResult && (
+        <Box
+          paddingLeft={2}
+          borderLeft
+          borderColor="gray"
+          flexDirection="column"
+        >
+          {shortResult.split("\n").map((line, index) => (
+            <Text key={index} color="white">
+              {line}
+            </Text>
+          ))}
+        </Box>
+      )}
+
+      {/* Display complete parameters in expanded state */}
+      {isExpanded && parameters && (
+        <Box
+          paddingLeft={2}
+          borderLeft
+          borderColor="gray"
+          flexDirection="column"
+        >
+          <Text color="cyan" bold>
+            Parameters:
+          </Text>
+          <Text color="gray">{parameters}</Text>
+        </Box>
+      )}
+
+      {/* Display complete result in expanded state */}
+      {isExpanded && result && (
+        <Box flexDirection="column">
+          <Box
+            paddingLeft={2}
+            borderLeft
+            borderColor="green"
+            flexDirection="column"
+          >
+            <Text color="cyan" bold>
+              Result:
+            </Text>
+            <Text color="white">{result}</Text>
+          </Box>
+        </Box>
+      )}
+
+      {/* Error information always displayed */}
+      {error && (
+        <Box>
+          <Text color="red">
+            Error: {typeof error === "string" ? error : String(error)}
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+};

package/src/contexts/useAppConfig.tsx

@@ -0,0 +1,32 @@
+import React, { createContext, useContext } from "react";
+
+export interface AppConfig {
+  restoreSessionId?: string;
+  continueLastSession?: boolean;
+}
+
+const AppContext = createContext<AppConfig | null>(null);
+
+export const useAppConfig = () => {
+  const context = useContext(AppContext);
+  if (!context) {
+    throw new Error("useAppConfig must be used within AppProvider");
+  }
+  return context;
+};
+
+export interface AppProviderProps extends AppConfig {
+  children: React.ReactNode;
+}
+
+export const AppProvider: React.FC<AppProviderProps> = ({
+  restoreSessionId,
+  continueLastSession,
+  children,
+}) => {
+  return (
+    <AppContext.Provider value={{ restoreSessionId, continueLastSession }}>
+      {children}
+    </AppContext.Provider>
+  );
+};

package/src/contexts/useChat.tsx

@@ -0,0 +1,300 @@
+import React, {
+  createContext,
+  useContext,
+  useCallback,
+  useRef,
+  useEffect,
+  useState,
+} from "react";
+import { useInput } from "ink";
+import { useAppConfig } from "./useAppConfig.js";
+import type {
+  Message,
+  McpServerStatus,
+  BackgroundShell,
+  SlashCommand,
+} from "wave-agent-sdk";
+import { Agent, AgentCallbacks } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
+
+// Main Chat Context
+export interface ChatContextType {
+  messages: Message[];
+  isLoading: boolean;
+  isCommandRunning: boolean;
+  isCompressing: boolean;
+  userInputHistory: string[];
+  // Message display state
+  isExpanded: boolean;
+  // AI functionality
+  sessionId: string;
+  sendMessage: (
+    content: string,
+    images?: Array<{ path: string; mimeType: string }>,
+  ) => Promise<void>;
+  abortMessage: () => void;
+  latestTotalTokens: number;
+  // Memory functionality
+  saveMemory: (message: string, type: "project" | "user") => Promise<void>;
+  // MCP functionality
+  mcpServers: McpServerStatus[];
+  connectMcpServer: (serverName: string) => Promise<boolean>;
+  disconnectMcpServer: (serverName: string) => Promise<boolean>;
+  // Background bash shells
+  backgroundShells: BackgroundShell[];
+  getBackgroundShellOutput: (
+    shellId: string,
+  ) => { stdout: string; stderr: string; status: string } | null;
+  killBackgroundShell: (shellId: string) => boolean;
+  // Slash Command functionality
+  slashCommands: SlashCommand[];
+  hasSlashCommand: (commandId: string) => boolean;
+}
+
+const ChatContext = createContext<ChatContextType | null>(null);
+
+export const useChat = () => {
+  const context = useContext(ChatContext);
+  if (!context) {
+    throw new Error("useChat must be used within ChatProvider");
+  }
+  return context;
+};
+
+export interface ChatProviderProps {
+  children: React.ReactNode;
+}
+
+export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
+  const { restoreSessionId, continueLastSession } = useAppConfig();
+
+  // Message Display State
+  const [isExpanded, setIsExpanded] = useState(false);
+
+  // AI State
+  const [messages, setMessages] = useState<Message[]>([]);
+  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<string[]>([]);
+
+  // MCP State
+  const [mcpServers, setMcpServers] = useState<McpServerStatus[]>([]);
+
+  // Background bash shells state
+  const [backgroundShells, setBackgroundShells] = useState<BackgroundShell[]>(
+    [],
+  );
+
+  // Command state
+  const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
+
+  const agentRef = useRef<Agent | null>(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: AgentCallbacks = {
+        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: string,
+      images?: Array<{ path: string; mimeType: string }>,
+    ) => {
+      // 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: string, type: "project" | "user") => {
+      await agentRef.current?.saveMemory(message, type);
+    },
+    [],
+  );
+
+  // MCP management methods - delegate to Agent
+  const connectMcpServer = useCallback(async (serverName: string) => {
+    return (await agentRef.current?.connectMcpServer(serverName)) ?? false;
+  }, []);
+
+  const disconnectMcpServer = useCallback(async (serverName: string) => {
+    return (await agentRef.current?.disconnectMcpServer(serverName)) ?? false;
+  }, []);
+
+  // Background bash management methods - delegate to Agent
+  const getBackgroundShellOutput = useCallback((shellId: string) => {
+    if (!agentRef.current) return null;
+    return agentRef.current.getBackgroundShellOutput(shellId);
+  }, []);
+
+  const killBackgroundShell = useCallback((shellId: string) => {
+    if (!agentRef.current) return false;
+    return agentRef.current.killBackgroundShell(shellId);
+  }, []);
+
+  const hasSlashCommand = useCallback((commandId: string) => {
+    if (!agentRef.current) return false;
+    return agentRef.current.hasSlashCommand(commandId);
+  }, []);
+
+  const contextValue: ChatContextType = {
+    messages,
+    isLoading,
+    isCommandRunning,
+    userInputHistory,
+    isExpanded,
+    sessionId,
+    sendMessage,
+    abortMessage,
+    latestTotalTokens,
+    isCompressing,
+    saveMemory,
+    mcpServers,
+    connectMcpServer,
+    disconnectMcpServer,
+    backgroundShells,
+    getBackgroundShellOutput,
+    killBackgroundShell,
+    slashCommands,
+    hasSlashCommand,
+  };
+
+  return (
+    <ChatContext.Provider value={contextValue}>{children}</ChatContext.Provider>
+  );
+};

package/src/hooks/useBashHistorySelector.ts

@@ -0,0 +1,77 @@
+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: number) => {
+    setShowBashHistorySelector(true);
+    setExclamationPosition(position);
+    setBashHistorySearchQuery("");
+  }, []);
+
+  const handleBashHistorySelect = useCallback(
+    (command: string, inputText: string, cursorPosition: number) => {
+      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: string) => {
+    setShowBashHistorySelector(false);
+    setExclamationPosition(-1);
+    setBashHistorySearchQuery("");
+    return command; // Return command to execute
+  }, []);
+
+  const updateBashHistorySearchQuery = useCallback((query: string) => {
+    setBashHistorySearchQuery(query);
+  }, []);
+
+  const checkForExclamationDeletion = useCallback(
+    (cursorPosition: number) => {
+      if (showBashHistorySelector && cursorPosition <= exclamationPosition) {
+        handleCancelBashHistorySelect();
+        return true;
+      }
+      return false;
+    },
+    [
+      showBashHistorySelector,
+      exclamationPosition,
+      handleCancelBashHistorySelect,
+    ],
+  );
+
+  return {
+    showBashHistorySelector,
+    bashHistorySearchQuery,
+    activateBashHistorySelector,
+    handleBashHistorySelect,
+    handleBashHistoryExecute,
+    handleCancelBashHistorySelect,
+    updateBashHistorySearchQuery,
+    checkForExclamationDeletion,
+    exclamationPosition,
+  };
+};

package/src/hooks/useCommandSelector.ts

@@ -0,0 +1,131 @@
+import { useState, useCallback } from "react";
+
+export interface UseCommandSelectorParams {
+  onShowBashManager?: () => void;
+  onShowMcpManager?: () => void;
+  sendMessage?: (content: string) => Promise<void>; // Use sendMessage instead of executeSlashCommand
+  hasSlashCommand?: (commandId: string) => boolean; // Function to check if command exists
+}
+
+export const useCommandSelector = ({
+  onShowBashManager,
+  onShowMcpManager,
+  sendMessage,
+  hasSlashCommand,
+}: UseCommandSelectorParams) => {
+  const [showCommandSelector, setShowCommandSelector] = useState(false);
+  const [slashPosition, setSlashPosition] = useState(-1);
+  const [commandSearchQuery, setCommandSearchQuery] = useState("");
+
+  const activateCommandSelector = useCallback((position: number) => {
+    setShowCommandSelector(true);
+    setSlashPosition(position);
+    setCommandSearchQuery("");
+  }, []);
+
+  const handleCommandInsert = useCallback(
+    (command: string, inputText: string, cursorPosition: number) => {
+      if (slashPosition >= 0) {
+        // Replace content from / to current cursor position with /command_name + space
+        const beforeSlash = inputText.substring(0, slashPosition);
+        const afterQuery = inputText.substring(cursorPosition);
+        const newInput = beforeSlash + `/${command} ` + afterQuery;
+        const newCursorPosition = beforeSlash.length + command.length + 2; // +2 for "/" and " "
+
+        setShowCommandSelector(false);
+        setSlashPosition(-1);
+        setCommandSearchQuery("");
+
+        return { newInput, newCursorPosition };
+      }
+      return { newInput: inputText, newCursorPosition: cursorPosition };
+    },
+    [slashPosition],
+  );
+
+  const handleCommandSelect = useCallback(
+    (command: string, inputText: string, cursorPosition: number) => {
+      if (slashPosition >= 0) {
+        // Replace command part, keep other content
+        const beforeSlash = inputText.substring(0, slashPosition);
+        const afterQuery = inputText.substring(cursorPosition);
+        const newInput = beforeSlash + afterQuery;
+        const newCursorPosition = beforeSlash.length;
+
+        // Execute command asynchronously
+        (async () => {
+          // First check if it's an agent command
+          let commandExecuted = false;
+          if (sendMessage && hasSlashCommand && hasSlashCommand(command)) {
+            // Execute complete command (replace partial input with complete command name)
+            const fullCommand = `/${command}`;
+            try {
+              await sendMessage(fullCommand);
+              commandExecuted = true;
+            } catch (error) {
+              console.error("Failed to execute slash command:", error);
+            }
+          }
+
+          // If not an agent command or execution failed, check local commands
+          if (!commandExecuted) {
+            if (command === "bashes" && onShowBashManager) {
+              onShowBashManager();
+              commandExecuted = true;
+            } else if (command === "mcp" && onShowMcpManager) {
+              onShowMcpManager();
+              commandExecuted = true;
+            }
+          }
+        })();
+
+        setShowCommandSelector(false);
+        setSlashPosition(-1);
+        setCommandSearchQuery("");
+
+        return { newInput, newCursorPosition };
+      }
+      return { newInput: inputText, newCursorPosition: cursorPosition };
+    },
+    [
+      slashPosition,
+      onShowBashManager,
+      onShowMcpManager,
+      sendMessage,
+      hasSlashCommand,
+    ],
+  );
+
+  const handleCancelCommandSelect = useCallback(() => {
+    setShowCommandSelector(false);
+    setSlashPosition(-1);
+    setCommandSearchQuery("");
+  }, []);
+
+  const updateCommandSearchQuery = useCallback((query: string) => {
+    setCommandSearchQuery(query);
+  }, []);
+
+  const checkForSlashDeletion = useCallback(
+    (cursorPosition: number) => {
+      if (showCommandSelector && cursorPosition <= slashPosition) {
+        handleCancelCommandSelect();
+        return true;
+      }
+      return false;
+    },
+    [showCommandSelector, slashPosition, handleCancelCommandSelect],
+  );
+
+  return {
+    showCommandSelector,
+    commandSearchQuery,
+    activateCommandSelector,
+    handleCommandSelect,
+    handleCommandInsert,
+    handleCancelCommandSelect,
+    updateCommandSearchQuery,
+    checkForSlashDeletion,
+    slashPosition,
+  };
+};