byterover-cli 1.8.0 → 2.1.0

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: [],
+}));

package/dist/tui/features/commands/utils/arg-parser.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Shared argument parser for REPL commands
+ *
+ * Combines shell-like string splitting with oclif's Parser for consistent
+ * flag and argument handling across REPL commands.
+ */
+import { type Interfaces } from '@oclif/core';
+import { CommandFlag } from '../../../types/index.js';
+export { Args, Flags } from '@oclif/core';
+type ArgInput = Interfaces.ArgInput;
+type FlagInput = Interfaces.FlagInput;
+/**
+ * Convert oclif flag definitions to CommandFlag[] for SlashCommand.flags
+ *
+ * This allows defining flags once using oclif format and auto-generating
+ * the CommandFlag[] needed for help display.
+ *
+ * @example
+ * const flags = {
+ *   apiKey: Flags.string({char: 'k', description: 'API key'}),
+ *   verbose: Flags.boolean({char: 'v', description: 'Verbose output'}),
+ * }
+ *
+ * export const myCommand: SlashCommand = {
+ *   action(context, args) {
+ *     const parsed = await parseReplArgs(args, {flags})
+ *   },
+ *   flags: toCommandFlags(flags),
+ * }
+ */
+export declare function toCommandFlags(flags: FlagInput): CommandFlag[];
+/**
+ * Result from splitArgs with file and folder references
+ */
+export interface SplitArgsResult {
+    /** Regular arguments */
+    args: string[];
+    /** File references (tokens starting with @ that point to files) */
+    files: string[];
+    /** Folder references (tokens starting with @ that point to directories) */
+    folders: string[];
+}
+/**
+ * Split a string into args array, respecting quoted strings
+ * Handles both single and double quotes, and extracts @file and @folder references
+ *
+ * @example
+ * splitArgs('"hello world" --force') // { args: ['hello world', '--force'], files: [], folders: [] }
+ * splitArgs("'hello world' -f") // { args: ['hello world', '-f'], files: [], folders: [] }
+ * splitArgs('query @src/file.ts') // { args: ['query'], files: ['src/file.ts'], folders: [] }
+ * splitArgs('"context" @src/') // { args: ['context'], files: [], folders: ['src/'] }
+ * splitArgs('text @src/ @README.md') // { args: ['text'], files: ['README.md'], folders: ['src/'] }
+ */
+export declare function splitArgs(input: string): SplitArgsResult;
+/**
+ * Parse result from parseReplArgs
+ */
+export interface ParsedReplArgs<TFlags extends FlagInput, TArgs extends ArgInput> {
+    /** Parsed arguments */
+    args: {
+        [K in keyof TArgs]: TArgs[K] extends {
+            required: true;
+        } ? string : string | undefined;
+    };
+    /** Remaining unparsed arguments (when strict: false) */
+    argv: string[];
+    /** File references extracted from @filepath tokens (non-directory paths) */
+    files: string[];
+    /** Parsed flags */
+    flags: {
+        [K in keyof TFlags]: TFlags[K] extends {
+            type: 'boolean';
+        } ? boolean : string | undefined;
+    };
+    /** Folder references extracted from @folderpath tokens (directory paths) */
+    folders: string[];
+}
+/**
+ * Parse REPL command arguments using oclif's Parser
+ *
+ * @param input - Raw input string from REPL (e.g., '"hello world" --force @src/file.ts')
+ * @param options - Parser options
+ * @param options.args - Argument definitions using Args from @oclif/core
+ * @param options.flags - Flag definitions using Flags from @oclif/core
+ * @param options.strict - Whether to error on unknown flags (default: false)
+ * @returns Parsed flags, args, remaining argv, and file references
+ *
+ * @example
+ * const result = await parseReplArgs('query text --verbose @src/auth.ts', {
+ *   args: { query: Args.string({ required: true }) },
+ *   flags: { verbose: Flags.boolean({ char: 'v' }) },
+ * })
+ * // result.args.query === 'query'
+ * // result.flags.verbose === true
+ * // result.argv === ['query', 'text']
+ * // result.files === ['src/auth.ts']
+ */
+export declare function parseReplArgs<TFlags extends FlagInput, TArgs extends ArgInput>(input: string, options: {
+    args?: TArgs;
+    flags?: TFlags;
+    strict?: boolean;
+}): Promise<ParsedReplArgs<TFlags, TArgs>>;

package/dist/tui/features/connectors/api/get-agent-config-paths.d.ts

@@ -0,0 +1,18 @@
+import type { Agent } from '../../../../shared/types/agent.js';
+import type { QueryConfig } from '../../../lib/react-query.js';
+import { type ConnectorGetAgentConfigPathsResponse } from '../../../../shared/transport/events/index.js';
+export declare const getAgentConfigPaths: (agentId: Agent) => Promise<ConnectorGetAgentConfigPathsResponse>;
+export declare const getAgentConfigPathsQueryOptions: (agentId: Agent) => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ConnectorGetAgentConfigPathsResponse, Error, ConnectorGetAgentConfigPathsResponse, string[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<ConnectorGetAgentConfigPathsResponse, string[], never> | undefined;
+} & {
+    queryKey: string[] & {
+        [dataTagSymbol]: ConnectorGetAgentConfigPathsResponse;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+type UseGetAgentConfigPathsOptions = {
+    agentId: Agent;
+    queryConfig?: QueryConfig<typeof getAgentConfigPathsQueryOptions>;
+};
+export declare const useGetAgentConfigPaths: ({ agentId, queryConfig }: UseGetAgentConfigPathsOptions) => import("@tanstack/react-query").UseQueryResult<ConnectorGetAgentConfigPathsResponse, Error>;
+export {};

package/dist/tui/features/connectors/api/get-agent-config-paths.js

@@ -0,0 +1,17 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { ConnectorEvents, } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const getAgentConfigPaths = (agentId) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(ConnectorEvents.GET_AGENT_CONFIG_PATHS, { agentId });
+};
+export const getAgentConfigPathsQueryOptions = (agentId) => queryOptions({
+    queryFn: () => getAgentConfigPaths(agentId),
+    queryKey: ['connectors', 'agentConfigPaths', agentId],
+});
+export const useGetAgentConfigPaths = ({ agentId, queryConfig }) => useQuery({
+    ...getAgentConfigPathsQueryOptions(agentId),
+    ...queryConfig,
+});