wave-code 0.11.6 → 0.12.0

package/src/components/SlashDisplay.tsx

@@ -0,0 +1,70 @@
+import React from "react";
+import { Box, Text } from "ink";
+import type { SlashBlock } from "wave-agent-sdk";
+
+interface SlashDisplayProps {
+  block: SlashBlock;
+  isExpanded?: boolean;
+}
+
+export const SlashDisplay: React.FC<SlashDisplayProps> = ({
+  block,
+  isExpanded = false,
+}) => {
+  const { command, args, stage, shortResult, error, result } = block;
+
+  const getStatusColor = () => {
+    switch (stage) {
+      case "running":
+        return "yellow";
+      case "success":
+        return "green";
+      case "error":
+        return "red";
+      case "aborted":
+        return "gray";
+      default:
+        return "white";
+    }
+  };
+
+  return (
+    <Box flexDirection="column">
+      <Box>
+        <Text color={getStatusColor()}>/ </Text>
+        <Text color="white">{command}</Text>
+        {args && <Text color="gray"> {args}</Text>}
+      </Box>
+
+      {/* Display shortResult in collapsed state */}
+      {!isExpanded && shortResult && !error && (
+        <Box paddingLeft={2} flexDirection="column">
+          {shortResult.split("\n").map((line, index) => (
+            <Text key={index} color="gray">
+              {line}
+            </Text>
+          ))}
+        </Box>
+      )}
+
+      {/* Display complete result in expanded state */}
+      {isExpanded && result && (
+        <Box paddingLeft={2} flexDirection="column">
+          <Text color="cyan" bold>
+            Result:
+          </Text>
+          <Text color="white">{result}</Text>
+        </Box>
+      )}
+
+      {/* Error information always displayed */}
+      {error && (
+        <Box paddingLeft={2}>
+          <Text color="red">
+            Error: {typeof error === "string" ? error : String(error)}
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+};

package/src/components/StatusLine.tsx

@@ -0,0 +1,36 @@
+import React from "react";
+import { Box, Text } from "ink";
+
+export interface StatusLineProps {
+  permissionMode: string;
+  isShellCommand: boolean;
+  isBtwActive: boolean;
+}
+
+export const StatusLine: React.FC<StatusLineProps> = ({
+  permissionMode,
+  isShellCommand,
+  isBtwActive,
+}) => {
+  return (
+    <Box paddingRight={1} justifyContent="space-between" width="100%">
+      {isBtwActive ? (
+        <Text color="gray">
+          Mode: <Text color="cyan">BTW</Text> (ESC to dismiss)
+        </Text>
+      ) : isShellCommand ? (
+        <Text color="gray">
+          Shell: <Text color="yellow">Run shell command</Text>
+        </Text>
+      ) : (
+        <Text color="gray">
+          Mode:{" "}
+          <Text color={permissionMode === "plan" ? "yellow" : "cyan"}>
+            {permissionMode}
+          </Text>{" "}
+          (Shift+Tab to cycle)
+        </Text>
+      )}
+    </Box>
+  );
+};

package/src/constants/commands.ts

@@ -38,4 +38,16 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "View and manage plugins",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "btw",
+    name: "btw",
+    description: "Ask a side question without tool use",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
+  {
+    id: "model",
+    name: "model",
+    description: "Switch between configured AI models",
+    handler: () => {}, // Handler here won't be used, actual processing is in the hook
+  },
 ];

package/src/contexts/useChat.tsx

@@ -51,8 +51,14 @@ export interface ChatContextType {
     images?: Array<{ path: string; mimeType: string }>,
     longTextMap?: Record<string, string>,
   ) => Promise<void>;
+  askBtw: (question: string) => Promise<string>;
   abortMessage: () => void;
   latestTotalTokens: number;
+  // Model functionality
+  currentModel: string;
+  configuredModels: string[];
+  getConfiguredModels: () => string[];
+  setModel: (model: string) => void;
   // MCP functionality
   mcpServers: McpServerStatus[];
   connectMcpServer: (serverName: string) => Promise<boolean>;
@@ -77,6 +83,7 @@ export interface ChatContextType {
   // Permission functionality
   permissionMode: PermissionMode;
   setPermissionMode: (mode: PermissionMode) => void;
+  allowBypassInCycle: boolean;
   // Permission confirmation state
   isConfirmationVisible: boolean;
   confirmingTool?: {
@@ -113,6 +120,10 @@ export interface ChatContextType {
   workingDirectory: string;
   version?: string;
   workdir?: string;
+  btwState: import("../managers/inputReducer.js").BtwState;
+  setBtwState: (
+    payload: Partial<import("../managers/inputReducer.js").BtwState>,
+  ) => void;
 }
 
 const ChatContext = createContext<ChatContextType | null>(null);
@@ -170,6 +181,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   const [sessionId, setSessionId] = useState("");
   const [isCommandRunning, setIsCommandRunning] = useState(false);
   const [isCompressing, setIsCompressing] = useState(false);
+  const [currentModel, setCurrentModelState] = useState("");
+  const [configuredModels, setConfiguredModels] = useState<string[]>([]);
 
   // MCP State
   const [mcpServers, setMcpServers] = useState<McpServerStatus[]>([]);
@@ -235,8 +248,32 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
   // Status metadata state
   const [workingDirectory, setWorkingDirectory] = useState("");
 
+  // /btw state
+  const [btwState, setBtwStateInternal] = useState<
+    import("../managers/inputReducer.js").BtwState
+  >({
+    isActive: false,
+    question: "",
+    isLoading: false,
+  });
+
+  const setBtwState = useCallback(
+    (payload: Partial<import("../managers/inputReducer.js").BtwState>) => {
+      setBtwStateInternal((prev) => {
+        const newState = { ...prev, ...payload };
+        if (process.env.NODE_ENV === "test") {
+          // console.log("setBtwState", newState);
+        }
+        return newState;
+      });
+    },
+    [],
+  );
+
   // Confirmation too tall state
   const [wasLastDetailsTooTall, setWasLastDetailsTooTall] = useState(0);
+  const allowBypassInCycle =
+    !!bypassPermissions || initialPermissionMode === "bypassPermissions";
 
   const agentRef = useRef<Agent | null>(null);
   const taskUpdateTimerRef = useRef<NodeJS.Timeout | null>(null);
@@ -327,6 +364,12 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         onPermissionModeChange: (mode) => {
           setPermissionModeState(mode);
         },
+        onModelChange: (model) => {
+          setCurrentModelState(model);
+        },
+        onConfiguredModelsChange: (models) => {
+          setConfiguredModels(models);
+        },
       };
 
       try {
@@ -384,6 +427,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
         setIsCompressing(agent.isCompressing);
         setPermissionModeState(agent.getPermissionMode());
         setWorkingDirectory(agent.workingDirectory);
+        setCurrentModelState(agent.getModelConfig().model);
+        setConfiguredModels(agent.getConfiguredModels());
 
         // Get initial MCP servers state
         const mcpServers = agent.getMcpServers?.() || [];
@@ -497,6 +542,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     [isLoading, isCommandRunning],
   );
 
+  const askBtw = useCallback(async (question: string) => {
+    if (!agentRef.current) {
+      throw new Error("Agent not initialized");
+    }
+    return await agentRef.current.askBtw(question);
+  }, []);
+
   // Process queued messages when idle
   useEffect(() => {
     if (!isLoading && !isCommandRunning && queuedMessages.length > 0) {
@@ -635,6 +687,20 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     return agentRef.current.getModelConfig();
   }, []);
 
+  const getConfiguredModels = useCallback(() => {
+    if (!agentRef.current) {
+      return [];
+    }
+    return agentRef.current.getConfiguredModels();
+  }, []);
+
+  const setModel = useCallback((model: string) => {
+    if (agentRef.current) {
+      agentRef.current.setModel(model);
+      setCurrentModelState(model);
+    }
+  }, []);
+
   // Listen for Ctrl+O hotkey to toggle collapse/expand state and ESC to cancel confirmation
   useInput((input, key) => {
     if (key.ctrl && input === "o") {
@@ -664,10 +730,17 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
       setIsTaskListVisible((prev) => !prev);
     }
 
-    // Handle ESC key to cancel confirmation
+    // Handle ESC key to cancel confirmation or dismiss BTW
     if (key.escape) {
       if (isConfirmationVisible) {
         handleConfirmationCancel();
+      } else if (btwState.isActive) {
+        setBtwState({
+          isActive: false,
+          question: "",
+          answer: undefined,
+          isLoading: false,
+        });
       }
     }
   });
@@ -682,8 +755,13 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     queuedMessages,
     sessionId,
     sendMessage,
+    askBtw,
     abortMessage,
     latestTotalTokens,
+    currentModel,
+    configuredModels,
+    getConfiguredModels,
+    setModel,
     isCompressing,
     mcpServers,
     connectMcpServer,
@@ -698,6 +776,7 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     subagentLatestTokens,
     permissionMode,
     setPermissionMode,
+    allowBypassInCycle,
     isConfirmationVisible,
     confirmingTool,
     showConfirmation,
@@ -715,6 +794,8 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     workingDirectory,
     version,
     workdir,
+    btwState,
+    setBtwState,
   };
 
   return (

package/src/hooks/useInputManager.ts

@@ -149,10 +149,55 @@ export const useInputManager = (
     callbacksRef.current.onPluginManagerStateChange?.(state.showPluginManager);
   }, [state.showPluginManager]);
 
+  useEffect(() => {
+    callbacksRef.current.onModelSelectorStateChange?.(state.showModelSelector);
+  }, [state.showModelSelector]);
+
   useEffect(() => {
     callbacksRef.current.onImagesStateChange?.(state.attachedImages);
   }, [state.attachedImages]);
 
+  useEffect(() => {
+    if (callbacksRef.current.onBtwStateChange) {
+      callbacksRef.current.onBtwStateChange(state.btwState);
+    }
+  }, [state.btwState]);
+
+  // Handle /btw side question
+  useEffect(() => {
+    if (
+      state.btwState.isActive &&
+      state.btwState.isLoading &&
+      state.btwState.question
+    ) {
+      const askBtw = async () => {
+        try {
+          const answer = await callbacksRef.current.onAskBtw?.(
+            state.btwState.question,
+          );
+          dispatch({
+            type: "SET_BTW_STATE",
+            payload: { answer, isLoading: false },
+          });
+        } catch (error) {
+          console.error("Failed to ask side question:", error);
+          dispatch({
+            type: "SET_BTW_STATE",
+            payload: {
+              answer: "Error: Failed to get an answer for your side question.",
+              isLoading: false,
+            },
+          });
+        }
+      };
+      askBtw();
+    }
+  }, [
+    state.btwState.isActive,
+    state.btwState.isLoading,
+    state.btwState.question,
+  ]);
+
   // Methods
   const insertTextAtCursor = useCallback((text: string) => {
     dispatch({ type: "INSERT_TEXT", payload: text });
@@ -302,11 +347,30 @@ export const useInputManager = (
     dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: show });
   }, []);
 
+  const setShowModelSelector = useCallback((show: boolean) => {
+    dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: show });
+  }, []);
+
   const setPermissionMode = useCallback((mode: PermissionMode) => {
     dispatch({ type: "SET_PERMISSION_MODE", payload: mode });
     callbacksRef.current.onPermissionModeChange?.(mode);
   }, []);
 
+  const setAllowBypassInCycle = useCallback((allow: boolean) => {
+    dispatch({ type: "SET_ALLOW_BYPASS_IN_CYCLE", payload: allow });
+  }, []);
+
+  const setBtwState = useCallback(
+    (payload: Partial<import("../managers/inputReducer.js").BtwState>) => {
+      if (callbacksRef.current.onBtwStateChange) {
+        callbacksRef.current.onBtwStateChange(payload);
+      } else {
+        dispatch({ type: "SET_BTW_STATE", payload });
+      }
+    },
+    [],
+  );
+
   const addImage = useCallback((imagePath: string, mimeType: string) => {
     dispatch({ type: "ADD_IMAGE", payload: { path: imagePath, mimeType } });
   }, []);
@@ -396,8 +460,10 @@ export const useInputManager = (
     showHelp: state.showHelp,
     showStatusCommand: state.showStatusCommand,
     showPluginManager: state.showPluginManager,
+    showModelSelector: state.showModelSelector,
     permissionMode: state.permissionMode,
     attachedImages: state.attachedImages,
+    btwState: state.btwState,
     isManagerReady: true,
 
     // Methods
@@ -436,7 +502,10 @@ export const useInputManager = (
     setShowHelp,
     setShowStatusCommand,
     setShowPluginManager,
+    setShowModelSelector,
     setPermissionMode,
+    setAllowBypassInCycle,
+    setBtwState,
 
     // Image management
     addImage,

package/src/index.ts

@@ -228,6 +228,15 @@ export async function main() {
             },
           );
       })
+      .command(
+        "update",
+        "Update WAVE Code to the latest version",
+        {},
+        async () => {
+          const { updateCommand } = await import("./commands/update.js");
+          await updateCommand();
+        },
+      )
       .version()
       .alias("v", "version")
       .example("$0", "Start CLI with default settings")

package/src/managers/inputHandlers.ts

@@ -55,6 +55,30 @@ export const handleSubmit = async (
       .replace(imageRegex, "")
       .trim();
 
+    if (
+      contentWithPlaceholders === "/btw" ||
+      contentWithPlaceholders.startsWith("/btw ")
+    ) {
+      const question = contentWithPlaceholders.startsWith("/btw ")
+        ? contentWithPlaceholders.substring(5).trim()
+        : "";
+
+      const payload = {
+        isActive: true,
+        question,
+        isLoading: question !== "",
+      };
+
+      dispatch({
+        type: "SET_BTW_STATE",
+        payload,
+      });
+      dispatch({ type: "CLEAR_INPUT" });
+      dispatch({ type: "RESET_HISTORY_NAVIGATION" });
+      dispatch({ type: "CLEAR_LONG_TEXT_MAP" });
+      return;
+    }
+
     PromptHistoryManager.addEntry(
       contentWithPlaceholders,
       callbacks.sessionId,
@@ -100,8 +124,12 @@ export const cyclePermissionMode = (
   currentMode: PermissionMode,
   dispatch: React.Dispatch<InputAction>,
   callbacks: Partial<InputManagerCallbacks>,
+  allowBypassInCycle: boolean = false,
 ) => {
   const modes: PermissionMode[] = ["default", "acceptEdits", "plan"];
+  if (allowBypassInCycle) {
+    modes.push("bypassPermissions");
+  }
   const currentIndex = modes.indexOf(currentMode);
   const nextIndex = currentIndex === -1 ? 0 : (currentIndex + 1) % modes.length;
   const nextMode = modes[nextIndex];
@@ -342,6 +370,13 @@ export const handleCommandSelect = (
           dispatch({ type: "SET_SHOW_STATUS_COMMAND", payload: true });
         } else if (command === "plugin") {
           dispatch({ type: "SET_SHOW_PLUGIN_MANAGER", payload: true });
+        } else if (command === "model") {
+          dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: true });
+        } else if (command === "btw") {
+          dispatch({
+            type: "SET_BTW_STATE",
+            payload: { isActive: true, question: "", isLoading: false },
+          });
         }
       }
     })();
@@ -461,8 +496,10 @@ export const handleSelectorInput = (
   if (input === " ") {
     if (state.showFileSelector) {
       dispatch({ type: "CANCEL_FILE_SELECTOR" });
+      return false;
     } else if (state.showCommandSelector) {
       dispatch({ type: "CANCEL_COMMAND_SELECTOR" });
+      return false;
     }
   }
 
@@ -667,6 +704,46 @@ export const handleInput = async (
     return true;
   }
 
+  if (state.btwState.isActive) {
+    if (key.escape) {
+      dispatch({
+        type: "SET_BTW_STATE",
+        payload: {
+          isActive: false,
+          question: "",
+          answer: undefined,
+          isLoading: false,
+        },
+      });
+      return true;
+    }
+
+    if (key.return) {
+      if (state.inputText.trim() && !state.btwState.isLoading) {
+        dispatch({
+          type: "SET_BTW_STATE",
+          payload: {
+            question: state.inputText.trim(),
+            isLoading: true,
+            answer: undefined,
+          },
+        });
+        dispatch({ type: "CLEAR_INPUT" });
+      }
+      return true;
+    }
+
+    // Handle normal input for the question
+    return await handleNormalInput(
+      state,
+      dispatch,
+      callbacks,
+      input,
+      key,
+      clearImages,
+    );
+  }
+
   if (key.escape) {
     if (
       !(
@@ -678,7 +755,9 @@ export const handleInput = async (
         state.showRewindManager ||
         state.showHelp ||
         state.showStatusCommand ||
-        state.showPluginManager
+        state.showPluginManager ||
+        state.showModelSelector ||
+        state.btwState.isActive
       )
     ) {
       callbacks.onAbortMessage?.();
@@ -687,7 +766,12 @@ export const handleInput = async (
   }
 
   if (key.tab && key.shift) {
-    cyclePermissionMode(state.permissionMode, dispatch, callbacks);
+    cyclePermissionMode(
+      state.permissionMode,
+      dispatch,
+      callbacks,
+      state.allowBypassInCycle,
+    );
     return true;
   }
 
@@ -700,7 +784,9 @@ export const handleInput = async (
     state.showRewindManager ||
     state.showHelp ||
     state.showStatusCommand ||
-    state.showPluginManager
+    state.showPluginManager ||
+    state.showModelSelector ||
+    state.btwState.isActive
   ) {
     if (
       state.showBackgroundTaskManager ||
@@ -708,7 +794,9 @@ export const handleInput = async (
       state.showRewindManager ||
       state.showHelp ||
       state.showStatusCommand ||
-      state.showPluginManager
+      state.showPluginManager ||
+      state.showModelSelector ||
+      state.btwState.isActive
     ) {
       return true;
     }