wave-code 0.7.1 → 0.8.0

package/src/contexts/useChat.tsx

@@ -25,6 +25,8 @@ import {
 import { logger } from "../utils/logger.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 
+import { BaseAppProps } from "../types.js";
+
 // Main Chat Context
 export interface ChatContextType {
   messages: Message[];
@@ -43,14 +45,15 @@ export interface ChatContextType {
   ) => Promise<void>;
   abortMessage: () => void;
   latestTotalTokens: number;
+  clearMessages: () => void;
   // MCP functionality
   mcpServers: McpServerStatus[];
   connectMcpServer: (serverName: string) => Promise<boolean>;
   disconnectMcpServer: (serverName: string) => Promise<boolean>;
   // Background tasks
   backgroundTasks: BackgroundTask[];
-  // Session tasks
-  sessionTasks: Task[];
+  // Tasks
+  tasks: Task[];
   getBackgroundTaskOutput: (
     taskId: string,
   ) => { stdout: string; stderr: string; status: string } | null;
@@ -92,6 +95,12 @@ export interface ChatContextType {
   }>;
   wasLastDetailsTooTall: number;
   setWasLastDetailsTooTall: React.Dispatch<React.SetStateAction<number>>;
+  // Status metadata
+  getGatewayConfig: () => import("wave-agent-sdk").GatewayConfig;
+  getModelConfig: () => import("wave-agent-sdk").ModelConfig;
+  workingDirectory: string;
+  version?: string;
+  workdir?: string;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -104,11 +113,8 @@ export const useChat = () => {
   return context;
 };
 
-export interface ChatProviderProps {
+export interface ChatProviderProps extends BaseAppProps {
   children: React.ReactNode;
-  bypassPermissions?: boolean;
-  pluginDirs?: string[];
-  tools?: string[];
 }
 
 export const ChatProvider: React.FC<ChatProviderProps> = ({
@@ -116,6 +122,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   bypassPermissions,
   pluginDirs,
   tools,
+  workdir,
+  worktreeSession,
+  version,
+  model,
 }) => {
   const { restoreSessionId, continueLastSession } = useAppConfig();
 
@@ -144,8 +154,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
 
   // Background tasks state
   const [backgroundTasks, setBackgroundTasks] = useState<BackgroundTask[]>([]);
-  // Session tasks state
-  const [sessionTasks, setSessionTasks] = useState<Task[]>([]);
+  // Tasks state
+  const [tasks, setTasks] = useState<Task[]>([]);
 
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
@@ -195,6 +205,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Rewind state
   const [rewindId, setRewindId] = useState(0);
 
+  // Status metadata state
+  const [workingDirectory, setWorkingDirectory] = useState("");
+
   // Confirmation too tall state
   const [wasLastDetailsTooTall, setWasLastDetailsTooTall] = useState(0);
 
@@ -237,7 +250,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
                   setMessages([...agentRef.current.messages]);
                 }
                 messagesUpdateTimerRef.current = null;
-              }, 50);
+              }, 100);
             }
           }
         },
@@ -253,11 +266,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onCompressionStateChange: (isCompressingState) => {
           setIsCompressing(isCompressingState);
         },
-        onTasksChange: (tasks) => {
+        onBackgroundTasksChange: (tasks) => {
           setBackgroundTasks([...tasks]);
         },
-        onSessionTasksChange: (tasks) => {
-          setSessionTasks([...tasks]);
+        onTasksChange: (tasks) => {
+          setTasks([...tasks]);
         },
         onSubagentMessagesChange: (subagentId: string, messages: Message[]) => {
           logger.debug("onSubagentMessagesChange", subagentId, messages.length);
@@ -316,6 +329,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
           stream: false, // 关闭流式模式
           plugins: pluginDirs?.map((path) => ({ type: "local", path })),
           tools,
+          workdir,
+          worktreeName: worktreeSession?.name,
+          isNewWorktree: worktreeSession?.isNew,
+          model,
         });
 
         agentRef.current = agent;
@@ -328,6 +345,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         setIsCommandRunning(agent.isCommandRunning);
         setIsCompressing(agent.isCompressing);
         setPermissionModeState(agent.getPermissionMode());
+        setWorkingDirectory(agent.workingDirectory);
 
         // Get initial MCP servers state
         const mcpServers = agent.getMcpServers?.() || [];
@@ -349,6 +367,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     showConfirmation,
     pluginDirs,
     tools,
+    workdir,
+    worktreeSession,
   ]);
 
   // Cleanup on unmount
@@ -431,6 +451,10 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     agentRef.current?.abortMessage();
   }, []);
 
+  const clearMessages = useCallback(() => {
+    agentRef.current?.clearMessages();
+  }, []);
+
   // Permission management methods
   const setPermissionMode = useCallback((mode: PermissionMode) => {
     setPermissionModeState((prev) => {
@@ -535,6 +559,20 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     return { messages: [], sessionIds: [] };
   }, []);
 
+  const getGatewayConfig = useCallback(() => {
+    if (!agentRef.current) {
+      return { baseURL: "" };
+    }
+    return agentRef.current.getGatewayConfig();
+  }, []);
+
+  const getModelConfig = useCallback(() => {
+    if (!agentRef.current) {
+      return { model: "", fastModel: "" };
+    }
+    return agentRef.current.getModelConfig();
+  }, []);
+
   // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
   useInput((input, key) => {
     if (key.ctrl && input === "o") {
@@ -584,13 +622,14 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     sessionId,
     sendMessage,
     abortMessage,
+    clearMessages,
     latestTotalTokens,
     isCompressing,
     mcpServers,
     connectMcpServer,
     disconnectMcpServer,
     backgroundTasks,
-    sessionTasks,
+    tasks,
     getBackgroundTaskOutput,
     stopBackgroundTask,
     slashCommands,
@@ -611,6 +650,11 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     getFullMessageThread,
     wasLastDetailsTooTall,
     setWasLastDetailsTooTall,
+    getGatewayConfig,
+    getModelConfig,
+    workingDirectory,
+    version,
+    workdir,
   };
 
   return (

package/src/contracts/status.ts

@@ -0,0 +1,7 @@
+export interface AgentStatus {
+  version: string;
+  sessionId: string;
+  cwd: string;
+  baseURL: string;
+  model: string;
+}

package/src/hooks/useInputManager.ts

@@ -38,6 +38,7 @@ export const useInputManager = (
   const [showMcpManager, setShowMcpManager] = useState(false);
   const [showRewindManager, setShowRewindManager] = useState(false);
   const [showHelp, setShowHelp] = useState(false);
+  const [showStatusCommand, setShowStatusCommand] = useState(false);
   const [permissionMode, setPermissionModeState] =
     useState<PermissionMode>("default");
   const [attachedImages, setAttachedImages] = useState<AttachedImage[]>([]);
@@ -71,6 +72,9 @@ export const useInputManager = (
         onHelpStateChange: (show) => {
           setShowHelp(show);
         },
+        onStatusCommandStateChange: (show) => {
+          setShowStatusCommand(show);
+        },
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
           callbacks.onPermissionModeChange?.(mode);
@@ -108,6 +112,9 @@ export const useInputManager = (
         onHelpStateChange: (show) => {
           setShowHelp(show);
         },
+        onStatusCommandStateChange: (show) => {
+          setShowStatusCommand(show);
+        },
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
           callbacks.onPermissionModeChange?.(mode);
@@ -268,6 +275,7 @@ export const useInputManager = (
     showMcpManager,
     showRewindManager,
     showHelp,
+    showStatusCommand,
     permissionMode,
     attachedImages,
     isManagerReady,
@@ -316,6 +324,10 @@ export const useInputManager = (
       managerRef.current?.setShowHelp(show);
       setShowHelp(show);
     }, []),
+    setShowStatusCommand: useCallback((show: boolean) => {
+      managerRef.current?.setShowStatusCommand(show);
+      setShowStatusCommand(show);
+    }, []),
     setPermissionMode: useCallback((mode: PermissionMode) => {
       setPermissionModeState(mode);
       managerRef.current?.setPermissionMode(mode);

package/src/hooks/usePluginManager.ts

@@ -17,6 +17,7 @@ export function usePluginManager(): PluginManagerContextType {
     selectedId: null,
     isLoading: true,
     error: null,
+    successMessage: null,
     searchQuery: "",
   });
 
@@ -34,11 +35,37 @@ export function usePluginManager(): PluginManagerContextType {
 
   const pluginCore = useMemo(() => new PluginCore(), []);
 
+  const clearPluginFeedback = useCallback(() => {
+    setState((prev: PluginManagerState) => ({
+      ...prev,
+      error: null,
+      successMessage: null,
+    }));
+  }, []);
+
+  const setSuccessMessage = useCallback(
+    (message: string) => {
+      setState((prev: PluginManagerState) => ({
+        ...prev,
+        successMessage: message,
+        error: null,
+      }));
+      setTimeout(() => {
+        setState((prev: PluginManagerState) => ({
+          ...prev,
+          successMessage:
+            prev.successMessage === message ? null : prev.successMessage,
+        }));
+      }, 5000);
+    },
+    [setState],
+  );
+
   const refresh = useCallback(async () => {
+    clearPluginFeedback();
     setState((prev: PluginManagerState) => ({
       ...prev,
       isLoading: true,
-      error: null,
     }));
     try {
       const [mks, installed, enabledMap] = await Promise.all([
@@ -115,14 +142,15 @@ export function usePluginManager(): PluginManagerContextType {
 
   const addMarketplace = useCallback(
     async (source: string) => {
+      clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
-        error: null,
       }));
       try {
         await pluginCore.addMarketplace(source);
         await refresh();
+        setSuccessMessage(`Marketplace added successfully`);
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -131,19 +159,20 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
   );
 
   const removeMarketplace = useCallback(
     async (name: string) => {
+      clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
-        error: null,
       }));
       try {
         await pluginCore.removeMarketplace(name);
         await refresh();
+        setSuccessMessage(`Marketplace '${name}' removed successfully`);
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -152,19 +181,20 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
   );
 
   const updateMarketplace = useCallback(
     async (name: string) => {
+      clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
-        error: null,
       }));
       try {
         await pluginCore.updateMarketplace(name);
         await refresh();
+        setSuccessMessage(`Marketplace '${name}' updated successfully`);
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -173,7 +203,7 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
   );
 
   const installPlugin = useCallback(
@@ -182,15 +212,16 @@ export function usePluginManager(): PluginManagerContextType {
       marketplace: string,
       scope: "user" | "project" | "local" = "project",
     ) => {
+      clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
-        error: null,
       }));
       try {
         const pluginId = `${name}@${marketplace}`;
         await pluginCore.installPlugin(pluginId, scope);
         await refresh();
+        setSuccessMessage(`Plugin '${name}' installed successfully`);
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -199,20 +230,21 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
   );
 
   const uninstallPlugin = useCallback(
     async (name: string, marketplace: string) => {
+      clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
-        error: null,
       }));
       try {
         const pluginId = `${name}@${marketplace}`;
         await pluginCore.uninstallPlugin(pluginId);
         await refresh();
+        setSuccessMessage(`Plugin '${name}' uninstalled successfully`);
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -221,20 +253,21 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
   );
 
   const updatePlugin = useCallback(
     async (name: string, marketplace: string) => {
+      clearPluginFeedback();
       setState((prev: PluginManagerState) => ({
         ...prev,
         isLoading: true,
-        error: null,
       }));
       try {
         const pluginId = `${name}@${marketplace}`;
         await pluginCore.updatePlugin(pluginId);
         await refresh();
+        setSuccessMessage(`Plugin '${name}' updated successfully`);
       } catch (error) {
         setState((prev: PluginManagerState) => ({
           ...prev,
@@ -243,7 +276,7 @@ export function usePluginManager(): PluginManagerContextType {
         }));
       }
     },
-    [pluginCore, refresh],
+    [pluginCore, refresh, clearPluginFeedback, setSuccessMessage],
   );
 
   return {
@@ -261,6 +294,7 @@ export function usePluginManager(): PluginManagerContextType {
       uninstallPlugin,
       updatePlugin,
       refresh,
+      clearPluginFeedback,
     },
   };
 }

package/src/hooks/useTasks.ts

@@ -1,6 +1,6 @@
 import { useChat } from "../contexts/useChat.js";
 
 export const useTasks = () => {
-  const { sessionTasks } = useChat();
-  return sessionTasks;
+  const { tasks } = useChat();
+  return tasks;
 };

package/src/index.ts

@@ -1,11 +1,21 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { startCli } from "./cli.js";
-import { Scope } from "wave-agent-sdk";
+import { Scope, generateRandomName } from "wave-agent-sdk";
+import { createWorktree, type WorktreeSession } from "./utils/worktree.js";
+import path from "path";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = path.resolve(__dirname, "../package.json");
+const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+const version = packageJson.version;
 
 // Export main function for external use
 export async function main() {
   try {
+    const originalCwd = process.cwd();
     const argv = await yargs(hideBin(process.argv))
       .option("restore", {
         alias: "r",
@@ -20,6 +30,12 @@ export async function main() {
         type: "boolean",
         global: false,
       })
+      .option("worktree", {
+        alias: "w",
+        description: "Start session in a git worktree (optional name)",
+        type: "string",
+        global: false,
+      })
       .option("print", {
         alias: "p",
         description: "Print response without interactive mode",
@@ -49,6 +65,11 @@ export async function main() {
         type: "string",
         global: false,
       })
+      .option("model", {
+        description: "Specify the AI model to use",
+        type: "string",
+        global: false,
+      })
       .command(
         "plugin",
         "Manage plugins and marketplaces",
@@ -231,6 +252,30 @@ export async function main() {
 
     const tools = parseTools(argv.tools as string | undefined);
 
+    // Resolve plugin directories to absolute paths before any worktree logic
+    const pluginDirs = (argv.pluginDir as string[] | undefined)?.map((dir) =>
+      path.resolve(originalCwd, dir),
+    );
+
+    let worktreeSession: WorktreeSession | undefined;
+    if (
+      argv.worktree !== undefined ||
+      process.argv.includes("-w") ||
+      process.argv.includes("--worktree")
+    ) {
+      let name = argv.worktree as string | undefined;
+      if (!name || name === "") {
+        name = generateRandomName();
+      }
+      worktreeSession = createWorktree(name, originalCwd);
+    }
+
+    const workdir = worktreeSession?.path || originalCwd;
+
+    if (worktreeSession) {
+      process.chdir(workdir);
+    }
+
     // Handle restore session command
     if (
       argv.restore === "" ||
@@ -241,7 +286,7 @@ export async function main() {
       const { startSessionSelectorCli } = await import(
         "./session-selector-cli.js"
       );
-      const selectedSessionId = await startSessionSelectorCli();
+      const selectedSessionId = await startSessionSelectorCli({ workdir });
       if (!selectedSessionId) {
         return;
       }
@@ -249,8 +294,12 @@ export async function main() {
       return startCli({
         restoreSessionId: selectedSessionId,
         bypassPermissions: argv.dangerouslySkipPermissions,
-        pluginDirs: argv.pluginDir as string[],
+        pluginDirs,
         tools,
+        worktreeSession,
+        workdir,
+        version,
+        model: argv.model as string | undefined,
       });
     }
 
@@ -258,22 +307,32 @@ export async function main() {
     if (argv.print !== undefined) {
       const { startPrintCli } = await import("./print-cli.js");
       return startPrintCli({
-        restoreSessionId: argv.restore,
-        continueLastSession: argv.continue,
+        restoreSessionId: argv.restore as string | undefined,
+        continueLastSession: argv.continue as boolean | undefined,
         message: argv.print,
-        showStats: argv.showStats,
-        bypassPermissions: argv.dangerouslySkipPermissions,
-        pluginDirs: argv.pluginDir as string[],
+        showStats: argv.showStats as boolean | undefined,
+        bypassPermissions: argv.dangerouslySkipPermissions as
+          | boolean
+          | undefined,
+        pluginDirs,
         tools,
+        worktreeSession,
+        workdir,
+        version,
+        model: argv.model as string | undefined,
       });
     }
 
     await startCli({
-      restoreSessionId: argv.restore,
-      continueLastSession: argv.continue,
-      bypassPermissions: argv.dangerouslySkipPermissions,
-      pluginDirs: argv.pluginDir as string[],
+      restoreSessionId: argv.restore as string | undefined,
+      continueLastSession: argv.continue as boolean | undefined,
+      bypassPermissions: argv.dangerouslySkipPermissions as boolean | undefined,
+      pluginDirs,
       tools,
+      worktreeSession,
+      workdir,
+      version,
+      model: argv.model as string | undefined,
     });
   } catch (error) {
     console.error("Failed to start WAVE Code:", error);