byterover-cli 1.7.2 → 2.0.0

package/dist/tui/features/commands/definitions/space-list.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { SpaceListView } from '../../space/components/space-list-view.js';
+import { Flags, parseReplArgs, toCommandFlags } from '../utils/arg-parser.js';
+const listFlags = {
+    json: Flags.boolean({
+        char: 'j',
+        default: false,
+        description: 'Output in JSON format',
+    }),
+};
+export const spaceListCommand = {
+    async action(_context, args) {
+        const parsed = await parseReplArgs(args, { flags: listFlags, strict: false });
+        const json = parsed.flags.json ?? false;
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(SpaceListView, { json, onCancel, onComplete }),
+        };
+    },
+    description: 'List all spaces for the current team',
+    flags: toCommandFlags(listFlags),
+    name: 'list',
+};

package/dist/tui/features/commands/definitions/space-switch.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const spaceSwitchCommand: SlashCommand;

package/dist/tui/features/commands/definitions/space-switch.js

@@ -0,0 +1,9 @@
+import React from 'react';
+import { SpaceSwitchFlow } from '../../space/components/space-switch-flow.js';
+export const spaceSwitchCommand = {
+    action: () => ({
+        render: ({ onCancel, onComplete }) => React.createElement(SpaceSwitchFlow, { onCancel, onComplete }),
+    }),
+    description: 'Switch to a different space',
+    name: 'switch',
+};

package/dist/tui/features/commands/definitions/space.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const spaceCommand: SlashCommand;

package/dist/tui/features/commands/definitions/space.js

@@ -0,0 +1,7 @@
+import { spaceListCommand } from './space-list.js';
+import { spaceSwitchCommand } from './space-switch.js';
+export const spaceCommand = {
+    description: 'Manage ByteRover spaces',
+    name: 'space',
+    subCommands: [spaceListCommand, spaceSwitchCommand],
+};

package/dist/tui/features/commands/definitions/status.d.ts

@@ -0,0 +1,2 @@
+import type { SlashCommand } from '../../../types/commands.js';
+export declare const statusCommand: SlashCommand;

package/dist/tui/features/commands/definitions/status.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { StatusView } from '../../status/components/status-view.js';
+export const statusCommand = {
+    action(context) {
+        return {
+            render: ({ onCancel, onComplete }) => React.createElement(StatusView, { onCancel, onComplete, version: context.version }),
+        };
+    },
+    description: 'Show CLI status and project information',
+    name: 'status',
+};

package/dist/tui/features/commands/hooks/use-commands-controller.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Commands Controller Hook
+ *
+ * Provides command definitions and execution.
+ * Uses CommandsStore for state, adds command loading and execution logic.
+ */
+import type { SlashCommand, SlashCommandActionReturn } from '../../../types/index.js';
+export interface UseCommandsControllerReturn {
+    /** Loaded command definitions */
+    commands: readonly SlashCommand[];
+    /** Execute a slash command */
+    handleSlashCommand: (input: string) => Promise<SlashCommandActionReturn>;
+}
+/**
+ * Hook that provides command definitions and execution.
+ * State (messages, prompts, streaming) is accessed directly from useCommandsStore.
+ */
+export declare function useCommandsController(): UseCommandsControllerReturn;
+/**
+ * Combined hook that provides both controller and store state.
+ * This is the main hook for components that need full command functionality.
+ */
+export declare function useCommands(): {
+    /** Loaded command definitions */
+    commands: readonly SlashCommand[];
+    /** Execute a slash command */
+    handleSlashCommand: (input: string) => Promise<SlashCommandActionReturn>;
+    addMessage: (message: import("../../../types/messages.js").CommandMessage) => void;
+    clearMessages: () => void;
+    setHasActiveDialog: (hasActiveDialog: boolean) => void;
+    setIsStreaming: (isStreaming: boolean) => void;
+    setMessages: (messages: ((prev: import("../../../types/messages.js").CommandMessage[]) => import("../../../types/messages.js").CommandMessage[]) | import("../../../types/messages.js").CommandMessage[]) => void;
+    setStreamingMessages: (messages: ((prev: import("../../../types/messages.js").StreamingMessage[]) => import("../../../types/messages.js").StreamingMessage[]) | import("../../../types/messages.js").StreamingMessage[]) => void;
+    hasActiveDialog: boolean;
+    isStreaming: boolean;
+    messages: import("../../../types/messages.js").CommandMessage[];
+    streamingMessages: import("../../../types/messages.js").StreamingMessage[];
+};

package/dist/tui/features/commands/hooks/use-commands-controller.js

@@ -0,0 +1,43 @@
+/**
+ * Commands Controller Hook
+ *
+ * Provides command definitions and execution.
+ * Uses CommandsStore for state, adds command loading and execution logic.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { load } from '../definitions/index.js';
+import { useCommandsStore } from '../stores/commands-store.js';
+import { useSlashCommandProcessor } from './use-slash-command-processor.js';
+/**
+ * Hook that provides command definitions and execution.
+ * State (messages, prompts, streaming) is accessed directly from useCommandsStore.
+ */
+export function useCommandsController() {
+    const [commands, setCommands] = useState([]);
+    const version = useTransportStore((s) => s.version);
+    // Load commands on mount
+    useEffect(() => {
+        setCommands(load());
+    }, []);
+    const commandContext = useMemo(() => ({
+        version,
+    }), [version]);
+    const { handleSlashCommand } = useSlashCommandProcessor(commandContext, commands);
+    return {
+        commands,
+        handleSlashCommand,
+    };
+}
+/**
+ * Combined hook that provides both controller and store state.
+ * This is the main hook for components that need full command functionality.
+ */
+export function useCommands() {
+    const controller = useCommandsController();
+    const store = useCommandsStore();
+    return {
+        ...store,
+        ...controller,
+    };
+}

package/dist/tui/features/commands/hooks/use-slash-command-processor.d.ts

@@ -0,0 +1,16 @@
+import type { CommandContext, SlashCommand, SlashCommandActionReturn } from '../../../types/index.js';
+/**
+ * Hook return type
+ */
+interface UseSlashCommandProcessorReturn {
+    /** Handle a slash command input */
+    handleSlashCommand: (input: string) => Promise<SlashCommandActionReturn>;
+    /** Whether a command is currently being processed */
+    isProcessing: boolean;
+}
+/**
+ * Hook for processing slash commands
+ * Handles command parsing, execution, and result handling
+ */
+export declare function useSlashCommandProcessor(context: CommandContext, commands: readonly SlashCommand[]): UseSlashCommandProcessorReturn;
+export {};

package/dist/tui/features/commands/hooks/use-slash-command-processor.js

@@ -0,0 +1,134 @@
+import { useCallback, useState } from 'react';
+import { splitArgs } from '../utils/arg-parser.js';
+/**
+ * Parse user input to extract command, subcommand, and arguments
+ */
+function parseInput(input, commands) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/')) {
+        return { args: trimmed, commandPath: '', isCommand: false };
+    }
+    const withoutSlash = trimmed.slice(1);
+    const parts = withoutSlash.split(/\s+/);
+    const commandName = parts[0]?.toLowerCase();
+    if (!commandName) {
+        return { args: '', commandPath: '', isCommand: true };
+    }
+    // Find command by name or alias
+    const command = commands.find((cmd) => cmd.name === commandName);
+    if (!command) {
+        return { args: parts.slice(1).join(' '), commandPath: commandName, isCommand: true };
+    }
+    // Recursively resolve subcommands (e.g. /hub registry list)
+    let current = command;
+    let depth = 1;
+    while (current.subCommands?.length && depth < parts.length) {
+        const nextName = parts[depth]?.toLowerCase();
+        const match = current.subCommands.find((sub) => sub.name === nextName);
+        if (!match)
+            break;
+        current = match;
+        depth++;
+    }
+    const commandPath = parts.slice(0, depth).join(' ');
+    return {
+        args: parts.slice(depth).join(' '),
+        command,
+        commandPath,
+        isCommand: true,
+        ...(current === command ? {} : { subCommand: current }),
+    };
+}
+/**
+ * Hook for processing slash commands
+ * Handles command parsing, execution, and result handling
+ */
+export function useSlashCommandProcessor(context, commands) {
+    const [isProcessing, setIsProcessing] = useState(false);
+    const handleSlashCommand = useCallback(async (input) => {
+        const { args, command, commandPath, isCommand, subCommand } = parseInput(input, commands);
+        if (!isCommand) {
+            // Slash command only mode - show warning for non-slash input
+            return {
+                content: 'Please use a slash command. Type / for available commands.',
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        if (!command) {
+            const commandName = input.trim().slice(1).split(/\s+/)[0];
+            return {
+                content: `Unknown command: /${commandName}. Type / for available commands.`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        // Determine which action to execute
+        const deepest = subCommand ?? command;
+        const commandNameForContext = commandPath;
+        // If the deepest resolved command has no action but has subcommands, show usage
+        if (!deepest.action && deepest.subCommands?.length) {
+            const subNames = deepest.subCommands.map((s) => s.name).join('|');
+            return {
+                content: `Usage: /${commandPath} <${subNames}>`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        const actionToExecute = deepest.action ?? command.action;
+        if (!actionToExecute) {
+            return {
+                content: `Command /${commandPath} has no action defined.`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        // Check for required arguments
+        const targetCommand = subCommand ?? command;
+        const requiredArgs = targetCommand.args?.filter((arg) => arg.required) ?? [];
+        if (requiredArgs.length > 0 && !args.trim()) {
+            const argNames = requiredArgs.map((a) => `<${a.name}>`).join(' ');
+            const flagsStr = targetCommand.flags?.map((f) => `[--${f.name}]`).join(' ') ?? '';
+            const usage = `/${commandNameForContext} ${argNames}${flagsStr ? ' ' + flagsStr : ''}`;
+            return {
+                content: `Missing required argument(s).\nUsage: ${usage}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        // Extract file and folder references from args
+        const { args: argsWithoutFiles, files, folders } = splitArgs(args);
+        const cleanArgs = argsWithoutFiles.join(' ');
+        // Build execution context with invocation details
+        const execContext = {
+            ...context,
+            invocation: {
+                args: cleanArgs,
+                files,
+                folders,
+                name: commandNameForContext,
+                raw: input,
+            },
+        };
+        setIsProcessing(true);
+        try {
+            const result = await actionToExecute(execContext, cleanArgs);
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: `Error executing /${commandNameForContext}: ${errorMessage}`,
+                messageType: 'error',
+                type: 'message',
+            };
+        }
+        finally {
+            setIsProcessing(false);
+        }
+    }, [commands, context]);
+    return {
+        handleSlashCommand,
+        isProcessing,
+    };
+}

package/dist/tui/features/commands/hooks/use-slash-completion.d.ts

@@ -0,0 +1,30 @@
+import type { CommandSuggestion } from '../../../types/index.js';
+/**
+ * Hook return type
+ */
+interface UseSlashCompletionReturn {
+    /** Index of currently active suggestion (-1 if none) */
+    activeIndex: number;
+    /** Clear suggestions */
+    clearSuggestions: () => void;
+    /** Whether the input matches a known command (even if typing arguments) */
+    hasMatchedCommand: boolean;
+    /** Whether input is a slash command attempt (starts with /) */
+    isCommandAttempt: boolean;
+    /** Move to next suggestion */
+    nextSuggestion: () => void;
+    /** Move to previous suggestion */
+    prevSuggestion: () => void;
+    /** Select the current suggestion and return the value to insert */
+    selectSuggestion: () => null | string;
+    /** Set active index directly */
+    setActiveIndex: (index: number) => void;
+    /** Current suggestions */
+    suggestions: CommandSuggestion[];
+}
+/**
+ * Hook for slash command auto-completion
+ * Generates suggestions based on input and manages selection state
+ */
+export declare function useSlashCompletion(input: string): UseSlashCompletionReturn;
+export {};

package/dist/tui/features/commands/hooks/use-slash-completion.js

@@ -0,0 +1,256 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCommands } from './use-commands-controller.js';
+/**
+ * Generate file suggestions based on @ prefix
+ * Returns files from the current working directory matching the search pattern
+ */
+function generateFileSuggestions(searchPattern) {
+    try {
+        const cwd = process.cwd();
+        const suggestions = [];
+        // Special case: Always suggest ./ as the first option when appropriate
+        // This allows users to curate the entire current directory
+        const normalizedPattern = searchPattern.toLowerCase();
+        const shouldShowCurrentDir = !searchPattern || // Just typed @
+            normalizedPattern === '.' || // Typing @.
+            './'.startsWith(normalizedPattern); // Typing @. (partial match)
+        if (shouldShowCurrentDir) {
+            suggestions.push({
+                description: 'Current directory (will pack all contents)',
+                label: './',
+                value: '@./',
+            });
+        }
+        // If pattern ends with /, list contents of that directory
+        let searchDir;
+        let searchPrefix;
+        if (searchPattern.endsWith('/')) {
+            searchDir = searchPattern.slice(0, -1) || '.';
+            searchPrefix = '';
+        }
+        else {
+            searchDir = path.dirname(searchPattern) || '.';
+            searchPrefix = path.basename(searchPattern).toLowerCase();
+        }
+        const fullSearchDir = path.resolve(cwd, searchDir);
+        // Check if search directory exists and is within cwd
+        if (!fs.existsSync(fullSearchDir) || !fullSearchDir.startsWith(cwd)) {
+            return suggestions;
+        }
+        const entries = fs.readdirSync(fullSearchDir, { withFileTypes: true });
+        for (const entry of entries) {
+            // Skip hidden files
+            if (entry.name.startsWith('.'))
+                continue;
+            const name = entry.name.toLowerCase();
+            if (!searchPrefix || name.startsWith(searchPrefix)) {
+                const relativePath = searchDir === '.' ? entry.name : path.join(searchDir, entry.name);
+                const isDir = entry.isDirectory();
+                suggestions.push({
+                    description: isDir ? 'folder (will pack contents)' : '',
+                    label: `${relativePath}${isDir ? '/' : ''}`,
+                    value: `@${relativePath}${isDir ? '/' : ''}`,
+                });
+            }
+        }
+        // Sort: directories first, then alphabetically
+        // Note: ./ is already at the front, so we sort from index 1
+        const hasCurrentDir = suggestions[0]?.label === './';
+        const startIndex = hasCurrentDir ? 1 : 0;
+        const toSort = suggestions.slice(startIndex);
+        toSort.sort((a, b) => {
+            const aIsDir = a.label.endsWith('/');
+            const bIsDir = b.label.endsWith('/');
+            if (aIsDir !== bIsDir)
+                return aIsDir ? -1 : 1;
+            return a.label.localeCompare(b.label);
+        });
+        // Recombine: ./ stays at front, rest are sorted
+        const finalSuggestions = hasCurrentDir ? [suggestions[0], ...toSort] : toSort;
+        return finalSuggestions.slice(0, 20); // Limit to 20 suggestions
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Generate command suggestions based on current input
+ */
+function generateSuggestions(input, commands) {
+    const trimmed = input.trim();
+    // Check for @ file completion (last word starts with @)
+    // Don't show file suggestions if input ends with space (file already selected)
+    if (!input.endsWith(' ')) {
+        const lastAtMatch = trimmed.match(/@([^\s@]*)$/);
+        if (lastAtMatch) {
+            const searchPattern = lastAtMatch[1];
+            const suggestions = generateFileSuggestions(searchPattern);
+            // Filter out already selected files
+            const existingFiles = new Set([...trimmed.matchAll(/@([^\s@]+)/g)].map((m) => m[1]));
+            return suggestions.filter((s) => {
+                const filePath = s.value.slice(1); // Remove @ prefix
+                return !existingFiles.has(filePath);
+            });
+        }
+    }
+    // Only suggest for slash command inputs
+    if (!trimmed.startsWith('/')) {
+        return [];
+    }
+    const withoutSlash = trimmed.slice(1);
+    const parts = withoutSlash.split(/\s+/);
+    const commandPart = parts[0]?.toLowerCase() ?? '';
+    // If we're still typing the command name (no space after it)
+    if (parts.length === 1) {
+        // Filter commands that start with the typed prefix
+        const matchingCommands = commands
+            .filter((cmd) => !cmd.hidden)
+            .filter((cmd) => cmd.name.toLowerCase().startsWith(commandPart));
+        return matchingCommands.map((cmd) => ({
+            args: cmd.args,
+            description: cmd.description,
+            flags: cmd.flags,
+            label: `/${cmd.name}`,
+            subCommands: cmd.subCommands
+                ?.filter((sub) => !sub.hidden)
+                .map((sub) => ({
+                description: sub.description,
+                name: sub.name,
+            })),
+            value: `/${cmd.name}`,
+        }));
+    }
+    // Recursively resolve to the deepest matched command with subcommands
+    const command = commands.find((cmd) => cmd.name === commandPart);
+    if (!command) {
+        return [];
+    }
+    let current = command;
+    let depth = 1;
+    while (current.subCommands?.length && depth < parts.length - 1) {
+        const nextName = parts[depth]?.toLowerCase();
+        const match = current.subCommands.find((sub) => sub.name === nextName);
+        if (!match)
+            break;
+        current = match;
+        depth++;
+    }
+    // If the deepest resolved command has subcommands, suggest them
+    if (current.subCommands?.length && parts.length === depth + 1) {
+        const subPart = parts[depth]?.toLowerCase() ?? '';
+        const commandPath = parts.slice(0, depth).join(' ');
+        const matchingSubCommands = current.subCommands
+            .filter((sub) => !sub.hidden)
+            .filter((sub) => sub.name.toLowerCase().startsWith(subPart));
+        return matchingSubCommands.map((sub) => ({
+            args: sub.args,
+            description: sub.description,
+            flags: sub.flags,
+            label: `/${commandPath} ${sub.name}`,
+            subCommands: sub.subCommands
+                ?.filter((s) => !s.hidden)
+                .map((s) => ({
+                description: s.description,
+                name: s.name,
+            })),
+            value: `/${commandPath} ${sub.name}`,
+        }));
+    }
+    // Future enhancement: use command.completion for argument suggestions
+    return [];
+}
+/**
+ * Hook for slash command auto-completion
+ * Generates suggestions based on input and manages selection state
+ */
+export function useSlashCompletion(input) {
+    const { commands } = useCommands();
+    const [activeIndex, setActiveIndex] = useState(-1);
+    // Check if input is a command attempt (starts with /)
+    const isCommandAttempt = input.trim().startsWith('/');
+    // Check if we're in file completion mode (has @ and not ending with space)
+    const isFileCompletion = useMemo(() => !input.endsWith(' ') && /@[^\s@]*$/.test(input.trim()), [input]);
+    // Check if the input matches a known command (for when typing arguments)
+    const hasMatchedCommand = useMemo(() => {
+        // File completion counts as "matched" to avoid showing "no commands found"
+        if (isFileCompletion)
+            return true;
+        if (!isCommandAttempt)
+            return false;
+        const trimmed = input.trim();
+        const withoutSlash = trimmed.slice(1);
+        const parts = withoutSlash.split(/\s+/);
+        const commandPart = parts[0]?.toLowerCase() ?? '';
+        return commands.some((cmd) => cmd.name === commandPart);
+    }, [commands, input, isCommandAttempt, isFileCompletion]);
+    // Generate suggestions based on current input
+    const suggestions = useMemo(() => generateSuggestions(input, commands), [commands, input]);
+    // Use refs to avoid stale closures
+    const activeIndexRef = useRef(activeIndex);
+    const suggestionsRef = useRef(suggestions);
+    const inputRef = useRef(input);
+    const isFileCompletionRef = useRef(isFileCompletion);
+    // Keep refs in sync
+    activeIndexRef.current = activeIndex;
+    suggestionsRef.current = suggestions;
+    inputRef.current = input;
+    isFileCompletionRef.current = isFileCompletion;
+    // Reset active index when suggestions change
+    useEffect(() => {
+        const newIndex = suggestions.length > 0 ? 0 : -1;
+        setActiveIndex(newIndex);
+        activeIndexRef.current = newIndex;
+    }, [suggestions]);
+    const nextSuggestion = useCallback(() => {
+        const currentSuggestions = suggestionsRef.current;
+        if (currentSuggestions.length === 0)
+            return;
+        setActiveIndex((prev) => {
+            const newIndex = (prev + 1) % currentSuggestions.length;
+            activeIndexRef.current = newIndex;
+            return newIndex;
+        });
+    }, []);
+    const prevSuggestion = useCallback(() => {
+        const currentSuggestions = suggestionsRef.current;
+        if (currentSuggestions.length === 0)
+            return;
+        setActiveIndex((prev) => {
+            const newIndex = (prev - 1 + currentSuggestions.length) % currentSuggestions.length;
+            activeIndexRef.current = newIndex;
+            return newIndex;
+        });
+    }, []);
+    const selectSuggestion = useCallback(() => {
+        const currentIndex = activeIndexRef.current;
+        const currentSuggestions = suggestionsRef.current;
+        if (currentIndex < 0 || currentIndex >= currentSuggestions.length) {
+            return null;
+        }
+        const selectedValue = currentSuggestions[currentIndex].value;
+        // For file completion, replace the @... part with the selected file
+        if (isFileCompletionRef.current) {
+            const currentInput = inputRef.current;
+            // Replace the @... at the end with the selected file path
+            return currentInput.replace(/@[^\s@]*$/, selectedValue);
+        }
+        return selectedValue;
+    }, []);
+    const clearSuggestions = useCallback(() => {
+        setActiveIndex(-1);
+        activeIndexRef.current = -1;
+    }, []);
+    return {
+        activeIndex,
+        clearSuggestions,
+        hasMatchedCommand,
+        isCommandAttempt,
+        nextSuggestion,
+        prevSuggestion,
+        selectSuggestion,
+        setActiveIndex,
+        suggestions,
+    };
+}

package/dist/tui/features/commands/stores/commands-store.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Commands Store
+ *
+ * Zustand store for slash command state: messages, streaming, dialogs.
+ * Command definitions and execution are handled by useCommandsController hook.
+ */
+import type { CommandMessage, StreamingMessage } from '../../../types/messages.js';
+export interface CommandsState {
+    /** Whether a dialog command is currently active (blocks input focus and feed navigation) */
+    hasActiveDialog: boolean;
+    /** Whether a command is currently streaming output */
+    isStreaming: boolean;
+    /** Command messages for display */
+    messages: CommandMessage[];
+    /** Streaming messages for live output */
+    streamingMessages: StreamingMessage[];
+}
+export interface CommandsActions {
+    /** Add a command message */
+    addMessage: (message: CommandMessage) => void;
+    /** Clear all messages */
+    clearMessages: () => void;
+    /** Set whether a dialog command is active */
+    setHasActiveDialog: (hasActiveDialog: boolean) => void;
+    /** Set streaming state */
+    setIsStreaming: (isStreaming: boolean) => void;
+    /** Set messages directly */
+    setMessages: (messages: ((prev: CommandMessage[]) => CommandMessage[]) | CommandMessage[]) => void;
+    /** Set streaming messages directly */
+    setStreamingMessages: (messages: ((prev: StreamingMessage[]) => StreamingMessage[]) | StreamingMessage[]) => void;
+}
+export declare const useCommandsStore: import("zustand").UseBoundStore<import("zustand").StoreApi<CommandsActions & CommandsState>>;

package/dist/tui/features/commands/stores/commands-store.js

@@ -0,0 +1,23 @@
+/**
+ * Commands Store
+ *
+ * Zustand store for slash command state: messages, streaming, dialogs.
+ * Command definitions and execution are handled by useCommandsController hook.
+ */
+import { create } from 'zustand';
+export const useCommandsStore = create()((set) => ({
+    addMessage: (message) => set((state) => ({ messages: [...state.messages, message] })),
+    clearMessages: () => set({ hasActiveDialog: false, isStreaming: false, messages: [], streamingMessages: [] }),
+    hasActiveDialog: false,
+    isStreaming: false,
+    messages: [],
+    setHasActiveDialog: (hasActiveDialog) => set({ hasActiveDialog }),
+    setIsStreaming: (isStreaming) => set({ isStreaming }),
+    setMessages: (messagesOrFn) => set((state) => ({
+        messages: typeof messagesOrFn === 'function' ? messagesOrFn(state.messages) : messagesOrFn,
+    })),
+    setStreamingMessages: (messagesOrFn) => set((state) => ({
+        streamingMessages: typeof messagesOrFn === 'function' ? messagesOrFn(state.streamingMessages) : messagesOrFn,
+    })),
+    streamingMessages: [],
+}));