wave-code 0.17.6 → 0.17.7

package/src/components/InputBox.tsx

@@ -76,6 +76,9 @@ export const InputBox: React.FC<InputBoxProps> = ({
     sessionId,
     workingDirectory,
     askBtw,
+    clearMessages,
+    compact,
+    goalCommand,
     currentModel,
     configuredModels,
     setModel,
@@ -155,6 +158,9 @@ export const InputBox: React.FC<InputBoxProps> = ({
   } = useInputManager({
     onSendMessage: sendMessage,
     onAskBtw: askBtw,
+    onClearMessages: clearMessages,
+    onCompact: compact,
+    onGoalCommand: goalCommand,
     onHasSlashCommand: hasSlashCommand,
     onAbortMessage: abortMessage,
     onBackgroundCurrentTask: backgroundCurrentTask,

package/src/constants/commands.ts

@@ -68,4 +68,22 @@ export const AVAILABLE_COMMANDS: SlashCommand[] = [
     description: "View and manage workflow runs",
     handler: () => {}, // Handler here won't be used, actual processing is in the hook
   },
+  {
+    id: "clear",
+    name: "clear",
+    description: "Clear conversation history and reset session",
+    handler: () => {},
+  },
+  {
+    id: "compact",
+    name: "compact",
+    description: "Compact conversation history to reduce context usage",
+    handler: () => {},
+  },
+  {
+    id: "goal",
+    name: "goal",
+    description: "Set, check, or clear an autonomous goal for the session",
+    handler: () => {},
+  },
 ];

package/src/contexts/useChat.tsx

@@ -53,6 +53,9 @@ export interface ChatContextType {
     longTextMap?: Record<string, string>,
   ) => Promise<void>;
   askBtw: (question: string) => Promise<string>;
+  clearMessages: () => Promise<void>;
+  compact: (instructions?: string) => Promise<void>;
+  goalCommand: (args?: string) => Promise<void>;
   abortMessage: () => void;
   recallQueuedMessage: () => QueuedMessage | null;
   removeQueuedMessageById: (id: string) => boolean;
@@ -623,6 +626,27 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     return await agentRef.current.askBtw(question);
   }, []);
 
+  const clearMessages = useCallback(async () => {
+    await agentRef.current?.clearMessages();
+  }, []);
+
+  const compact = useCallback(async (instructions?: string) => {
+    await agentRef.current?.compact(instructions);
+  }, []);
+
+  const goalCommand = useCallback(async (args?: string) => {
+    const trimmed = args?.trim() ?? "";
+    if (!trimmed) {
+      await agentRef.current?.showGoalStatus();
+    } else if (
+      ["clear", "stop", "off", "reset", "none", "cancel"].includes(trimmed)
+    ) {
+      await agentRef.current?.clearGoal();
+    } else {
+      await agentRef.current?.setGoal(trimmed);
+    }
+  }, []);
+
   // Unified interrupt method, interrupt both AI messages and command execution
   const abortMessage = useCallback(() => {
     agentRef.current?.abortMessage();
@@ -824,6 +848,9 @@ export const ChatProvider: React.FC<ChatProviderProps> = ({
     sessionId,
     sendMessage,
     askBtw,
+    clearMessages,
+    compact,
+    goalCommand,
     abortMessage,
     recallQueuedMessage,
     removeQueuedMessageById,

package/src/hooks/useInputManager.ts

@@ -45,6 +45,9 @@ export const useInputManager = (
     logger,
     hasQueuedMessages: hasQueuedMessagesProp,
     onRecallQueuedMessage,
+    onClearMessages,
+    onCompact,
+    onGoalCommand,
   } = callbacks;
 
   // Handle debounced file search
@@ -212,6 +215,12 @@ export const useInputManager = (
                 dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: true });
               } else if (command === "workflows") {
                 dispatch({ type: "SET_SHOW_WORKFLOW_MANAGER", payload: true });
+              } else if (command === "clear") {
+                await onClearMessages?.();
+              } else if (command === "compact") {
+                await onCompact?.(effect.args);
+              } else if (command === "goal") {
+                await onGoalCommand?.(effect.args);
               }
             }
             break;
@@ -238,6 +247,9 @@ export const useInputManager = (
     logger,
     onHasSlashCommand,
     onRecallQueuedMessage,
+    onClearMessages,
+    onCompact,
+    onGoalCommand,
   ]);
 
   useEffect(() => {

package/src/managers/inputHandlers.ts

@@ -373,6 +373,12 @@ export const handleCommandSelect = (
           dispatch({ type: "SET_SHOW_MODEL_SELECTOR", payload: true });
         } else if (command === "workflows") {
           dispatch({ type: "SET_SHOW_WORKFLOW_MANAGER", payload: true });
+        } else if (command === "clear") {
+          await callbacks.onClearMessages?.();
+        } else if (command === "compact") {
+          await callbacks.onCompact?.();
+        } else if (command === "goal") {
+          await callbacks.onGoalCommand?.();
         }
       }
     })();

package/src/managers/inputReducer.ts

@@ -40,7 +40,7 @@ export type PendingEffect =
   | { type: "PERMISSION_MODE_CHANGE"; mode: PermissionMode }
   | { type: "FETCH_HISTORY" }
   | { type: "PASTE_IMAGE" }
-  | { type: "EXECUTE_COMMAND"; command: string }
+  | { type: "EXECUTE_COMMAND"; command: string; args?: string }
   | { type: "RECALL_QUEUED_MESSAGE" };
 
 export interface InputManagerCallbacks {
@@ -77,6 +77,9 @@ export interface InputManagerCallbacks {
   onBackgroundCurrentTask?: () => void;
   onPermissionModeChange?: (mode: PermissionMode) => void;
   onAskBtw?: (question: string) => Promise<string>;
+  onClearMessages?: () => Promise<void>;
+  onCompact?: (instructions?: string) => Promise<void>;
+  onGoalCommand?: (args?: string) => Promise<void>;
   sessionId?: string;
   workdir?: string;
   getFullMessageThread?: () => Promise<{
@@ -1033,6 +1036,11 @@ export function inputReducer(
               (cmd) => cmd.id === commandName,
             );
             if (isInternalCommand) {
+              const argsText =
+                spaceIndex === -1
+                  ? undefined
+                  : contentWithPlaceholders.substring(spaceIndex + 1).trim() ||
+                    undefined;
               return {
                 ...state,
                 inputText: "",
@@ -1042,6 +1050,7 @@ export function inputReducer(
                 pendingEffect: {
                   type: "EXECUTE_COMMAND",
                   command: commandName,
+                  args: argsText,
                 },
               };
             }