🤖 fix: unify chat input and commands flow

Author: ammar-agent

src/browser/App.tsx

@@ -28,7 +28,7 @@ import { buildCoreSources, type BuildSourcesParams } from "./utils/commands/sour
 
 import type { ThinkingLevel } from "@/common/types/thinking";
 import { CUSTOM_EVENTS } from "@/common/constants/events";
-import { isWorkspaceForkSwitchEvent } from "./utils/workspaceFork";
+import { isWorkspaceForkSwitchEvent } from "./utils/chatCommands";
 import { getThinkingLevelKey } from "@/common/constants/storage";
 import type { BranchListResult } from "@/common/types/ipc";
 import { useTelemetry } from "./hooks/useTelemetry";
@@ -517,9 +517,21 @@ function AppInner() {
       );
   }, [projects, setSelectedWorkspace, setWorkspaceMetadata]);
 
+  const handleProviderConfig = useCallback(
+    async (provider: string, keyPath: string[], value: string) => {
+      const result = await window.api.providers.setProviderConfig(provider, keyPath, value);
+      if (!result.success) {
+        throw new Error(result.error);
+      }
+    },
+    []
+  );
+
   return (
     <>
       <div className="bg-bg-dark mobile-layout flex h-screen overflow-hidden">
+
+
         <LeftSidebar
           lastReadTimestamps={lastReadTimestamps}
           onToggleUnread={onToggleUnread}
@@ -561,6 +573,7 @@ function AppInner() {
                           variant="creation"
                           projectPath={projectPath}
                           projectName={projectName}
+                          onProviderConfig={handleProviderConfig}
                           onReady={handleCreationChatReady}
                           onWorkspaceCreated={(metadata) => {
                             // Add to workspace metadata map

src/browser/components/ChatInput/index.tsx

@@ -11,7 +11,7 @@ import React, {
 import { CommandSuggestions, COMMAND_SUGGESTION_KEYS } from "../CommandSuggestions";
 import type { Toast } from "../ChatInputToast";
 import { ChatInputToast } from "../ChatInputToast";
-import { createCommandToast, createErrorToast } from "../ChatInputToasts";
+import { createErrorToast } from "../ChatInputToasts";
 import { parseCommand } from "@/browser/utils/slashCommands/parser";
 import { usePersistedState, updatePersistedState } from "@/browser/hooks/usePersistedState";
 import { useMode } from "@/browser/contexts/ModeContext";
@@ -26,11 +26,9 @@ import {
   getPendingScopeId,
 } from "@/common/constants/storage";
 import {
-  handleNewCommand,
-  handleCompactCommand,
-  forkWorkspace,
   prepareCompactionMessage,
-  type CommandHandlerContext,
+  processSlashCommand,
+  type SlashCommandContext,
 } from "@/browser/utils/chatCommands";
 import { CUSTOM_EVENTS } from "@/common/constants/events";
 import {
@@ -59,7 +57,6 @@ import {
 import type { ThinkingLevel } from "@/common/types/thinking";
 import type { MuxFrontendMetadata } from "@/common/types/message";
 import { useTelemetry } from "@/browser/hooks/useTelemetry";
-import { setTelemetryEnabled } from "@/common/telemetry";
 import { getTokenCountPromise } from "@/browser/utils/tokenizer/rendererClient";
 import { CreationCenterContent } from "./CreationCenterContent";
 import { cn } from "@/common/lib/utils";
@@ -458,8 +455,38 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
     }
 
     const messageText = input.trim();
+    const parsed = parseCommand(messageText);
+
+    if (parsed) {
+      const context: SlashCommandContext = {
+        variant,
+        workspaceId: variant === "workspace" ? props.workspaceId : undefined,
+        sendMessageOptions,
+        setInput,
+        setIsSending,
+        setToast,
+        setVimEnabled,
+        setPreferredModel,
+        onProviderConfig: props.onProviderConfig,
+        onModelChange: props.onModelChange,
+        onTruncateHistory: variant === "workspace" ? props.onTruncateHistory : undefined,
+        onCancelEdit: variant === "workspace" ? props.onCancelEdit : undefined,
+        editMessageId: editingMessage?.id,
+        resetInputHeight: () => {
+          if (inputRef.current) {
+            inputRef.current.style.height = "36px";
+          }
+        },
+      };
+
+      const result = await processSlashCommand(parsed, context);
+      
+      if (!result.clearInput) {
+        setInput(messageText); // Restore input on failure
+      }
+      return;
+    }
 
-    // Route to creation handler for creation variant
     if (variant === "creation") {
       // Creation variant: simple message send + workspace creation
       setIsSending(true);
@@ -474,193 +501,10 @@ export const ChatInput: React.FC<ChatInputProps> = (props) => {
       return;
     }
 
-    // Workspace variant: full command handling + message send
+    // Workspace variant: regular message send
     if (variant !== "workspace") return; // Type guard
 
     try {
-      // Parse command
-      const parsed = parseCommand(messageText);
-
-      if (parsed) {
-        // Handle /clear command
-        if (parsed.type === "clear") {
-          setInput("");
-          if (inputRef.current) {
-            inputRef.current.style.height = "36px";
-          }
-          await props.onTruncateHistory(1.0);
-          setToast({
-            id: Date.now().toString(),
-            type: "success",
-            message: "Chat history cleared",
-          });
-          return;
-        }
-
-        // Handle /truncate command
-        if (parsed.type === "truncate") {
-          setInput("");
-          if (inputRef.current) {
-            inputRef.current.style.height = "36px";
-          }
-          await props.onTruncateHistory(parsed.percentage);
-          setToast({
-            id: Date.now().toString(),
-            type: "success",
-            message: `Chat history truncated by ${Math.round(parsed.percentage * 100)}%`,
-          });
-          return;
-        }
-
-        // Handle /providers set command
-        if (parsed.type === "providers-set" && props.onProviderConfig) {
-          setIsSending(true);
-          setInput(""); // Clear input immediately
-
-          try {
-            await props.onProviderConfig(parsed.provider, parsed.keyPath, parsed.value);
-            // Success - show toast
-            setToast({
-              id: Date.now().toString(),
-              type: "success",
-              message: `Provider ${parsed.provider} updated`,
-            });
-          } catch (error) {
-            console.error("Failed to update provider config:", error);
-            setToast({
-              id: Date.now().toString(),
-              type: "error",
-              message: error instanceof Error ? error.message : "Failed to update provider",
-            });
-            setInput(messageText); // Restore input on error
-          } finally {
-            setIsSending(false);
-          }
-          return;
-        }
-
-        // Handle /model command
-        if (parsed.type === "model-set") {
-          setInput(""); // Clear input immediately
-          setPreferredModel(parsed.modelString);
-          props.onModelChange?.(parsed.modelString);
-          setToast({
-            id: Date.now().toString(),
-            type: "success",
-            message: `Model changed to ${parsed.modelString}`,
-          });
-          return;
-        }
-
-        // Handle /vim command
-        if (parsed.type === "vim-toggle") {
-          setInput(""); // Clear input immediately
-          setVimEnabled((prev) => !prev);
-          return;
-        }
-
-        // Handle /telemetry command
-        if (parsed.type === "telemetry-set") {
-          setInput(""); // Clear input immediately
-          setTelemetryEnabled(parsed.enabled);
-          setToast({
-            id: Date.now().toString(),
-            type: "success",
-            message: `Telemetry ${parsed.enabled ? "enabled" : "disabled"}`,
-          });
-          return;
-        }
-
-        // Handle /compact command
-        if (parsed.type === "compact") {
-          const context: CommandHandlerContext = {
-            workspaceId: props.workspaceId,
-            sendMessageOptions,
-            editMessageId: editingMessage?.id,
-            setInput,
-            setIsSending,
-            setToast,
-            onCancelEdit: props.onCancelEdit,
-          };
-
-          const result = await handleCompactCommand(parsed, context);
-          if (!result.clearInput) {
-            setInput(messageText); // Restore input on error
-          }
-          return;
-        }
-
-        // Handle /fork command
-        if (parsed.type === "fork") {
-          setInput(""); // Clear input immediately
-          setIsSending(true);
-
-          try {
-            const forkResult = await forkWorkspace({
-              sourceWorkspaceId: props.workspaceId,
-              newName: parsed.newName,
-              startMessage: parsed.startMessage,
-              sendMessageOptions,
-            });
-
-            if (!forkResult.success) {
-              const errorMsg = forkResult.error ?? "Failed to fork workspace";
-              console.error("Failed to fork workspace:", errorMsg);
-              setToast({
-                id: Date.now().toString(),
-                type: "error",
-                title: "Fork Failed",
-                message: errorMsg,
-              });
-              setInput(messageText); // Restore input on error
-            } else {
-              setToast({
-                id: Date.now().toString(),
-                type: "success",
-                message: `Forked to workspace "${parsed.newName}"`,
-              });
-            }
-          } catch (error) {
-            const errorMsg = error instanceof Error ? error.message : "Failed to fork workspace";
-            console.error("Fork error:", error);
-            setToast({
-              id: Date.now().toString(),
-              type: "error",
-              title: "Fork Failed",
-              message: errorMsg,
-            });
-            setInput(messageText); // Restore input on error
-          }
-
-          setIsSending(false);
-          return;
-        }
-
-        // Handle /new command
-        if (parsed.type === "new") {
-          const context: CommandHandlerContext = {
-            workspaceId: props.workspaceId,
-            sendMessageOptions,
-            setInput,
-            setIsSending,
-            setToast,
-          };
-
-          const result = await handleNewCommand(parsed, context);
-          if (!result.clearInput) {
-            setInput(messageText); // Restore input on error
-          }
-          return;
-        }
-
-        // Handle all other commands - show display toast
-        const commandToast = createCommandToast(parsed);
-        if (commandToast) {
-          setToast(commandToast);
-          return;
-        }
-      }
-
       // Regular message - send directly via API
       setIsSending(true);
 

src/browser/components/ChatInput/types.ts

@@ -31,6 +31,8 @@ export interface ChatInputCreationVariant {
   projectPath: string;
   projectName: string;
   onWorkspaceCreated: (metadata: FrontendWorkspaceMetadata) => void;
+  onProviderConfig?: (provider: string, keyPath: string[], value: string) => Promise<void>;
+  onModelChange?: (model: string) => void;
   onCancel?: () => void;
   disabled?: boolean;
   onReady?: (api: ChatInputAPI) => void;