wave-code 0.2.1 → 0.5.0

package/src/contexts/useChat.tsx

@@ -11,7 +11,7 @@ import { useAppConfig } from "./useAppConfig.js";
 import type {
   Message,
   McpServerStatus,
-  BackgroundShell,
+  BackgroundTask,
   SlashCommand,
   PermissionDecision,
   PermissionMode,
@@ -47,12 +47,12 @@ export interface ChatContextType {
   mcpServers: McpServerStatus[];
   connectMcpServer: (serverName: string) => Promise<boolean>;
   disconnectMcpServer: (serverName: string) => Promise<boolean>;
-  // Background bash shells
-  backgroundShells: BackgroundShell[];
-  getBackgroundShellOutput: (
-    shellId: string,
+  // Background tasks
+  backgroundTasks: BackgroundTask[];
+  getBackgroundTaskOutput: (
+    taskId: string,
   ) => { stdout: string; stderr: string; status: string } | null;
-  killBackgroundShell: (shellId: string) => boolean;
+  stopBackgroundTask: (taskId: string) => boolean;
   // Slash Command functionality
   slashCommands: SlashCommand[];
   hasSlashCommand: (commandId: string) => boolean;
@@ -78,6 +78,11 @@ export interface ChatContextType {
   hideConfirmation: () => void;
   handleConfirmationDecision: (decision: PermissionDecision) => void;
   handleConfirmationCancel: () => void;
+  // Background current task
+  backgroundCurrentTask: () => void;
+  // Rewind functionality
+  rewindId: number;
+  handleRewindSelect: (index: number) => Promise<void>;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -118,10 +123,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // MCP State
   const [mcpServers, setMcpServers] = useState<McpServerStatus[]>([]);
 
-  // Background bash shells state
-  const [backgroundShells, setBackgroundShells] = useState<BackgroundShell[]>(
-    [],
-  );
+  // Background tasks state
+  const [backgroundTasks, setBackgroundTasks] = useState<BackgroundTask[]>([]);
 
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
@@ -165,6 +168,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     reject: () => void;
   } | null>(null);
 
+  // Rewind state
+  const [rewindId, setRewindId] = useState(0);
+
   const agentRef = useRef<Agent | null>(null);
 
   // Permission confirmation methods with queue support
@@ -216,8 +222,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onCompressionStateChange: (isCompressingState) => {
           setIsCompressing(isCompressingState);
         },
-        onShellsChange: (shells) => {
-          setBackgroundShells([...shells]);
+        onTasksChange: (tasks) => {
+          setBackgroundTasks([...tasks]);
         },
         onSubagentMessagesChange: (subagentId, messages) => {
           logger.debug("onSubagentMessagesChange", subagentId, messages.length);
@@ -229,6 +235,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
         },
+        onSlashCommandsChange: (commands) => {
+          setSlashCommands([...commands]);
+        },
       };
 
       try {
@@ -413,15 +422,15 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     return (await agentRef.current?.disconnectMcpServer(serverName)) ?? false;
   }, []);
 
-  // Background bash management methods - delegate to Agent
-  const getBackgroundShellOutput = useCallback((shellId: string) => {
+  // Background task management methods - delegate to Agent
+  const getBackgroundTaskOutput = useCallback((taskId: string) => {
     if (!agentRef.current) return null;
-    return agentRef.current.getBackgroundShellOutput(shellId);
+    return agentRef.current.getBackgroundTaskOutput(taskId);
   }, []);
 
-  const killBackgroundShell = useCallback((shellId: string) => {
+  const stopBackgroundTask = useCallback((taskId: string) => {
     if (!agentRef.current) return false;
-    return agentRef.current.killBackgroundShell(shellId);
+    return agentRef.current.stopBackgroundTask(taskId);
   }, []);
 
   const hasSlashCommand = useCallback((commandId: string) => {
@@ -473,6 +482,25 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hideConfirmation();
   }, [currentConfirmation, hideConfirmation]);
 
+  const backgroundCurrentTask = useCallback(() => {
+    agentRef.current?.backgroundCurrentTask();
+  }, []);
+
+  const handleRewindSelect = useCallback(async (index: number) => {
+    if (agentRef.current) {
+      try {
+        await agentRef.current.truncateHistory(index);
+
+        // Clear terminal screen after rewind
+        process.stdout.write("\x1Bc", () => {
+          setRewindId((prev) => prev + 1);
+        });
+      } catch (error) {
+        logger.error("Failed to rewind:", error);
+      }
+    }
+  }, []);
+
   // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
   useInput((input, key) => {
     if (key.ctrl && input === "o") {
@@ -506,9 +534,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     mcpServers,
     connectMcpServer,
     disconnectMcpServer,
-    backgroundShells,
-    getBackgroundShellOutput,
-    killBackgroundShell,
+    backgroundTasks,
+    getBackgroundTaskOutput,
+    stopBackgroundTask,
     slashCommands,
     hasSlashCommand,
     subagentMessages,
@@ -520,6 +548,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     hideConfirmation,
     handleConfirmationDecision,
     handleConfirmationCancel,
+    backgroundCurrentTask,
+    rewindId,
+    handleRewindSelect,
   };
 
   return (

package/src/hooks/useInputManager.ts

@@ -29,17 +29,17 @@ export const useInputManager = (
     query: "",
     position: -1,
   });
-  const [bashHistorySelectorState, setBashHistorySelectorState] = useState({
+  const [historySearchState, setHistorySearchState] = useState({
     show: false,
     query: "",
-    position: -1,
   });
   const [memoryTypeSelectorState, setMemoryTypeSelectorState] = useState({
     show: false,
     message: "",
   });
-  const [showBashManager, setShowBashManager] = useState(false);
+  const [showTaskManager, setShowTaskManager] = useState(false);
   const [showMcpManager, setShowMcpManager] = useState(false);
+  const [showRewindManager, setShowRewindManager] = useState(false);
   const [permissionMode, setPermissionModeState] =
     useState<PermissionMode>("default");
   const [attachedImages, setAttachedImages] = useState<AttachedImage[]>([]);
@@ -58,25 +58,29 @@ export const useInputManager = (
         onCommandSelectorStateChange: (show, query, position) => {
           setCommandSelectorState({ show, query, position });
         },
-        onBashHistorySelectorStateChange: (show, query, position) => {
-          setBashHistorySelectorState({ show, query, position });
+        onHistorySearchStateChange: (show, query) => {
+          setHistorySearchState({ show, query });
         },
         onMemoryTypeSelectorStateChange: (show, message) => {
           setMemoryTypeSelectorState({ show, message });
         },
-        onBashManagerStateChange: (show) => {
-          setShowBashManager(show);
+        onTaskManagerStateChange: (show) => {
+          setShowTaskManager(show);
         },
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
         },
+        onRewindManagerStateChange: (show) => {
+          setShowRewindManager(show);
+        },
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
           callbacks.onPermissionModeChange?.(mode);
         },
         onImagesStateChange: setAttachedImages,
-        onShowBashManager: () => setShowBashManager(true),
+        onShowTaskManager: () => setShowTaskManager(true),
         onShowMcpManager: () => setShowMcpManager(true),
+        onShowRewindManager: () => setShowRewindManager(true),
         ...callbacks,
       });
 
@@ -94,25 +98,29 @@ export const useInputManager = (
         onCommandSelectorStateChange: (show, query, position) => {
           setCommandSelectorState({ show, query, position });
         },
-        onBashHistorySelectorStateChange: (show, query, position) => {
-          setBashHistorySelectorState({ show, query, position });
+        onHistorySearchStateChange: (show, query) => {
+          setHistorySearchState({ show, query });
         },
         onMemoryTypeSelectorStateChange: (show, message) => {
           setMemoryTypeSelectorState({ show, message });
         },
-        onBashManagerStateChange: (show) => {
-          setShowBashManager(show);
+        onTaskManagerStateChange: (show) => {
+          setShowTaskManager(show);
         },
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
         },
+        onRewindManagerStateChange: (show) => {
+          setShowRewindManager(show);
+        },
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
           callbacks.onPermissionModeChange?.(mode);
         },
         onImagesStateChange: setAttachedImages,
-        onShowBashManager: () => setShowBashManager(true),
+        onShowTaskManager: () => setShowTaskManager(true),
         onShowMcpManager: () => setShowMcpManager(true),
+        onShowRewindManager: () => setShowRewindManager(true),
         ...callbacks,
       });
     }
@@ -235,37 +243,13 @@ export const useInputManager = (
     return managerRef.current?.checkForSlashDeletion(cursorPos) || false;
   }, []);
 
-  // Bash history selector methods
-  const activateBashHistorySelector = useCallback((position: number) => {
-    managerRef.current?.activateBashHistorySelector(position);
-  }, []);
-
-  const handleBashHistorySelect = useCallback(
-    (command: string) => {
-      return (
-        managerRef.current?.handleBashHistorySelect(command) || {
-          newInput: inputText,
-          newCursorPosition: cursorPosition,
-        }
-      );
-    },
-    [inputText, cursorPosition],
-  );
-
-  const handleCancelBashHistorySelect = useCallback(() => {
-    managerRef.current?.handleCancelBashHistorySelect();
-  }, []);
-
-  const updateBashHistorySearchQuery = useCallback((query: string) => {
-    managerRef.current?.updateBashHistorySearchQuery(query);
+  // History search methods
+  const handleHistorySearchSelect = useCallback((prompt: string) => {
+    managerRef.current?.handleHistorySearchSelect(prompt);
   }, []);
 
-  const handleBashHistoryExecute = useCallback((command: string) => {
-    return managerRef.current?.handleBashHistoryExecute(command) || command;
-  }, []);
-
-  const checkForExclamationDeletion = useCallback((cursorPos: number) => {
-    return managerRef.current?.checkForExclamationDeletion(cursorPos) || false;
+  const handleCancelHistorySearch = useCallback(() => {
+    managerRef.current?.handleCancelHistorySearch();
   }, []);
 
   // Memory type selector methods
@@ -320,17 +304,6 @@ export const useInputManager = (
   }, []);
 
   // Complex handlers that combine multiple operations
-  const handleBashHistoryExecuteAndSend = useCallback((command: string) => {
-    managerRef.current?.handleBashHistoryExecuteAndSend(command);
-  }, []);
-
-  const handleBashHistoryDelete = useCallback(
-    (command: string, workdir?: string) => {
-      managerRef.current?.handleBashHistoryDelete(command, workdir);
-    },
-    [],
-  );
-
   return {
     // State
     inputText,
@@ -342,13 +315,13 @@ export const useInputManager = (
     showCommandSelector: commandSelectorState.show,
     commandSearchQuery: commandSelectorState.query,
     slashPosition: commandSelectorState.position,
-    showBashHistorySelector: bashHistorySelectorState.show,
-    bashHistorySearchQuery: bashHistorySelectorState.query,
-    exclamationPosition: bashHistorySelectorState.position,
+    showHistorySearch: historySearchState.show,
+    historySearchQuery: historySearchState.query,
     showMemoryTypeSelector: memoryTypeSelectorState.show,
     memoryMessage: memoryTypeSelectorState.message,
-    showBashManager,
+    showTaskManager,
     showMcpManager,
+    showRewindManager,
     permissionMode,
     attachedImages,
     isManagerReady,
@@ -377,14 +350,9 @@ export const useInputManager = (
     updateCommandSearchQuery,
     checkForSlashDeletion,
 
-    // Bash history selector
-    activateBashHistorySelector,
-    handleBashHistorySelect,
-    handleCancelBashHistorySelect,
-    updateBashHistorySearchQuery,
-
-    handleBashHistoryExecute,
-    checkForExclamationDeletion,
+    // History search
+    handleHistorySearchSelect,
+    handleCancelHistorySearch,
 
     // Memory type selector
     activateMemoryTypeSelector,
@@ -400,12 +368,16 @@ export const useInputManager = (
     handleSpecialCharInput,
 
     // Bash/MCP Manager
-    setShowBashManager: useCallback((show: boolean) => {
-      managerRef.current?.setShowBashManager(show);
+    setShowTaskManager: useCallback((show: boolean) => {
+      managerRef.current?.setShowTaskManager(show);
     }, []),
     setShowMcpManager: useCallback((show: boolean) => {
       managerRef.current?.setShowMcpManager(show);
     }, []),
+    setShowRewindManager: useCallback((show: boolean) => {
+      managerRef.current?.setShowRewindManager(show);
+      setShowRewindManager(show);
+    }, []),
     setPermissionMode: useCallback((mode: PermissionMode) => {
       setPermissionModeState(mode);
       managerRef.current?.setPermissionMode(mode);
@@ -450,10 +422,6 @@ export const useInputManager = (
       managerRef.current?.clearLongTextMap();
     }, []),
 
-    // Complex handlers combining multiple operations
-    handleBashHistoryExecuteAndSend,
-    handleBashHistoryDelete,
-
     // Main input handler
     handleInput: useCallback(
       async (

package/src/hooks/usePluginManager.ts

@@ -0,0 +1,302 @@
+import { useState, useCallback, useEffect, useMemo } from "react";
+import {
+  MarketplaceService,
+  PluginScopeManager,
+  ConfigurationService,
+  PluginManager,
+  KnownMarketplace,
+  InstalledPlugin,
+  MarketplacePluginEntry,
+} from "wave-agent-sdk";
+import {
+  PluginManagerState,
+  ViewType,
+  PluginManagerContextType,
+} from "../components/PluginManagerTypes.js";
+
+export function usePluginManager(): PluginManagerContextType {
+  const [state, setState] = useState<PluginManagerState>({
+    currentView: "DISCOVER",
+    selectedId: null,
+    isLoading: true,
+    error: null,
+    searchQuery: "",
+  });
+
+  const [marketplaces, setMarketplaces] = useState<KnownMarketplace[]>([]);
+  const [installedPlugins, setInstalledPlugins] = useState<
+    (InstalledPlugin & { enabled: boolean })[]
+  >([]);
+  const [discoverablePlugins, setDiscoverablePlugins] = useState<
+    (MarketplacePluginEntry & {
+      marketplace: string;
+      installed: boolean;
+      version?: string;
+    })[]
+  >([]);
+
+  const marketplaceService = useMemo(() => new MarketplaceService(), []);
+  const configurationService = useMemo(() => new ConfigurationService(), []);
+  const pluginManager = useMemo(
+    () =>
+      new PluginManager({
+        workdir: process.cwd(),
+        configurationService,
+      }),
+    [configurationService],
+  );
+  const pluginScopeManager = useMemo(
+    () =>
+      new PluginScopeManager({
+        workdir: process.cwd(),
+        configurationService,
+        pluginManager,
+      }),
+    [configurationService, pluginManager],
+  );
+
+  const refresh = useCallback(async () => {
+    setState((prev: PluginManagerState) => ({
+      ...prev,
+      isLoading: true,
+      error: null,
+    }));
+    try {
+      const [mks, installed, enabledMap] = await Promise.all([
+        marketplaceService.listMarketplaces(),
+        marketplaceService.getInstalledPlugins(),
+        Promise.resolve(pluginScopeManager.getMergedEnabledPlugins()),
+      ]);
+
+      setMarketplaces(mks);
+      const allInstalledWithEnabled = installed.plugins.map((p) => {
+        const pluginId = `${p.name}@${p.marketplace}`;
+        return {
+          ...p,
+          enabled: !!enabledMap[pluginId],
+          scope: pluginScopeManager.findPluginScope(pluginId) || undefined,
+        };
+      });
+
+      // Only show enabled plugins in the "Installed" view
+      setInstalledPlugins(allInstalledWithEnabled.filter((p) => p.enabled));
+
+      const allDiscoverable: (MarketplacePluginEntry & {
+        marketplace: string;
+        installed: boolean;
+        version?: string;
+      })[] = [];
+      for (const mk of mks) {
+        try {
+          const manifest = await marketplaceService.loadMarketplaceManifest(
+            marketplaceService.getMarketplacePath(mk),
+          );
+          manifest.plugins.forEach((p) => {
+            const pluginId = `${p.name}@${mk.name}`;
+            const isInstalled = installed.plugins.find(
+              (ip) => ip.name === p.name && ip.marketplace === mk.name,
+            );
+            const isEnabled = !!enabledMap[pluginId];
+
+            // Show in Discover if not installed OR if installed but not enabled in current scope
+            if (!isInstalled || !isEnabled) {
+              allDiscoverable.push({
+                ...p,
+                marketplace: mk.name,
+                installed: !!isInstalled,
+              });
+            }
+          });
+        } catch {
+          // Skip marketplaces that fail to load
+        }
+      }
+      setDiscoverablePlugins(allDiscoverable);
+      setState((prev: PluginManagerState) => ({ ...prev, isLoading: false }));
+    } catch (error) {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: false,
+        error: error instanceof Error ? error.message : String(error),
+      }));
+    }
+  }, [marketplaceService, pluginScopeManager]);
+
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  const setView = useCallback((view: ViewType) => {
+    setState((prev: PluginManagerState) => ({ ...prev, currentView: view }));
+  }, []);
+
+  const setSelectedId = useCallback((id: string | null) => {
+    setState((prev: PluginManagerState) => ({ ...prev, selectedId: id }));
+  }, []);
+
+  const addMarketplace = useCallback(
+    async (source: string) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: true,
+        error: null,
+      }));
+      try {
+        await marketplaceService.addMarketplace(source);
+        await refresh();
+      } catch (error) {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      }
+    },
+    [marketplaceService, refresh],
+  );
+
+  const removeMarketplace = useCallback(
+    async (name: string) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: true,
+        error: null,
+      }));
+      try {
+        await marketplaceService.removeMarketplace(name);
+        await refresh();
+      } catch (error) {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      }
+    },
+    [marketplaceService, refresh],
+  );
+
+  const updateMarketplace = useCallback(
+    async (name: string) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: true,
+        error: null,
+      }));
+      try {
+        await marketplaceService.updateMarketplace(name);
+        await refresh();
+      } catch (error) {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      }
+    },
+    [marketplaceService, refresh],
+  );
+
+  const installPlugin = useCallback(
+    async (
+      name: string,
+      marketplace: string,
+      scope: "user" | "project" | "local" = "project",
+    ) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: true,
+        error: null,
+      }));
+      try {
+        const pluginId = `${name}@${marketplace}`;
+        const workdir = process.cwd();
+        await marketplaceService.installPlugin(pluginId, workdir);
+        await pluginScopeManager.enablePlugin(scope, pluginId);
+        await refresh();
+      } catch (error) {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      }
+    },
+    [marketplaceService, pluginScopeManager, refresh],
+  );
+
+  const uninstallPlugin = useCallback(
+    async (name: string, marketplace: string) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: true,
+        error: null,
+      }));
+      try {
+        const pluginId = `${name}@${marketplace}`;
+        const workdir = process.cwd();
+
+        // 1. Remove from global registry and potentially clean up cache
+        await marketplaceService.uninstallPlugin(pluginId, workdir);
+
+        // 2. Find the scope where it's currently enabled and remove it from there
+        const scope = pluginScopeManager.findPluginScope(pluginId);
+        if (scope) {
+          await configurationService.removeEnabledPlugin(
+            workdir,
+            scope,
+            pluginId,
+          );
+        }
+        await refresh();
+      } catch (error) {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      }
+    },
+    [configurationService, marketplaceService, pluginScopeManager, refresh],
+  );
+
+  const updatePlugin = useCallback(
+    async (name: string, marketplace: string) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        isLoading: true,
+        error: null,
+      }));
+      try {
+        const pluginId = `${name}@${marketplace}`;
+        await marketplaceService.updatePlugin(pluginId);
+        await refresh();
+      } catch (error) {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          isLoading: false,
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      }
+    },
+    [marketplaceService, refresh],
+  );
+
+  return {
+    state,
+    marketplaces,
+    installedPlugins,
+    discoverablePlugins,
+    actions: {
+      setView,
+      setSelectedId,
+      addMarketplace,
+      removeMarketplace,
+      updateMarketplace,
+      installPlugin,
+      uninstallPlugin,
+      updatePlugin,
+      refresh,
+    },
+  };
+}