byterover-cli 1.6.0 → 1.7.0

package/dist/server/infra/connectors/connector-manager.js

@@ -0,0 +1,206 @@
+import { AGENT_CONNECTOR_CONFIG, AGENT_VALUES } from '../../core/domain/entities/agent.js';
+import { CONNECTOR_TYPES } from '../../core/domain/entities/connector-type.js';
+import { HOOK_CONNECTOR_CONFIGS } from './hook/hook-connector-config.js';
+import { HookConnector } from './hook/hook-connector.js';
+import { MCP_CONNECTOR_CONFIGS } from './mcp/mcp-connector-config.js';
+import { McpConnector } from './mcp/mcp-connector.js';
+import { RULES_CONNECTOR_CONFIGS } from './rules/rules-connector-config.js';
+import { RulesConnector } from './rules/rules-connector.js';
+import { SKILL_CONNECTOR_CONFIGS } from './skill/skill-connector-config.js';
+import { SkillConnector } from './skill/skill-connector.js';
+/**
+ * Factory and orchestration layer for connectors.
+ * Creates connector instances and manages connector operations.
+ */
+export class ConnectorManager {
+    connectors;
+    constructor(options) {
+        const { fileService, projectRoot, templateService } = options;
+        // Create connector instances
+        this.connectors = new Map([
+            ['hook', new HookConnector({ fileService, projectRoot })],
+            ['mcp', new McpConnector({ fileService, projectRoot, templateService })],
+            ['rules', new RulesConnector({ fileService, projectRoot, templateService })],
+            ['skill', new SkillConnector({ fileService, projectRoot })],
+        ]);
+    }
+    async getAllInstalledConnectors() {
+        const installed = new Map();
+        // Check all agents in parallel
+        const results = await Promise.all(AGENT_VALUES.map(async (agent) => {
+            const connectorType = await this.getInstalledConnectorType(agent);
+            return { agent, connectorType };
+        }));
+        // Add only agents with installed connectors to the map
+        for (const { agent, connectorType } of results) {
+            if (connectorType) {
+                installed.set(agent, connectorType);
+            }
+        }
+        return installed;
+    }
+    getConnector(type) {
+        const connector = this.connectors.get(type);
+        if (!connector) {
+            throw new Error(`Unknown connector type: ${type}`);
+        }
+        return connector;
+    }
+    getDefaultConnectorType(agent) {
+        return AGENT_CONNECTOR_CONFIG[agent].default;
+    }
+    async getInstalledConnectorType(agent) {
+        // Check each connector type to see if it's installed
+        // We need to check sequentially to return the first installed connector
+        const checkResults = await Promise.all(CONNECTOR_TYPES.map(async (type) => {
+            const connector = this.connectors.get(type);
+            if (connector && connector.isSupported(agent)) {
+                const status = await connector.status(agent);
+                return status.installed ? type : null;
+            }
+            return null;
+        }));
+        return checkResults.find((type) => type !== null) ?? null;
+    }
+    getSupportedConnectorTypes(agent) {
+        const supported = [];
+        for (const type of CONNECTOR_TYPES) {
+            const connector = this.connectors.get(type);
+            if (connector && connector.isSupported(agent)) {
+                supported.push(type);
+            }
+        }
+        return supported;
+    }
+    async installDefault(agent) {
+        const defaultType = this.getDefaultConnectorType(agent);
+        const connector = this.getConnector(defaultType);
+        return connector.install(agent);
+    }
+    async migrateOrphanedConnectors() {
+        // Step 1: Collect orphaned agent/connector pairs. Each connector config map
+        // (e.g., MCP_CONNECTOR_CONFIGS) defines which agents have configs for that type.
+        // An agent is orphaned when it exists in the config map but the connector type
+        // is no longer in AGENT_CONNECTOR_CONFIG[agent].supported.
+        const connectorConfigAgents = [
+            { agents: AGENT_VALUES.filter((a) => a in HOOK_CONNECTOR_CONFIGS), type: 'hook' },
+            { agents: AGENT_VALUES.filter((a) => a in MCP_CONNECTOR_CONFIGS), type: 'mcp' },
+            { agents: AGENT_VALUES.filter((a) => a in RULES_CONNECTOR_CONFIGS), type: 'rules' },
+            { agents: AGENT_VALUES.filter((a) => a in SKILL_CONNECTOR_CONFIGS), type: 'skill' },
+        ];
+        const orphanedPairs = [];
+        for (const { agents, type } of connectorConfigAgents) {
+            const connector = this.connectors.get(type);
+            if (!connector)
+                continue;
+            for (const agent of agents) {
+                if (!AGENT_CONNECTOR_CONFIG[agent].supported.includes(type)) {
+                    orphanedPairs.push({ agent, connector });
+                }
+            }
+        }
+        // Step 2: Check each candidate in parallel. Use { force: true } to bypass
+        // the isSupported() guard, since these connectors are no longer in the
+        // agent's supported list but may still have configs on disk from when
+        // they were previously supported.
+        const settledResults = await Promise.allSettled(orphanedPairs.map(async ({ agent, connector }) => {
+            const status = await connector.status(agent, { force: true });
+            if (!status.installed)
+                return null;
+            const uninstallResult = await connector.uninstall(agent, { force: true });
+            return {
+                agent,
+                configPath: uninstallResult.configPath,
+                success: uninstallResult.success,
+            };
+        }));
+        return settledResults
+            .filter((r) => r.status === 'fulfilled')
+            .map((r) => r.value)
+            .filter((result) => result !== null);
+    }
+    async status(type, agent) {
+        const connector = this.getConnector(type);
+        return connector.status(agent);
+    }
+    async switchConnector(agent, toType) {
+        const toConnector = this.getConnector(toType);
+        if (!toConnector.isSupported(agent)) {
+            return {
+                fromType: null,
+                installResult: {
+                    alreadyInstalled: false,
+                    configPath: '',
+                    message: `Connector type '${toType}' does not support agent: ${agent}`,
+                    success: false,
+                },
+                message: `Connector type '${toType}' does not support agent: ${agent}`,
+                success: false,
+                toType,
+            };
+        }
+        // Check if any connector is currently installed
+        const currentType = await this.getInstalledConnectorType(agent);
+        // If switching to the same type, just return success
+        if (currentType === toType) {
+            const status = await toConnector.status(agent);
+            return {
+                fromType: currentType,
+                installResult: {
+                    alreadyInstalled: true,
+                    configPath: status.configPath,
+                    message: `${toType} connector is already installed for ${agent}`,
+                    success: true,
+                },
+                message: `${toType} connector is already installed for ${agent}`,
+                success: true,
+                toType,
+            };
+        }
+        // Uninstall current connector if one exists
+        let uninstallResult;
+        if (currentType) {
+            const currentConnector = this.getConnector(currentType);
+            uninstallResult = await currentConnector.uninstall(agent);
+            if (!uninstallResult.success) {
+                return {
+                    fromType: currentType,
+                    installResult: {
+                        alreadyInstalled: false,
+                        configPath: '',
+                        message: 'Installation skipped due to uninstall failure',
+                        success: false,
+                    },
+                    message: `Failed to uninstall ${currentType} connector: ${uninstallResult.message}`,
+                    success: false,
+                    toType,
+                    uninstallResult,
+                };
+            }
+        }
+        // Install new connector
+        const installResult = await toConnector.install(agent);
+        if (!installResult.success) {
+            return {
+                fromType: currentType,
+                installResult,
+                message: `Failed to install ${toType} connector: ${installResult.message}`,
+                success: false,
+                toType,
+                uninstallResult,
+            };
+        }
+        // Build success message
+        const message = currentType
+            ? `Switched ${agent} from ${currentType} to ${toType}`
+            : `Installed ${toType} connector for ${agent}`;
+        return {
+            fromType: currentType,
+            installResult,
+            message,
+            success: true,
+            toType,
+            uninstallResult,
+        };
+    }
+}

package/dist/server/infra/connectors/hook/hook-connector.d.ts

@@ -0,0 +1,46 @@
+import type { Agent } from '../../../core/domain/entities/agent.js';
+import type { ConnectorType } from '../../../core/domain/entities/connector-type.js';
+import type { ConnectorInstallResult, ConnectorStatus, ConnectorUninstallResult } from '../../../core/interfaces/connectors/connector-types.js';
+import type { ConnectorOperationOptions, IConnector } from '../../../core/interfaces/connectors/i-connector.js';
+import type { IFileService } from '../../../core/interfaces/services/i-file-service.js';
+import { type HookSupportedAgent } from './hook-connector-config.js';
+/**
+ * Options for constructing HookConnector.
+ */
+type HookConnectorOptions = {
+    fileService: IFileService;
+    projectRoot: string;
+};
+/**
+ * Connector that integrates BRV with coding agents via hooks.
+ * Manages hook configurations stored in JSON files.
+ *
+ * Key safety features:
+ * - Non-destructive: Preserves user's existing hooks
+ * - No duplicates: Checks before adding new hooks
+ * - Safe uninstall: Only removes ByteRover hooks by command match
+ */
+export declare class HookConnector implements IConnector {
+    readonly connectorType: ConnectorType;
+    private readonly fileService;
+    private readonly projectRoot;
+    private readonly supportedAgents;
+    constructor(options: HookConnectorOptions);
+    getConfigPath(agent: Agent): string;
+    getSupportedAgents(): Agent[];
+    install(agent: Agent): Promise<ConnectorInstallResult>;
+    isSupported(agent: Agent): agent is HookSupportedAgent;
+    status(agent: Agent, options?: ConnectorOperationOptions): Promise<ConnectorStatus>;
+    uninstall(agent: Agent, options?: ConnectorOperationOptions): Promise<ConnectorUninstallResult>;
+    /**
+     * Get the hooks array from the config for a specific event key.
+     * Handles the nested structure: config.hooks[eventKey]
+     */
+    private getHooksArray;
+    /**
+     * Set the hooks array in the config for a specific event key.
+     * Creates the nested structure if it doesn't exist.
+     */
+    private setHooksArray;
+}
+export {};

package/dist/server/infra/connectors/hook/hook-connector.js

@@ -0,0 +1,246 @@
+import path from 'node:path';
+import { AGENT_CONNECTOR_CONFIG } from '../../../core/domain/entities/agent.js';
+import { isRecord } from '../../../utils/type-guards.js';
+import { HOOK_CONNECTOR_CONFIGS } from './hook-connector-config.js';
+/**
+ * Parse JSON and validate it's a Record object.
+ * @throws Error if JSON is invalid or not an object
+ */
+function parseJsonAsRecord(content) {
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed)) {
+        throw new Error('Expected JSON object');
+    }
+    return parsed;
+}
+/**
+ * Connector that integrates BRV with coding agents via hooks.
+ * Manages hook configurations stored in JSON files.
+ *
+ * Key safety features:
+ * - Non-destructive: Preserves user's existing hooks
+ * - No duplicates: Checks before adding new hooks
+ * - Safe uninstall: Only removes ByteRover hooks by command match
+ */
+export class HookConnector {
+    connectorType = 'hook';
+    fileService;
+    projectRoot;
+    supportedAgents;
+    constructor(options) {
+        this.fileService = options.fileService;
+        this.projectRoot = options.projectRoot;
+        this.supportedAgents = Object.entries(AGENT_CONNECTOR_CONFIG)
+            .filter(([_, config]) => config.supported.includes(this.connectorType))
+            .map(([agent]) => agent);
+    }
+    getConfigPath(agent) {
+        if (!this.isSupported(agent)) {
+            throw new Error(`Hook connector does not support agent: ${agent}`);
+        }
+        return HOOK_CONNECTOR_CONFIGS[agent].configPath;
+    }
+    getSupportedAgents() {
+        return this.supportedAgents;
+    }
+    async install(agent) {
+        if (!this.isSupported(agent)) {
+            return {
+                alreadyInstalled: false,
+                configPath: '',
+                message: `Hook connector does not support agent: ${agent}`,
+                success: false,
+            };
+        }
+        const config = HOOK_CONNECTOR_CONFIGS[agent];
+        const fullPath = path.join(this.projectRoot, config.configPath);
+        try {
+            const exists = await this.fileService.exists(fullPath);
+            if (exists) {
+                // Read existing config
+                const content = await this.fileService.read(fullPath);
+                const json = parseJsonAsRecord(content);
+                // Check if our hook already exists
+                const hooks = this.getHooksArray(json, config.hookEventKey);
+                const alreadyInstalled = hooks.some((entry) => config.isOurHook(entry));
+                if (alreadyInstalled) {
+                    return {
+                        alreadyInstalled: true,
+                        configPath: config.configPath,
+                        message: `Hook connector is already installed for ${agent}`,
+                        success: true,
+                    };
+                }
+                // Add our hook to the array (preserve existing hooks)
+                const newEntry = config.createHookEntry();
+                this.setHooksArray(json, config.hookEventKey, [...hooks, newEntry]);
+                // Write back
+                await this.fileService.write(JSON.stringify(json, null, 2), fullPath, 'overwrite');
+                return {
+                    alreadyInstalled: false,
+                    configPath: config.configPath,
+                    message: `Hook connector installed for ${agent}`,
+                    success: true,
+                };
+            }
+            // File doesn't exist - create new config
+            const newConfig = config.defaultConfig ? structuredClone(config.defaultConfig) : {};
+            this.setHooksArray(newConfig, config.hookEventKey, [config.createHookEntry()]);
+            await this.fileService.write(JSON.stringify(newConfig, null, 2), fullPath, 'overwrite');
+            return {
+                alreadyInstalled: false,
+                configPath: config.configPath,
+                message: `Hook connector installed for ${agent} (created ${config.configPath})`,
+                success: true,
+            };
+        }
+        catch (error) {
+            return {
+                alreadyInstalled: false,
+                configPath: config.configPath,
+                message: `Failed to install hook connector for ${agent}: ${error instanceof Error ? error.message : String(error)}`,
+                success: false,
+            };
+        }
+    }
+    isSupported(agent) {
+        return AGENT_CONNECTOR_CONFIG[agent].supported.includes(this.connectorType);
+    }
+    async status(agent, options) {
+        if (!options?.force && !this.isSupported(agent)) {
+            return {
+                configExists: false,
+                configPath: '',
+                error: `Hook connector does not support agent: ${agent}`,
+                installed: false,
+            };
+        }
+        if (!(agent in HOOK_CONNECTOR_CONFIGS)) {
+            return {
+                configExists: false,
+                configPath: '',
+                installed: false,
+            };
+        }
+        const config = HOOK_CONNECTOR_CONFIGS[agent];
+        const fullPath = path.join(this.projectRoot, config.configPath);
+        try {
+            const exists = await this.fileService.exists(fullPath);
+            if (!exists) {
+                return {
+                    configExists: false,
+                    configPath: config.configPath,
+                    installed: false,
+                };
+            }
+            // Read and check for our hook
+            const content = await this.fileService.read(fullPath);
+            const json = parseJsonAsRecord(content);
+            const hooks = this.getHooksArray(json, config.hookEventKey);
+            const installed = hooks.some((entry) => config.isOurHook(entry));
+            return {
+                configExists: true,
+                configPath: config.configPath,
+                installed,
+            };
+        }
+        catch (error) {
+            return {
+                configExists: true,
+                configPath: config.configPath,
+                error: error instanceof Error ? error.message : String(error),
+                installed: false,
+            };
+        }
+    }
+    async uninstall(agent, options) {
+        if (!options?.force && !this.isSupported(agent)) {
+            return {
+                configPath: '',
+                message: `Hook connector does not support agent: ${agent}`,
+                success: false,
+                wasInstalled: false,
+            };
+        }
+        if (!(agent in HOOK_CONNECTOR_CONFIGS)) {
+            return {
+                configPath: '',
+                message: `Hook connector has no config for agent: ${agent}`,
+                success: true,
+                wasInstalled: false,
+            };
+        }
+        const config = HOOK_CONNECTOR_CONFIGS[agent];
+        const fullPath = path.join(this.projectRoot, config.configPath);
+        let wasInstalled = false;
+        try {
+            const exists = await this.fileService.exists(fullPath);
+            if (!exists) {
+                return {
+                    configPath: config.configPath,
+                    message: `Config file does not exist: ${config.configPath}`,
+                    success: true,
+                    wasInstalled: false,
+                };
+            }
+            // Read existing config
+            const content = await this.fileService.read(fullPath);
+            const json = parseJsonAsRecord(content);
+            // Get current hooks and filter out ours
+            const hooks = this.getHooksArray(json, config.hookEventKey);
+            wasInstalled = hooks.some((entry) => config.isOurHook(entry));
+            if (!wasInstalled) {
+                return {
+                    configPath: config.configPath,
+                    message: `Hook connector is not installed for ${agent}`,
+                    success: true,
+                    wasInstalled: false,
+                };
+            }
+            // Remove only our hooks (preserve others)
+            const filteredHooks = hooks.filter((entry) => !config.isOurHook(entry));
+            this.setHooksArray(json, config.hookEventKey, filteredHooks);
+            // Write back (even if array is empty - don't delete file)
+            await this.fileService.write(JSON.stringify(json, null, 2), fullPath, 'overwrite');
+            return {
+                configPath: config.configPath,
+                message: `Hook connector uninstalled for ${agent}`,
+                success: true,
+                wasInstalled: true,
+            };
+        }
+        catch (error) {
+            return {
+                configPath: config.configPath,
+                message: `Failed to uninstall hook connector for ${agent}: ${error instanceof Error ? error.message : String(error)}`,
+                success: false,
+                wasInstalled,
+            };
+        }
+    }
+    /**
+     * Get the hooks array from the config for a specific event key.
+     * Handles the nested structure: config.hooks[eventKey]
+     */
+    getHooksArray(config, eventKey) {
+        if (!isRecord(config.hooks)) {
+            return [];
+        }
+        const eventHooks = config.hooks[eventKey];
+        if (!Array.isArray(eventHooks)) {
+            return [];
+        }
+        return eventHooks;
+    }
+    /**
+     * Set the hooks array in the config for a specific event key.
+     * Creates the nested structure if it doesn't exist.
+     */
+    setHooksArray(config, eventKey, hooks) {
+        if (!isRecord(config.hooks)) {
+            config.hooks = { [eventKey]: hooks };
+            return;
+        }
+        config.hooks[eventKey] = hooks;
+    }
+}

package/dist/server/infra/connectors/mcp/json-mcp-config-writer.d.ts

@@ -0,0 +1,26 @@
+import type { IFileService } from '../../../core/interfaces/services/i-file-service.js';
+import type { IMcpConfigWriter, McpConfigExistsResult } from '../../../core/interfaces/storage/i-mcp-config-writer.js';
+import type { McpServerConfig } from './mcp-connector-config.js';
+/**
+ * Options for constructing JsonMcpConfigWriter.
+ */
+export type JsonMcpConfigWriterOptions = {
+    fileService: IFileService;
+    /**
+     * JSON key path to the MCP server entry, including server name.
+     * e.g., ['mcpServers', 'brv'] navigates to { mcpServers: { brv: ... } }
+     */
+    serverKeyPath: readonly string[];
+};
+/**
+ * MCP config writer for JSON format files.
+ * Handles nested key path navigation for reading/writing MCP server config.
+ */
+export declare class JsonMcpConfigWriter implements IMcpConfigWriter {
+    private readonly fileService;
+    private readonly serverKeyPath;
+    constructor(options: JsonMcpConfigWriterOptions);
+    exists(filePath: string): Promise<McpConfigExistsResult>;
+    remove(filePath: string): Promise<boolean>;
+    write(filePath: string, serverConfig: McpServerConfig): Promise<void>;
+}

package/dist/server/infra/connectors/mcp/mcp-connector.d.ts

@@ -0,0 +1,80 @@
+import type { Agent } from '../../../core/domain/entities/agent.js';
+import type { ConnectorType } from '../../../core/domain/entities/connector-type.js';
+import type { ConnectorInstallResult, ConnectorStatus, ConnectorUninstallResult } from '../../../core/interfaces/connectors/connector-types.js';
+import type { ConnectorOperationOptions, IConnector } from '../../../core/interfaces/connectors/i-connector.js';
+import type { IFileService } from '../../../core/interfaces/services/i-file-service.js';
+import type { IRuleTemplateService } from '../../../core/interfaces/services/i-rule-template-service.js';
+import type { McpSupportedAgent } from './mcp-connector-config.js';
+/**
+ * Options for constructing McpConnector.
+ */
+type McpConnectorOptions = {
+    fileService: IFileService;
+    projectRoot: string;
+    templateService: IRuleTemplateService;
+};
+/**
+ * Connector that integrates BRV with coding agents via MCP configuration.
+ * Manages MCP server entries in agent-specific configuration files.
+ * Also installs rule files with MCP-specific content.
+ *
+ * Key safety features:
+ * - Non-destructive: Preserves user's existing MCP servers and other config
+ * - No duplicates: Checks before adding new server entry
+ * - Safe uninstall: Only removes ByteRover's MCP server entry and rule content
+ */
+export declare class McpConnector implements IConnector {
+    readonly connectorType: ConnectorType;
+    private readonly fileService;
+    private readonly projectRoot;
+    private readonly ruleFileManager;
+    private readonly supportedAgents;
+    private readonly templateService;
+    constructor(options: McpConnectorOptions);
+    getConfigPath(agent: Agent): string;
+    getSupportedAgents(): Agent[];
+    install(agent: Agent): Promise<ConnectorInstallResult>;
+    isSupported(agent: Agent): agent is McpSupportedAgent;
+    status(agent: Agent, options?: ConnectorOperationOptions): Promise<ConnectorStatus>;
+    uninstall(agent: Agent, options?: ConnectorOperationOptions): Promise<ConnectorUninstallResult>;
+    /**
+     * Create the appropriate config writer for the given agent config.
+     */
+    private createWriter;
+    /**
+     * Format the config content for display based on format type.
+     */
+    private formatConfigContent;
+    /**
+     * Get the full (absolute) config path for file operations.
+     * - Project scope: relative to project root
+     * - Global scope: relative to os.homedir()
+     */
+    private getFullConfigPath;
+    /**
+     * Install connector automatically by writing to config file.
+     */
+    private installAutomatic;
+    /**
+     * Generate manual installation instructions for the user.
+     */
+    private installManual;
+    /**
+     * Install the rule file with MCP-specific content.
+     */
+    private installRuleFile;
+    /**
+     * Get status for auto mode by checking MCP config file.
+     */
+    private statusAutomatic;
+    /**
+     * Get status for manual mode by checking if rule file has MCP content.
+     * Checks for markers AND MCP-specific tool references (brv-query, brv-curate).
+     */
+    private statusManual;
+    /**
+     * Uninstall the rule file content.
+     */
+    private uninstallRuleFile;
+}
+export {};