byterover-cli 0.3.5 → 0.4.0

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

@@ -0,0 +1,230 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useCommands } from '../contexts/use-commands.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();
+        // 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 [];
+        }
+        const entries = fs.readdirSync(fullSearchDir, { withFileTypes: true });
+        const suggestions = [];
+        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' : '',
+                    label: `${relativePath}${isDir ? '/' : ''}`,
+                    value: `@${relativePath}${isDir ? '/' : ''}`,
+                });
+            }
+        }
+        // Sort: directories first, then alphabetically
+        suggestions.sort((a, b) => {
+            const aIsDir = a.description === 'folder';
+            const bIsDir = b.description === 'folder';
+            if (aIsDir !== bIsDir)
+                return aIsDir ? -1 : 1;
+            return a.label.localeCompare(b.label);
+        });
+        return suggestions.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) => {
+            const nameMatch = cmd.name.toLowerCase().startsWith(commandPart);
+            const aliasMatch = cmd.aliases?.some((alias) => alias.toLowerCase().startsWith(commandPart));
+            return nameMatch || aliasMatch;
+        });
+        return matchingCommands.map((cmd) => ({
+            args: cmd.args,
+            commandKind: cmd.kind,
+            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}`,
+        }));
+    }
+    // Find the matched command
+    const command = commands.find((cmd) => cmd.name === commandPart || cmd.aliases?.includes(commandPart));
+    if (!command) {
+        return [];
+    }
+    // If command has subcommands, suggest them
+    if (command.subCommands?.length && parts.length === 2) {
+        const subPart = parts[1]?.toLowerCase() ?? '';
+        const matchingSubCommands = command.subCommands
+            .filter((sub) => !sub.hidden)
+            .filter((sub) => {
+            const nameMatch = sub.name.toLowerCase().startsWith(subPart);
+            const aliasMatch = sub.aliases?.some((alias) => alias.toLowerCase().startsWith(subPart));
+            return nameMatch || aliasMatch;
+        });
+        return matchingSubCommands.map((sub) => ({
+            args: sub.args,
+            commandKind: sub.kind,
+            description: sub.description,
+            flags: sub.flags,
+            label: `/${command.name} ${sub.name}`,
+            value: `/${command.name} ${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 || cmd.aliases?.includes(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/hooks/use-tab-navigation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tab Navigation Hook
+ */
+import type { TabId } from '../types.js';
+interface UseTabNavigationResult {
+    activeTab: TabId;
+    setActiveTab: (tab: TabId) => void;
+}
+export declare function useTabNavigation(): UseTabNavigationResult;
+export {};

package/dist/tui/hooks/use-tab-navigation.js

@@ -0,0 +1,35 @@
+/**
+ * Tab Navigation Hook
+ */
+import { useApp, useInput } from 'ink';
+import { useEffect, useState } from 'react';
+import { stopQueuePollingService } from '../../infra/cipher/consumer/queue-polling-service.js';
+import { DEFAULT_TAB, TABS } from '../constants.js';
+import { useMode } from '../contexts/use-mode.js';
+import { useOnboarding } from './use-onboarding.js';
+export function useTabNavigation() {
+    const { exit } = useApp();
+    const { shouldShowOnboarding } = useOnboarding();
+    const { mode, setMode } = useMode();
+    const [activeTab, setActiveTab] = useState(DEFAULT_TAB);
+    // Sync mode with active tab on mount and when activeTab changes
+    useEffect(() => {
+        setMode(activeTab === 'activity' ? 'activity' : 'console');
+    }, [activeTab, setMode]);
+    useInput((input, key) => {
+        // Tab: cycle through tabs (blocked during onboarding)
+        if (key.tab && !shouldShowOnboarding) {
+            const currentIndex = TABS.findIndex((t) => t.id === activeTab);
+            const nextIndex = currentIndex >= TABS.length - 1 ? 0 : currentIndex + 1;
+            const nextTab = TABS[nextIndex].id;
+            setActiveTab(nextTab);
+            // Mode will be synced by useEffect
+        }
+        // Quit with Ctrl+C
+        if (key.ctrl && input === 'c') {
+            stopQueuePollingService();
+            exit();
+        }
+    }, { isActive: mode === 'activity' || mode === 'console' });
+    return { activeTab, setActiveTab };
+}

package/dist/tui/hooks/use-visible-window.d.ts

@@ -0,0 +1,22 @@
+/**
+ * useVisibleWindow Hook
+ *
+ * Calculates a visible window of items based on selected index.
+ * Used for scrollable lists that show a limited number of items
+ * with a sliding window that follows the selection.
+ */
+export interface UseVisibleWindowReturn<T> {
+    /** The visible items within the window */
+    visibleItems: T[];
+    /** The starting index of the window in the original array */
+    windowStart: number;
+}
+/**
+ * Hook for calculating a visible window of items
+ *
+ * @param items - The full array of items
+ * @param selectedIndex - The currently selected index
+ * @param maxVisibleItems - Maximum number of items to show (default: 7)
+ * @returns The visible items and window start index
+ */
+export declare function useVisibleWindow<T>(items: T[], selectedIndex: number, maxVisibleItems?: number): UseVisibleWindowReturn<T>;

package/dist/tui/hooks/use-visible-window.js

@@ -0,0 +1,37 @@
+/**
+ * useVisibleWindow Hook
+ *
+ * Calculates a visible window of items based on selected index.
+ * Used for scrollable lists that show a limited number of items
+ * with a sliding window that follows the selection.
+ */
+import { useMemo } from 'react';
+const DEFAULT_MAX_VISIBLE_ITEMS = 7;
+/**
+ * Hook for calculating a visible window of items
+ *
+ * @param items - The full array of items
+ * @param selectedIndex - The currently selected index
+ * @param maxVisibleItems - Maximum number of items to show (default: 7)
+ * @returns The visible items and window start index
+ */
+export function useVisibleWindow(items, selectedIndex, maxVisibleItems = DEFAULT_MAX_VISIBLE_ITEMS) {
+    return useMemo(() => {
+        if (items.length <= maxVisibleItems) {
+            return { visibleItems: items, windowStart: 0 };
+        }
+        // Calculate window start to keep selected item visible
+        let start = 0;
+        if (selectedIndex >= maxVisibleItems) {
+            // Selected item is beyond visible range, adjust window
+            start = selectedIndex - maxVisibleItems + 1;
+        }
+        // Ensure we don't go past the end
+        const maxStart = items.length - maxVisibleItems;
+        start = Math.min(start, maxStart);
+        return {
+            visibleItems: items.slice(start, start + maxVisibleItems),
+            windowStart: start,
+        };
+    }, [items, selectedIndex, maxVisibleItems]);
+}

package/dist/tui/index.d.ts

@@ -0,0 +1 @@
+export { App } from './app.js';

package/dist/tui/index.js

@@ -0,0 +1 @@
+export { App } from './app.js';

package/dist/tui/providers/app-providers.d.ts

@@ -0,0 +1,25 @@
+/**
+ * App Providers
+ *
+ * Composes all context providers in the correct order.
+ * Single wrapper for repl-startup.tsx to use.
+ */
+import React from 'react';
+import type { AuthToken } from '../../core/domain/entities/auth-token.js';
+import type { BrvConfig } from '../../core/domain/entities/brv-config.js';
+import type { IOnboardingPreferenceStore } from '../../core/interfaces/i-onboarding-preference-store.js';
+import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
+import type { ITokenStore } from '../../core/interfaces/i-token-store.js';
+import type { ITrackingService } from '../../core/interfaces/i-tracking-service.js';
+interface AppProvidersProps {
+    children: React.ReactNode;
+    initialAuthToken?: AuthToken;
+    initialBrvConfig?: BrvConfig;
+    onboardingPreferenceStore: IOnboardingPreferenceStore;
+    projectConfigStore: IProjectConfigStore;
+    tokenStore: ITokenStore;
+    trackingService: ITrackingService;
+    version: string;
+}
+export declare function AppProviders({ children, initialAuthToken, initialBrvConfig, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }: AppProvidersProps): React.ReactElement;
+export {};

package/dist/tui/providers/app-providers.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AuthProvider, ConsumerProvider, ServicesProvider } from '../contexts/index.js';
+import { OnboardingProvider } from '../contexts/onboarding-context.js';
+import { CommandsProvider } from '../contexts/use-commands.js';
+import { ModeProvider } from '../contexts/use-mode.js';
+import { ThemeProvider } from '../contexts/use-theme.js';
+export function AppProviders({ children, initialAuthToken, initialBrvConfig, onboardingPreferenceStore, projectConfigStore, tokenStore, trackingService, version, }) {
+    return (_jsx(ServicesProvider, { onboardingPreferenceStore: onboardingPreferenceStore, projectConfigStore: projectConfigStore, tokenStore: tokenStore, trackingService: trackingService, version: version, children: _jsx(AuthProvider, { initialAuthToken: initialAuthToken, initialBrvConfig: initialBrvConfig, children: _jsx(ThemeProvider, { children: _jsx(CommandsProvider, { children: _jsx(ModeProvider, { children: _jsx(ConsumerProvider, { children: _jsx(OnboardingProvider, { children: children }) }) }) }) }) }) }));
+}

package/dist/tui/types/commands.d.ts

@@ -0,0 +1,252 @@
+/**
+ * Command-related types
+ */
+import type React from 'react';
+import type { PromptRequest, StreamingMessage } from './index.js';
+import type { Message } from './messages.js';
+/**
+ * Command kind indicates the source/type of command
+ * Based on Gemini CLI pattern for extensibility
+ */
+export declare enum CommandKind {
+    /** Built-in commands defined in code */
+    BUILT_IN = "built-in",
+    /** Future: file-based commands */
+    FILE = "file",
+    /** Commands that dispatch to oclif CLI commands */
+    OCLIF = "oclif"
+}
+/**
+ * Command argument definition
+ */
+export interface CommandArg {
+    /** Argument description */
+    description: string;
+    /** Argument name */
+    name: string;
+    /** Whether the argument is required */
+    required?: boolean;
+}
+/**
+ * Command flag definition
+ */
+export interface CommandFlag {
+    /** Short flag character (e.g., 'b' for -b) */
+    char?: string;
+    /** Default value */
+    default?: boolean | string;
+    /** Flag description */
+    description: string;
+    /** Flag name (e.g., 'branch' for --branch) */
+    name: string;
+    /** Flag type */
+    type: 'boolean' | 'file' | 'string';
+}
+/**
+ * Context passed to command action functions
+ */
+export interface CommandContext {
+    /**
+     * Invocation details about the current command execution
+     */
+    invocation?: {
+        /** Arguments passed to the command (without @file references) */
+        args: string;
+        /** File references extracted from @filepath tokens */
+        files: string[];
+        /** Resolved command name */
+        name: string;
+        /** Full raw input string */
+        raw: string;
+    };
+    /**
+     * All loaded slash commands (for help command, etc.)
+     */
+    slashCommands?: readonly SlashCommand[];
+    /**
+     * UI operations available to commands
+     */
+    ui?: {
+        /**
+         * Add a message to the message history
+         */
+        addMessage: (msg: Message) => void;
+        /**
+         * Clear all messages from the history
+         */
+        clearMessages: () => void;
+        /**
+         * Remove the currently displayed custom dialog
+         */
+        removeDialog: () => void;
+        /**
+         * Set processing state
+         */
+        setIsProcessing: (processing: boolean) => void;
+    };
+    /**
+     * CLI version
+     */
+    version?: string;
+}
+/**
+ * Subcommand info for display in suggestions
+ */
+export interface CommandSubcommandInfo {
+    /** Subcommand description */
+    description: string;
+    /** Subcommand name */
+    name: string;
+}
+/**
+ * Suggestion item for auto-completion
+ */
+export interface CommandSuggestion {
+    /** Command arguments */
+    args?: CommandArg[];
+    /** Command kind for styling */
+    commandKind?: CommandKind;
+    /** Optional description */
+    description?: string;
+    /** Command flags */
+    flags?: CommandFlag[];
+    /** Display label */
+    label: string;
+    /** Subcommands for commands with nested commands */
+    subCommands?: CommandSubcommandInfo[];
+    /** Value to insert on selection */
+    value: string;
+}
+/**
+ * Command action return type for displaying a message
+ */
+export interface MessageActionReturn {
+    content: string;
+    messageType: 'error' | 'info';
+    type: 'message';
+}
+/**
+ * Command action return type for quitting the REPL
+ */
+export interface QuitActionReturn {
+    type: 'quit';
+}
+/**
+ * Command action return type for rendering a custom dialog component
+ */
+export interface CustomDialogActionReturn {
+    component: React.ReactNode;
+    type: 'custom_dialog';
+}
+/**
+ * Command action return type for clearing the screen
+ */
+export interface ClearActionReturn {
+    type: 'clear';
+}
+/**
+ * Command action return type for streaming output with interactive prompts
+ */
+export interface StreamingActionReturn {
+    /**
+     * Async function that executes the command
+     * @param onMessage - Callback for streaming output messages
+     * @param onPrompt - Callback for interactive prompts (search, confirm, select)
+     */
+    execute: (onMessage: (msg: StreamingMessage) => void, onPrompt: (prompt: PromptRequest) => void) => Promise<void>;
+    type: 'streaming';
+}
+/**
+ * Command action return type for confirming an action
+ * Uses callback pattern for handling confirmation result (Gemini CLI pattern)
+ */
+export interface ConfirmActionReturn {
+    /**
+     * Callback invoked when user makes a choice
+     * @param confirmed - true if user confirmed, false if cancelled
+     * @returns Optional streaming action to execute after confirmation
+     */
+    onConfirm: (confirmed: boolean) => Promise<StreamingActionReturn | void> | StreamingActionReturn | void;
+    prompt: string;
+    type: 'confirm_action';
+}
+/**
+ * Command action return type for submitting a prompt
+ */
+export interface SubmitPromptReturn {
+    content: string;
+    type: 'submit_prompt';
+}
+/**
+ * Command action return type for showing query input dialog
+ */
+export interface QueryDialogActionReturn {
+    type: 'query_dialog';
+}
+/**
+ * Command action return type for showing curate option dialog
+ */
+export interface CurateDialogActionReturn {
+    type: 'curate_dialog';
+}
+/**
+ * Command action return type for refreshing auth state (after logout/login)
+ */
+export interface RefreshAuthActionReturn {
+    type: 'refresh_auth';
+}
+/**
+ * Union of all possible command action return types
+ */
+export type SlashCommandActionReturn = ClearActionReturn | ConfirmActionReturn | CurateDialogActionReturn | CustomDialogActionReturn | MessageActionReturn | QueryDialogActionReturn | QuitActionReturn | RefreshAuthActionReturn | StreamingActionReturn | SubmitPromptReturn | void;
+/**
+ * Slash command definition (based on Gemini CLI pattern)
+ * Supports nested subcommands, auto-completion, and flexible action returns
+ */
+export interface SlashCommand {
+    /**
+     * Action function that executes the command
+     * Optional for commands that only have subcommands
+     */
+    action?: (context: CommandContext, args: string) => Promise<SlashCommandActionReturn> | SlashCommandActionReturn;
+    /**
+     * Alternative names for the command (e.g., 'q' for 'quit')
+     */
+    aliases?: string[];
+    /**
+     * Command arguments definition
+     */
+    args?: CommandArg[];
+    /**
+     * Auto-execute on Enter when selected in suggestions (vs just autocomplete)
+     */
+    autoExecute?: boolean;
+    /**
+     * Argument completion provider for suggestions
+     */
+    completion?: (context: CommandContext, partialArg: string) => Promise<string[]> | string[];
+    /**
+     * Description shown in help
+     */
+    description: string;
+    /**
+     * Command flags definition
+     */
+    flags?: CommandFlag[];
+    /**
+     * Hide from help and suggestions (e.g., for internal commands)
+     */
+    hidden?: boolean;
+    /**
+     * Command kind indicates the source/type of command
+     */
+    kind: CommandKind;
+    /**
+     * Primary command name (without leading slash)
+     */
+    name: string;
+    /**
+     * Nested subcommands (e.g., /space list, /space switch)
+     */
+    subCommands?: SlashCommand[];
+}

package/dist/tui/types/commands.js

@@ -0,0 +1,16 @@
+/**
+ * Command-related types
+ */
+/**
+ * Command kind indicates the source/type of command
+ * Based on Gemini CLI pattern for extensibility
+ */
+export var CommandKind;
+(function (CommandKind) {
+    /** Built-in commands defined in code */
+    CommandKind["BUILT_IN"] = "built-in";
+    /** Future: file-based commands */
+    CommandKind["FILE"] = "file";
+    /** Commands that dispatch to oclif CLI commands */
+    CommandKind["OCLIF"] = "oclif";
+})(CommandKind || (CommandKind = {}));

package/dist/tui/types/dialogs.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Dialog request types for UI state management
+ */
+/**
+ * Confirmation request stored in UI state (Gemini CLI pattern)
+ * Used by DialogManager to render confirmation dialogs
+ */
+export interface ConfirmationRequest {
+    onConfirm: (confirmed: boolean) => void;
+    prompt: string;
+}
+/**
+ * Query dialog request stored in UI state
+ * Used to render the query input dialog
+ */
+export interface QueryDialogRequest {
+    onCancel: () => void;
+    onSubmit: (query: string) => void;
+}
+/**
+ * Curate option dialog request stored in UI state
+ * Used to render the curate mode selection dialog
+ */
+export interface CurateDialogRequest {
+    onCancel: () => void;
+    onSelectContextInput: () => void;
+    onSelectInteractive: () => void;
+}
+/**
+ * Curate context input dialog request stored in UI state
+ * Used to render the context input dialog for autonomous curating
+ */
+export interface CurateContextInputRequest {
+    onCancel: () => void;
+    onSubmit: (context: string) => void;
+    onToggleMode?: () => void;
+}