byterover-cli 1.7.2 → 2.0.0

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

package/dist/tui/features/connectors/api/get-agents.d.ts

@@ -0,0 +1,16 @@
+import type { QueryConfig } from '../../../lib/react-query.js';
+import { type ConnectorGetAgentsResponse } from '../../../../shared/transport/events/index.js';
+export declare const getAgents: () => Promise<ConnectorGetAgentsResponse>;
+export declare const getAgentsQueryOptions: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ConnectorGetAgentsResponse, Error, ConnectorGetAgentsResponse, string[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<ConnectorGetAgentsResponse, string[], never> | undefined;
+} & {
+    queryKey: string[] & {
+        [dataTagSymbol]: ConnectorGetAgentsResponse;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+type UseGetAgentsOptions = {
+    queryConfig?: QueryConfig<typeof getAgentsQueryOptions>;
+};
+export declare const useGetAgents: ({ queryConfig }?: UseGetAgentsOptions) => import("@tanstack/react-query").UseQueryResult<ConnectorGetAgentsResponse, Error>;
+export {};

package/dist/tui/features/connectors/api/get-agents.js

@@ -0,0 +1,19 @@
+import { queryOptions, useQuery } from '@tanstack/react-query';
+import { ConnectorEvents } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+export const getAgents = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(ConnectorEvents.GET_AGENTS);
+};
+export const getAgentsQueryOptions = () => queryOptions({
+    gcTime: Infinity,
+    queryFn: getAgents,
+    queryKey: ['connectors', 'agents'],
+    staleTime: Infinity, // Static data - agents don't change during session
+});
+export const useGetAgents = ({ queryConfig } = {}) => useQuery({
+    ...getAgentsQueryOptions(),
+    ...queryConfig,
+});

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

@@ -0,0 +1,16 @@
+import type { QueryConfig } from '../../../lib/react-query.js';
+import { type ConnectorListResponse } from '../../../../shared/transport/events/index.js';
+export declare const getConnectors: () => Promise<ConnectorListResponse>;
+export declare const getConnectorsQueryOptions: () => import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ConnectorListResponse, Error, ConnectorListResponse, string[]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<ConnectorListResponse, string[], never> | undefined;
+} & {
+    queryKey: string[] & {
+        [dataTagSymbol]: ConnectorListResponse;
+        [dataTagErrorSymbol]: Error;
+    };
+};
+type UseGetConnectorsOptions = {
+    queryConfig?: QueryConfig<typeof getConnectorsQueryOptions>;
+};
+export declare const useGetConnectors: ({ queryConfig }?: UseGetConnectorsOptions) => import("@tanstack/react-query").UseQueryResult<ConnectorListResponse, Error>;
+export {};

package/dist/tui/features/connectors/api/get-connectors.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 getConnectors = () => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(ConnectorEvents.LIST);
+};
+export const getConnectorsQueryOptions = () => queryOptions({
+    queryFn: getConnectors,
+    queryKey: ['connectors', 'list'],
+});
+export const useGetConnectors = ({ queryConfig } = {}) => useQuery({
+    ...getConnectorsQueryOptions(),
+    ...queryConfig,
+});

package/dist/tui/features/connectors/api/install-connector.d.ts

@@ -0,0 +1,14 @@
+import type { Agent } from '../../../../shared/types/agent.js';
+import type { ConnectorType } from '../../../../shared/types/connector-type.js';
+import type { MutationConfig } from '../../../lib/react-query.js';
+import { type ConnectorInstallResponse } from '../../../../shared/transport/events/index.js';
+export type InstallConnectorDTO = {
+    agentId: Agent;
+    connectorType: ConnectorType;
+};
+export declare const installConnector: ({ agentId, connectorType }: InstallConnectorDTO) => Promise<ConnectorInstallResponse>;
+type UseInstallConnectorOptions = {
+    mutationConfig?: MutationConfig<typeof installConnector>;
+};
+export declare const useInstallConnector: ({ mutationConfig }?: UseInstallConnectorOptions) => import("@tanstack/react-query").UseMutationResult<ConnectorInstallResponse, Error, InstallConnectorDTO, unknown>;
+export {};

package/dist/tui/features/connectors/api/install-connector.js

@@ -0,0 +1,27 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { ConnectorEvents, } from '../../../../shared/transport/events/index.js';
+import { useTransportStore } from '../../../stores/transport-store.js';
+import { getConnectorsQueryOptions } from './get-connectors.js';
+export const installConnector = ({ agentId, connectorType }) => {
+    const { apiClient } = useTransportStore.getState();
+    if (!apiClient)
+        return Promise.reject(new Error('Not connected'));
+    return apiClient.request(ConnectorEvents.INSTALL, {
+        agentId,
+        connectorType,
+    });
+};
+export const useInstallConnector = ({ mutationConfig } = {}) => {
+    const queryClient = useQueryClient();
+    const { onSuccess, ...restConfig } = mutationConfig ?? {};
+    return useMutation({
+        onSuccess(...args) {
+            queryClient.invalidateQueries({
+                queryKey: getConnectorsQueryOptions().queryKey,
+            });
+            onSuccess?.(...args);
+        },
+        ...restConfig,
+        mutationFn: installConnector,
+    });
+};

package/dist/tui/features/connectors/components/agent-search-step.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { AgentDTO } from '../../../../shared/transport/types/dto.js';
+export interface AgentSearchStepProps {
+    agents: AgentDTO[];
+    isActive: boolean;
+    onCancel: () => void;
+    onSelect: (agent: AgentDTO) => void;
+}
+export declare const AgentSearchStep: React.FC<AgentSearchStepProps>;

package/dist/tui/features/connectors/components/agent-search-step.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from 'ink';
+import { SelectableList } from '../../../components/selectable-list.js';
+import { useTheme } from '../../../hooks/index.js';
+export const AgentSearchStep = ({ agents, isActive, onCancel, onSelect, }) => {
+    const { theme: { colors } } = useTheme();
+    const items = agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+    }));
+    const handleSelect = (item) => {
+        const agent = agents.find((a) => a.id === item.id);
+        if (agent) {
+            onSelect(agent);
+        }
+    };
+    return (_jsx(SelectableList, { filterKeys: (item) => [item.id, item.name], getCurrentKey: (item) => item.id, isActive: isActive, items: items, keyExtractor: (item) => item.id, onCancel: onCancel, onSelect: handleSelect, renderItem: (item, isHighlighted) => (_jsx(Text, { backgroundColor: isHighlighted ? colors.dimText : undefined, color: colors.text, children: item.name })), searchPlaceholder: "Search agents...", title: "Which agent are you using?" }));
+};

package/dist/tui/features/connectors/components/confirm-switch-step.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { ConnectorType } from '../../../../shared/types/connector-type.js';
+export interface ConfirmSwitchStepProps {
+    agentName: string;
+    fromType: ConnectorType;
+    isActive: boolean;
+    onConfirm: (confirmed: boolean) => void;
+    toType: ConnectorType;
+}
+export declare const ConfirmSwitchStep: React.FC<ConfirmSwitchStepProps>;

package/dist/tui/features/connectors/components/confirm-switch-step.js

@@ -0,0 +1,13 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { SelectableList } from '../../../components/selectable-list.js';
+import { useTheme } from '../../../hooks/index.js';
+import { getConnectorName } from '../utils/get-connector-name.js';
+export const ConfirmSwitchStep = ({ agentName, fromType, isActive, onConfirm, toType, }) => {
+    const { theme: { colors }, } = useTheme();
+    const items = [
+        { id: 'yes', name: 'Yes' },
+        { id: 'no', name: 'No' },
+    ];
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsxs(Text, { color: colors.text, children: ["Switch ", agentName, " from ", getConnectorName(fromType), " to ", getConnectorName(toType), "?"] }) }), _jsx(SelectableList, { filterKeys: (item) => [item.name], getCurrentKey: (item) => item.id, isActive: isActive, items: items, keyExtractor: (item) => item.id, onCancel: () => onConfirm(false), onSelect: (item) => onConfirm(item.id === 'yes'), renderItem: (item, isHighlighted) => (_jsx(Text, { backgroundColor: isHighlighted ? colors.dimText : undefined, color: colors.text, children: item.name })), title: "Confirm" })] }));
+};

package/dist/tui/features/connectors/components/connector-list-step.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { ConnectorDTO } from '../../../../shared/transport/types/dto.js';
+export interface ConnectorListStepProps {
+    connectors: ConnectorDTO[];
+    error: null | string;
+    isActive: boolean;
+    onAddNew: () => void;
+    onCancel: () => void;
+    onSelectConnector: (connector: ConnectorDTO) => void;
+}
+export declare const ConnectorListStep: React.FC<ConnectorListStepProps>;

package/dist/tui/features/connectors/components/connector-list-step.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { useMemo } from 'react';
+import { SelectableList } from '../../../components/selectable-list.js';
+import { useTheme } from '../../../hooks/index.js';
+import { getConnectorName } from '../utils/get-connector-name.js';
+const CONNECT_NEW_AGENT_ID = '__new__';
+export const ConnectorListStep = ({ connectors, error, isActive, onAddNew, onCancel, onSelectConnector, }) => {
+    const { theme: { colors }, } = useTheme();
+    const listItems = useMemo(() => [
+        ...connectors.map((c) => ({
+            description: '',
+            id: c.agent,
+            name: `${c.agent} (${getConnectorName(c.connectorType)})`,
+        })),
+        { description: '', id: CONNECT_NEW_AGENT_ID, name: '+ Connect a new agent' },
+    ], [connectors]);
+    const handleSelect = (item) => {
+        if (item.id === CONNECT_NEW_AGENT_ID) {
+            onAddNew();
+            return;
+        }
+        const connector = connectors.find((c) => c.agent === item.id);
+        if (connector) {
+            onSelectConnector(connector);
+        }
+    };
+    return (_jsxs(Box, { flexDirection: "column", children: [error && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: colors.errorText, children: error }) })), connectors.length === 0 && (_jsx(Box, { marginBottom: 1, children: _jsx(Text, { color: colors.dimText, children: "No agents connected yet." }) })), _jsx(SelectableList, { filterKeys: (item) => [item.id, item.name], getCurrentKey: (item) => item.id, isActive: isActive, items: listItems, keyExtractor: (item) => item.id, onCancel: onCancel, onSelect: handleSelect, renderItem: (item, isHighlighted) => (_jsxs(Box, { gap: 2, children: [_jsx(Text, { backgroundColor: isHighlighted ? colors.dimText : undefined, color: colors.text, children: item.name }), item.description && _jsx(Text, { color: colors.dimText, children: item.description })] })), title: "Manage agent connectors" })] }));
+};

package/dist/tui/features/connectors/components/connector-type-step.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { ConnectorType } from '../../../../shared/types/connector-type.js';
+export interface ConnectorTypeStepProps {
+    agentName: string;
+    configPaths?: Partial<Record<ConnectorType, string>>;
+    currentType?: ConnectorType;
+    defaultType: ConnectorType;
+    isActive: boolean;
+    onCancel: () => void;
+    onSelect: (connectorType: ConnectorType) => void;
+    supportedTypes: ConnectorType[];
+}
+export declare const ConnectorTypeStep: React.FC<ConnectorTypeStepProps>;

package/dist/tui/features/connectors/components/connector-type-step.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { SelectableList } from '../../../components/selectable-list.js';
+import { useTheme } from '../../../hooks/index.js';
+import { getConnectorDescription, getConnectorName } from '../utils/get-connector-name.js';
+export const ConnectorTypeStep = ({ agentName, configPaths, currentType, defaultType, isActive, onCancel, onSelect, supportedTypes, }) => {
+    const { theme: { colors }, } = useTheme();
+    const items = supportedTypes.map((t) => ({
+        description: getConnectorDescription(t, configPaths?.[t]),
+        id: t,
+        name: getConnectorName(t),
+        status: t === currentType ? '(current)' : t === defaultType ? '(default)' : '',
+    }));
+    const maxLabelLength = Math.max(...items.map((item) => item.name.length + (item.status ? 1 + item.status.length : 0)));
+    const handleSelect = (item) => {
+        onSelect(item.id);
+    };
+    return (_jsx(SelectableList, { filterKeys: (item) => [item.name], getCurrentKey: (item) => item.id, isActive: isActive, items: items, keyExtractor: (item) => item.id, onCancel: onCancel, onSelect: handleSelect, renderItem: (item, isHighlighted) => {
+            const labelLength = item.name.length + (item.status ? 1 + item.status.length : 0);
+            const padding = ' '.repeat(maxLabelLength - labelLength);
+            return (_jsxs(Box, { gap: 2, children: [_jsxs(Text, { children: [_jsx(Text, { backgroundColor: isHighlighted ? colors.dimText : undefined, color: colors.text, children: item.name }), item.status && _jsx(Text, { color: colors.primary, children: ` ${item.status}` }), padding] }), _jsx(Text, { color: colors.dimText, children: item.description })] }));
+        }, title: `Select connector type for ${agentName}` }));
+};

package/dist/tui/features/connectors/components/connectors-flow.d.ts

@@ -0,0 +1,17 @@
+/**
+ * ConnectorsFlow Component
+ *
+ * Multi-step React flow for the /connector command.
+ * State machine: list → search_agent → select_type → confirm | installing → done
+ *
+ * 1. Shows installed connectors + "Add new agent" option
+ * 2a. If existing selected → show connector type options → confirm switch → install
+ * 2b. If "add new" selected → search agent list → select connector type → install
+ */
+import React from 'react';
+export interface ConnectorsFlowProps {
+    isActive?: boolean;
+    onCancel: () => void;
+    onComplete: (message: string) => void;
+}
+export declare const ConnectorsFlow: React.FC<ConnectorsFlowProps>;

package/dist/tui/features/connectors/components/connectors-flow.js

@@ -0,0 +1,179 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * ConnectorsFlow Component
+ *
+ * Multi-step React flow for the /connector command.
+ * State machine: list → search_agent → select_type → confirm | installing → done
+ *
+ * 1. Shows installed connectors + "Add new agent" option
+ * 2a. If existing selected → show connector type options → confirm switch → install
+ * 2b. If "add new" selected → search agent list → select connector type → install
+ */
+import chalk from 'chalk';
+import { Box, Text } from 'ink';
+import { useCallback, useMemo, useState } from 'react';
+import { requiresAgentRestart } from '../../../../shared/types/connector-type.js';
+import { useTheme } from '../../../hooks/index.js';
+import { useGetAgentConfigPaths } from '../api/get-agent-config-paths.js';
+import { useGetAgents } from '../api/get-agents.js';
+import { useGetConnectors } from '../api/get-connectors.js';
+import { useInstallConnector } from '../api/install-connector.js';
+import { getConnectorName } from '../utils/get-connector-name.js';
+import { AgentSearchStep } from './agent-search-step.js';
+import { ConfirmSwitchStep } from './confirm-switch-step.js';
+import { ConnectorListStep } from './connector-list-step.js';
+import { ConnectorTypeStep } from './connector-type-step.js';
+export const ConnectorsFlow = ({ isActive = true, onCancel, onComplete }) => {
+    const { theme: { colors }, } = useTheme();
+    const [step, setStep] = useState('list');
+    const [selection, setSelection] = useState(null);
+    const [error, setError] = useState(null);
+    const { data: connectorsData, isLoading: isLoadingConnectors } = useGetConnectors();
+    const { data: agentsData, isLoading: isLoadingAgents } = useGetAgents();
+    const installMutation = useInstallConnector();
+    const selectedAgentId = selection?.kind === 'existing' ? selection.connector.agent : selection?.agent.id;
+    const { data: configPathsData } = useGetAgentConfigPaths({
+        agentId: selectedAgentId,
+        queryConfig: { enabled: Boolean(selectedAgentId) },
+    });
+    const connectors = connectorsData?.connectors ?? [];
+    const allAgents = agentsData?.agents ?? [];
+    const isLoading = isLoadingConnectors || isLoadingAgents;
+    // Filter out already-connected agents
+    const availableAgents = useMemo(() => {
+        const connected = new Set(connectors.map((c) => c.agent));
+        return allAgents.filter((a) => !connected.has(a.id));
+    }, [connectors, allAgents]);
+    // --- Handlers ---
+    const handleSelectConnector = useCallback((connector) => {
+        setSelection({ connector, kind: 'existing' });
+        setStep('select_type');
+    }, []);
+    const handleAddNew = useCallback(() => {
+        setStep('search_agent');
+    }, []);
+    const handleSelectAgent = useCallback((agent) => {
+        setSelection({ agent, kind: 'new_agent' });
+        setStep('select_type');
+    }, []);
+    const handleSelectType = useCallback(async (connectorType) => {
+        if (!selection)
+            return;
+        if (selection.kind === 'existing') {
+            // Same type selected - go back
+            if (connectorType === selection.connector.connectorType) {
+                setStep('list');
+                return;
+            }
+            // Confirm before switching
+            setSelection({ ...selection, newType: connectorType });
+            setStep('confirm_switch');
+            return;
+        }
+        // New agent - install directly
+        await installConnector(selection.agent.id, selection.agent.name, connectorType);
+    }, [selection]);
+    const handleConfirmSwitch = useCallback(async (confirmed) => {
+        if (!selection || selection.kind !== 'existing' || !selection.newType) {
+            setStep('list');
+            return;
+        }
+        if (!confirmed) {
+            onComplete(`Kept ${selection.connector.agent} connected via ${getConnectorName(selection.connector.connectorType)}`);
+            return;
+        }
+        await installConnector(selection.connector.agent, selection.connector.agent, selection.newType, selection.connector.connectorType);
+    }, [selection, onComplete]);
+    const handleCancelTypeSelection = useCallback(() => {
+        if (selection?.kind === 'new_agent') {
+            setSelection(null);
+            setStep('search_agent');
+        }
+        else {
+            setSelection(null);
+            setStep('list');
+        }
+    }, [selection]);
+    // --- Install Logic ---
+    async function installConnector(agentId, agentName, connectorType, fromType) {
+        setStep('installing');
+        try {
+            const result = await installMutation.mutateAsync({ agentId, connectorType });
+            if (result.success) {
+                if (result.requiresManualSetup && result.manualInstructions) {
+                    const lines = [
+                        `Manual setup required for ${agentName}`,
+                        '',
+                        'Add this configuration to your MCP settings:',
+                        '',
+                        result.manualInstructions.configContent,
+                    ];
+                    if (result.manualInstructions.guide) {
+                        lines.push('', `For detailed instructions, see: ${result.manualInstructions.guide}`);
+                    }
+                    onComplete(lines.join('\n'));
+                    return;
+                }
+                const statusMessage = fromType
+                    ? `${agentName} switched from ${getConnectorName(fromType)} to ${getConnectorName(connectorType)}`
+                    : `${agentName} connected via ${getConnectorName(connectorType)}`;
+                const locationLine = result.configPath ? `\nLocation: ${result.configPath}` : '';
+                const prompt = chalk.hex('#0AA77D').italic('> "Save our API authentication patterns, use brv curate"');
+                const restartAgentRequired = requiresAgentRestart(connectorType);
+                const message = `${statusMessage}${locationLine}
+${restartAgentRequired ? `\n⚠️  Please restart ${agentName} to apply the new ${getConnectorName(connectorType)}.` : ''}
+
+WHAT'S NEXT
+Try this in your next prompt:
+${prompt}
+Docs: https://docs.byterover.dev/common-workflows/curate-context`;
+                onComplete(message);
+            }
+            else {
+                setError(result.message ?? `Failed to configure ${agentName}`);
+                setStep('list');
+            }
+        }
+        catch (error_) {
+            setError(error_ instanceof Error ? error_.message : String(error_));
+            setStep('list');
+        }
+    }
+    // --- Render Helpers ---
+    function renderSelectTypeStep() {
+        if (!selection)
+            return null;
+        const isExisting = selection.kind === 'existing';
+        const agentName = isExisting ? selection.connector.agent : selection.agent.name;
+        const supportedTypes = isExisting ? selection.connector.supportedTypes : selection.agent.supportedConnectorTypes;
+        const defaultType = isExisting ? selection.connector.defaultType : selection.agent.defaultConnectorType;
+        const currentType = isExisting ? selection.connector.connectorType : undefined;
+        return (_jsx(ConnectorTypeStep, { agentName: agentName, configPaths: configPathsData?.configPaths, currentType: currentType, defaultType: defaultType, isActive: isActive, onCancel: handleCancelTypeSelection, onSelect: handleSelectType, supportedTypes: supportedTypes }));
+    }
+    // --- Render ---
+    if (isLoading) {
+        return (_jsx(Box, { children: _jsx(Text, { color: colors.dimText, children: "Loading connectors..." }) }));
+    }
+    switch (step) {
+        case 'confirm_switch': {
+            if (!selection || selection.kind !== 'existing' || !selection.newType)
+                return null;
+            return (_jsx(ConfirmSwitchStep, { agentName: selection.connector.agent, fromType: selection.connector.connectorType, isActive: isActive, onConfirm: handleConfirmSwitch, toType: selection.newType }));
+        }
+        case 'installing': {
+            return (_jsx(Box, { children: _jsx(Text, { color: colors.primary, children: "Installing connector..." }) }));
+        }
+        case 'list': {
+            return (_jsx(ConnectorListStep, { connectors: connectors, error: error, isActive: isActive, onAddNew: handleAddNew, onCancel: onCancel, onSelectConnector: handleSelectConnector }));
+        }
+        case 'search_agent': {
+            return (_jsx(AgentSearchStep, { agents: availableAgents, isActive: isActive, onCancel: () => setStep('list'), onSelect: handleSelectAgent }));
+        }
+        case 'select_type': {
+            return renderSelectTypeStep();
+        }
+        default: {
+            return null;
+        }
+    }
+};

package/dist/tui/features/connectors/utils/get-connector-name.d.ts

@@ -0,0 +1,3 @@
+import type { ConnectorType } from '../../../../shared/types/connector-type.js';
+export declare const getConnectorDescription: (type: ConnectorType, configPath?: string) => string;
+export declare const getConnectorName: (type: ConnectorType) => string;

package/dist/tui/features/connectors/utils/get-connector-name.js

@@ -0,0 +1,33 @@
+export const getConnectorDescription = (type, configPath) => {
+    const path = configPath ? ` (${configPath})` : '';
+    switch (type) {
+        case 'hook': {
+            return `Instructions injected on each prompt${path}`;
+        }
+        case 'mcp': {
+            return `Agent connects via MCP protocol${path}`;
+        }
+        case 'rules': {
+            return `Agent reads instructions from rule file${path}`;
+        }
+        case 'skill': {
+            return `Agent reads skill files from project directory${path}`;
+        }
+    }
+};
+export const getConnectorName = (type) => {
+    switch (type) {
+        case 'hook': {
+            return 'Hook';
+        }
+        case 'mcp': {
+            return 'MCP';
+        }
+        case 'rules': {
+            return 'Rules';
+        }
+        case 'skill': {
+            return 'Agent Skill';
+        }
+    }
+};