wave-code 0.0.5 → 0.0.8

package/src/components/ToolResultDisplay.tsx

@@ -1,6 +1,7 @@
 import React from "react";
 import { Box, Text } from "ink";
 import type { ToolBlock } from "wave-agent-sdk";
+import { DiffDisplay } from "./DiffDisplay.js";
 
 interface ToolResultDisplayProps {
   block: ToolBlock;
@@ -11,23 +12,23 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
   block,
   isExpanded = false,
 }) => {
-  const { parameters, result, compactParams, isRunning, success, error, name } =
+  const { parameters, result, compactParams, stage, success, error, name } =
     block;
 
   // Directly use compactParams
   // (no change needed as we destructured it above)
 
   const getStatusColor = () => {
-    if (isRunning) return "yellow";
+    if (stage === "running") 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 (stage === "running") return "🔄";
     if (success) return "";
-    if (error || success === false) return "❌ Failed";
+    if (error || success === false) return "❌";
     return ""; // Don't display text for unknown state
   };
 
@@ -70,7 +71,7 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
         <Text color="white">{toolName}</Text>
         {/* Display compactParams in collapsed state */}
         {!isExpanded && compactParams && (
-          <Text color="gray"> ({compactParams})</Text>
+          <Text color="gray"> {compactParams}</Text>
         )}
         <Text color={getStatusColor()}> {getStatusText()}</Text>
         {/* Display image indicator */}
@@ -133,6 +134,9 @@ export const ToolResultDisplay: React.FC<ToolResultDisplayProps> = ({
           </Text>
         </Box>
       )}
+
+      {/* Diff display - handled by DiffDisplay component */}
+      <DiffDisplay toolBlock={block} />
     </Box>
   );
 };

package/src/contexts/useChat.tsx

@@ -13,9 +13,14 @@ import type {
   McpServerStatus,
   BackgroundShell,
   SlashCommand,
-  Usage,
+  PermissionDecision,
+  PermissionMode,
+} from "wave-agent-sdk";
+import {
+  Agent,
+  AgentCallbacks,
+  type ToolPermissionContext,
 } from "wave-agent-sdk";
-import { Agent, AgentCallbacks } from "wave-agent-sdk";
 import { logger } from "../utils/logger.js";
 import { displayUsageSummary } from "../utils/usageSummary.js";
 
@@ -51,8 +56,21 @@ export interface ChatContextType {
   // Slash Command functionality
   slashCommands: SlashCommand[];
   hasSlashCommand: (commandId: string) => boolean;
-  // Usage tracking
-  usages: Usage[];
+  // Subagent messages
+  subagentMessages: Record<string, Message[]>;
+  // Permission functionality
+  permissionMode: PermissionMode;
+  setPermissionMode: (mode: PermissionMode) => void;
+  // Permission confirmation state
+  isConfirmationVisible: boolean;
+  confirmingTool?: { name: string; input?: Record<string, unknown> };
+  showConfirmation: (
+    toolName: string,
+    toolInput?: Record<string, unknown>,
+  ) => Promise<PermissionDecision>;
+  hideConfirmation: () => void;
+  handleConfirmationDecision: (decision: PermissionDecision) => void;
+  handleConfirmationCancel: () => void;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -67,9 +85,13 @@ export const useChat = () => {
 
 export interface ChatProviderProps {
   children: React.ReactNode;
+  bypassPermissions?: boolean;
 }
 
-export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
+export const ChatProvider: React.FC<ChatProviderProps> = ({
+  children,
+  bypassPermissions,
+}) => {
   const { restoreSessionId, continueLastSession } = useAppConfig();
 
   // Message Display State
@@ -95,17 +117,57 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
   // Command state
   const [slashCommands, setSlashCommands] = useState<SlashCommand[]>([]);
 
-  // Usage tracking state
-  const [usages, setUsages] = useState<Usage[]>([]);
+  // Subagent messages state
+  const [subagentMessages, setSubagentMessages] = useState<
+    Record<string, Message[]>
+  >({});
+
+  // Permission state
+  const [permissionMode, setPermissionModeState] =
+    useState<PermissionMode>("default");
+
+  // Confirmation state with queue-based architecture
+  const [isConfirmationVisible, setIsConfirmationVisible] = useState(false);
+  const [confirmingTool, setConfirmingTool] = useState<
+    { name: string; input?: Record<string, unknown> } | undefined
+  >();
+  const [confirmationQueue, setConfirmationQueue] = useState<
+    Array<{
+      toolName: string;
+      toolInput?: Record<string, unknown>;
+      resolver: (decision: PermissionDecision) => void;
+      reject: () => void;
+    }>
+  >([]);
+  const [currentConfirmation, setCurrentConfirmation] = useState<{
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+    resolver: (decision: PermissionDecision) => void;
+    reject: () => void;
+  } | null>(null);
 
   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);
-    }
-  });
+  // Permission confirmation methods with queue support
+  const showConfirmation = useCallback(
+    async (
+      toolName: string,
+      toolInput?: Record<string, unknown>,
+    ): Promise<PermissionDecision> => {
+      return new Promise<PermissionDecision>((resolve, reject) => {
+        const queueItem = {
+          toolName,
+          toolInput,
+          resolver: resolve,
+          reject,
+        };
+
+        setConfirmationQueue((prev) => [...prev, queueItem]);
+        // processNextConfirmation will be called via useEffect
+      });
+    },
+    [],
+  );
 
   // Initialize AI manager
   useEffect(() => {
@@ -118,7 +180,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
           setMcpServers([...servers]);
         },
         onSessionIdChange: (sessionId) => {
-          setSessionId(sessionId);
+          process.stdout.write("\x1Bc", () => {
+            setSessionId(sessionId);
+          });
         },
         onLatestTotalTokensChange: (tokens) => {
           setlatestTotalTokens(tokens);
@@ -132,17 +196,47 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
         onShellsChange: (shells) => {
           setBackgroundShells([...shells]);
         },
-        onUsagesChange: (newUsages) => {
-          setUsages([...newUsages]);
+        onSubagentMessagesChange: (subagentId, messages) => {
+          logger.debug("onSubagentMessagesChange", subagentId, messages.length);
+          setSubagentMessages((prev) => ({
+            ...prev,
+            [subagentId]: [...messages],
+          }));
+        },
+        onPermissionModeChange: (mode) => {
+          setPermissionModeState(mode);
         },
       };
 
       try {
+        // Create the permission callback inside the try block to access showConfirmation
+        const permissionCallback = bypassPermissions
+          ? undefined
+          : async (
+              context: ToolPermissionContext,
+            ): Promise<PermissionDecision> => {
+              try {
+                return await showConfirmation(
+                  context.toolName,
+                  context.toolInput,
+                );
+              } catch {
+                // If confirmation was cancelled or failed, deny the operation
+                return {
+                  behavior: "deny",
+                  message: "Operation cancelled by user",
+                };
+              }
+            };
+
         const agent = await Agent.create({
           callbacks,
           restoreSessionId,
           continueLastSession,
           logger,
+          permissionMode: bypassPermissions ? "bypassPermissions" : undefined,
+          canUseTool: permissionCallback,
+          stream: false, // 关闭流式模式
         });
 
         agentRef.current = agent;
@@ -155,6 +249,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
         setIsCommandRunning(agent.isCommandRunning);
         setIsCompressing(agent.isCompressing);
         setUserInputHistory(agent.userInputHistory);
+        setPermissionModeState(agent.getPermissionMode());
 
         // Get initial MCP servers state
         const mcpServers = agent.getMcpServers?.() || [];
@@ -163,16 +258,18 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
         // Get initial commands
         const agentSlashCommands = agent.getSlashCommands?.() || [];
         setSlashCommands(agentSlashCommands);
-
-        // Get initial usages
-        setUsages(agent.usages);
       } catch (error) {
         console.error("Failed to initialize AI manager:", error);
       }
     };
 
     initializeAgent();
-  }, [restoreSessionId, continueLastSession]);
+  }, [
+    restoreSessionId,
+    continueLastSession,
+    bypassPermissions,
+    showConfirmation,
+  ]);
 
   // Cleanup on unmount
   useEffect(() => {
@@ -269,6 +366,17 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     [],
   );
 
+  // Permission management methods
+  const setPermissionMode = useCallback((mode: PermissionMode) => {
+    setPermissionModeState((prev) => {
+      if (prev === mode) return prev;
+      if (agentRef.current && agentRef.current.getPermissionMode() !== mode) {
+        agentRef.current.setPermissionMode(mode);
+      }
+      return mode;
+    });
+  }, []);
+
   // MCP management methods - delegate to Agent
   const connectMcpServer = useCallback(async (serverName: string) => {
     return (await agentRef.current?.connectMcpServer(serverName)) ?? false;
@@ -294,6 +402,63 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     return agentRef.current.hasSlashCommand(commandId);
   }, []);
 
+  // Queue processing helper
+  const processNextConfirmation = useCallback(() => {
+    if (confirmationQueue.length > 0 && !isConfirmationVisible) {
+      const next = confirmationQueue[0];
+      setCurrentConfirmation(next);
+      setConfirmingTool({ name: next.toolName, input: next.toolInput });
+      setIsConfirmationVisible(true);
+      setConfirmationQueue((prev) => prev.slice(1));
+    }
+  }, [confirmationQueue, isConfirmationVisible]);
+
+  // Process queue when queue changes or confirmation is hidden
+  useEffect(() => {
+    processNextConfirmation();
+  }, [processNextConfirmation]);
+
+  const hideConfirmation = useCallback(() => {
+    setIsConfirmationVisible(false);
+    setConfirmingTool(undefined);
+    setCurrentConfirmation(null);
+  }, []);
+
+  const handleConfirmationDecision = useCallback(
+    (decision: PermissionDecision) => {
+      if (currentConfirmation) {
+        currentConfirmation.resolver(decision);
+      }
+      hideConfirmation();
+    },
+    [currentConfirmation, hideConfirmation],
+  );
+
+  const handleConfirmationCancel = useCallback(() => {
+    if (currentConfirmation) {
+      currentConfirmation.reject();
+    }
+    hideConfirmation();
+  }, [currentConfirmation, hideConfirmation]);
+
+  // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
+  useInput((input, key) => {
+    if (key.ctrl && input === "o") {
+      // Clear terminal screen when expanded state changes
+      process.stdout.write("\x1Bc", () => {
+        setIsExpanded((prev) => {
+          const newExpanded = !prev;
+          return newExpanded;
+        });
+      });
+    }
+
+    // Handle ESC key to cancel confirmation
+    if (key.escape && isConfirmationVisible) {
+      handleConfirmationCancel();
+    }
+  });
+
   const contextValue: ChatContextType = {
     messages,
     isLoading,
@@ -314,7 +479,15 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({ children }) => {
     killBackgroundShell,
     slashCommands,
     hasSlashCommand,
-    usages,
+    subagentMessages,
+    permissionMode,
+    setPermissionMode,
+    isConfirmationVisible,
+    confirmingTool,
+    showConfirmation,
+    hideConfirmation,
+    handleConfirmationDecision,
+    handleConfirmationCancel,
   };
 
   return (

package/src/hooks/useInputManager.ts

@@ -6,11 +6,14 @@ import {
   AttachedImage,
 } from "../managers/InputManager.js";
 import { FileItem } from "../components/FileSelector.js";
+import { PermissionMode } from "wave-agent-sdk";
+import { logger } from "../utils/logger.js";
 
 export const useInputManager = (
   callbacks: Partial<InputManagerCallbacks> = {},
 ) => {
   const managerRef = useRef<InputManager | null>(null);
+  const [isManagerReady, setIsManagerReady] = useState(false);
 
   // React state that mirrors InputManager state
   const [inputText, setInputText] = useState("");
@@ -37,6 +40,8 @@ export const useInputManager = (
   });
   const [showBashManager, setShowBashManager] = useState(false);
   const [showMcpManager, setShowMcpManager] = useState(false);
+  const [permissionMode, setPermissionModeState] =
+    useState<PermissionMode>("default");
   const [attachedImages, setAttachedImages] = useState<AttachedImage[]>([]);
 
   // Create InputManager on mount and update callbacks when they change
@@ -44,6 +49,7 @@ export const useInputManager = (
     if (!managerRef.current) {
       // Create InputManager on first mount
       const manager = new InputManager({
+        logger,
         onInputTextChange: setInputText,
         onCursorPositionChange: setCursorPosition,
         onFileSelectorStateChange: (show, files, query, position) => {
@@ -64,14 +70,22 @@ export const useInputManager = (
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
         },
+        onPermissionModeChange: (mode) => {
+          setPermissionModeState(mode);
+          callbacks.onPermissionModeChange?.(mode);
+        },
         onImagesStateChange: setAttachedImages,
+        onShowBashManager: () => setShowBashManager(true),
+        onShowMcpManager: () => setShowMcpManager(true),
         ...callbacks,
       });
 
       managerRef.current = manager;
+      setIsManagerReady(true);
     } else {
       // Update callbacks on existing manager
       managerRef.current.updateCallbacks({
+        logger,
         onInputTextChange: setInputText,
         onCursorPositionChange: setCursorPosition,
         onFileSelectorStateChange: (show, files, query, position) => {
@@ -92,7 +106,13 @@ export const useInputManager = (
         onMcpManagerStateChange: (show) => {
           setShowMcpManager(show);
         },
+        onPermissionModeChange: (mode) => {
+          setPermissionModeState(mode);
+          callbacks.onPermissionModeChange?.(mode);
+        },
         onImagesStateChange: setAttachedImages,
+        onShowBashManager: () => setShowBashManager(true),
+        onShowMcpManager: () => setShowMcpManager(true),
         ...callbacks,
       });
     }
@@ -253,9 +273,12 @@ export const useInputManager = (
     managerRef.current?.activateMemoryTypeSelector(message);
   }, []);
 
-  const handleMemoryTypeSelect = useCallback((type: "project" | "user") => {
-    managerRef.current?.handleMemoryTypeSelect(type);
-  }, []);
+  const handleMemoryTypeSelect = useCallback(
+    async (type: "project" | "user") => {
+      await managerRef.current?.handleMemoryTypeSelect(type);
+    },
+    [],
+  );
 
   const handleCancelMemoryTypeSelect = useCallback(() => {
     managerRef.current?.handleCancelMemoryTypeSelect();
@@ -296,6 +319,11 @@ export const useInputManager = (
     managerRef.current?.setCursorPosition(position);
   }, []);
 
+  // Complex handlers that combine multiple operations
+  const handleBashHistoryExecuteAndSend = useCallback((command: string) => {
+    managerRef.current?.handleBashHistoryExecuteAndSend(command);
+  }, []);
+
   return {
     // State
     inputText,
@@ -314,7 +342,9 @@ export const useInputManager = (
     memoryMessage: memoryTypeSelectorState.message,
     showBashManager,
     showMcpManager,
+    permissionMode,
     attachedImages,
+    isManagerReady,
 
     // Methods
     insertTextAtCursor,
@@ -369,6 +399,10 @@ export const useInputManager = (
     setShowMcpManager: useCallback((show: boolean) => {
       managerRef.current?.setShowMcpManager(show);
     }, []),
+    setPermissionMode: useCallback((mode: PermissionMode) => {
+      setPermissionModeState(mode);
+      managerRef.current?.setPermissionMode(mode);
+    }, []),
 
     // Image management
     addImage: useCallback((imagePath: string, mimeType: string) => {
@@ -409,6 +443,9 @@ export const useInputManager = (
       managerRef.current?.clearLongTextMap();
     }, []),
 
+    // Complex handlers combining multiple operations
+    handleBashHistoryExecuteAndSend,
+
     // Main input handler
     handleInput: useCallback(
       async (

package/src/index.ts

@@ -1,7 +1,11 @@
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { startCli } from "./cli.js";
-import { listSessions } from "wave-agent-sdk";
+import {
+  listSessions,
+  getSessionFilePath,
+  getFirstMessageContent,
+} from "wave-agent-sdk";
 
 // Export main function for external use
 export async function main() {
@@ -21,17 +25,29 @@ export async function main() {
       description: "Print response without interactive mode",
       type: "string",
     })
+    .option("show-stats", {
+      description: "Show timing and usage statistics in print mode",
+      type: "boolean",
+    })
     .option("list-sessions", {
       description: "List all available sessions",
       type: "boolean",
     })
+    .option("dangerously-skip-permissions", {
+      description: "Skip all permission checks (dangerous)",
+      type: "boolean",
+      default: false,
+    })
     .version()
     .alias("v", "version")
     .example("$0", "Start CLI with default settings")
     .example("$0 --restore session_123", "Restore specific session")
     .example("$0 --continue", "Continue from last session")
     .example("$0 --print 'Hello'", "Send message in print mode")
-    .example("$0 -p 'Hello'", "Send message in print mode (short)")
+    .example(
+      "$0 -p 'Hello' --show-stats",
+      "Send message in print mode with statistics",
+    )
     .example("$0 --list-sessions", "List all available sessions")
     .help("h")
     .parseAsync();
@@ -50,18 +66,39 @@ export async function main() {
       console.log(`Available sessions for: ${currentWorkdir}`);
       console.log("==========================================");
 
-      for (const session of sessions) {
-        const startedAt = new Date(session.startedAt).toLocaleString();
+      // Get last 5 sessions
+      const lastSessions = sessions.slice(0, 5);
+
+      for (const session of lastSessions) {
         const lastActiveAt = new Date(session.lastActiveAt).toLocaleString();
+        const filePath = await getSessionFilePath(session.id, session.workdir);
+
+        // Get first message content
+        const firstMessageContent = await getFirstMessageContent(
+          session.id,
+          session.workdir,
+        );
+
+        // Truncate content if too long
+        let truncatedContent =
+          firstMessageContent || "No first message content";
+        if (truncatedContent.length > 30) {
+          truncatedContent = truncatedContent.substring(0, 30) + "...";
+        }
 
         console.log(`ID: ${session.id}`);
         console.log(`  Workdir: ${session.workdir}`);
-        console.log(`  Started: ${startedAt}`);
+        console.log(`  File Path: ${filePath}`);
         console.log(`  Last Active: ${lastActiveAt}`);
         console.log(`  Last Message Tokens: ${session.latestTotalTokens}`);
+        console.log(`  First Message: ${truncatedContent}`);
         console.log("");
       }
 
+      if (sessions.length > 5) {
+        console.log(`... and ${sessions.length - 5} more sessions`);
+      }
+
       return;
     } catch (error) {
       console.error("Failed to list sessions:", error);
@@ -76,12 +113,15 @@ export async function main() {
       restoreSessionId: argv.restore,
       continueLastSession: argv.continue,
       message: argv.print,
+      showStats: argv.showStats,
+      bypassPermissions: argv.dangerouslySkipPermissions,
     });
   }
 
   await startCli({
     restoreSessionId: argv.restore,
     continueLastSession: argv.continue,
+    bypassPermissions: argv.dangerouslySkipPermissions,
   });
 }