byterover-cli 1.0.5 → 1.2.0

package/dist/infra/usecase/connectors-use-case.js

@@ -0,0 +1,222 @@
+import { AGENT_VALUES } from '../../core/domain/entities/agent.js';
+/** Sentinel value for "Connect a new agent" option */
+const CONNECT_NEW_AGENT = '__connect_new__';
+/**
+ * Array of all agents with name and value properties.
+ * Useful for UI components like select dropdowns.
+ */
+const AGENTS = AGENT_VALUES.map((agent) => ({
+    name: agent,
+    value: agent,
+}));
+/**
+ * Use case for managing connectors.
+ * Shows list of connected agents and allows managing or adding new connections.
+ */
+export class ConnectorsUseCase {
+    connectorManager;
+    terminal;
+    trackingService;
+    constructor(options) {
+        this.connectorManager = options.connectorManager;
+        this.terminal = options.terminal;
+        this.trackingService = options.trackingService;
+    }
+    async run() {
+        await this.trackingService.track('connectors:configure');
+        // Step 1: Get all installed connectors
+        const installedConnectors = await this.connectorManager.getAllInstalledConnectors();
+        // Step 2: Show list or prompt for new agent
+        const selectedAgent = installedConnectors.size === 0
+            ? await this.handleNoConnectorsInstalled()
+            : await this.handleExistingConnectors(installedConnectors);
+        // Step 3: Get current status and supported types for selected agent
+        const currentType = await this.connectorManager.getInstalledConnectorType(selectedAgent);
+        const supportedTypes = this.connectorManager.getSupportedConnectorTypes(selectedAgent);
+        // Step 4: Select connector type
+        const selectedType = await this.promptForConnectorType(selectedAgent, supportedTypes, currentType);
+        // Step 5: Handle switching with confirmation if needed
+        if (currentType && currentType !== selectedType) {
+            const shouldSwitch = await this.promptForSwitchConfirmation(selectedAgent, currentType, selectedType);
+            if (!shouldSwitch) {
+                this.terminal.log(`Kept ${selectedAgent} connected via ${currentType}`);
+                return;
+            }
+        }
+        // Step 6: Install the selected connector
+        await this.installConnector(selectedAgent, selectedType);
+    }
+    /**
+     * Display manual setup instructions for MCP configuration.
+     */
+    displayManualInstructions(agent, instructions) {
+        this.terminal.log(`\nManual setup required for ${agent}`);
+        this.terminal.log('');
+        this.terminal.log('Add this configuration to your MCP settings:');
+        this.terminal.log('');
+        this.terminal.log(instructions.configContent);
+        this.terminal.log('');
+        if (instructions.guide) {
+            this.terminal.log(`\nFor detailed instructions, see: ${instructions.guide}`);
+        }
+    }
+    /**
+     * Gets a description for a connector type.
+     */
+    getConnectorDescription(type, configPath) {
+        switch (type) {
+            case 'hook': {
+                return `Instructions injected on each prompt (${configPath})`;
+            }
+            case 'mcp': {
+                return `Agent connects via MCP protocol ${configPath ? `(${configPath})` : ''}`;
+            }
+            case 'rules': {
+                return `Agent reads instructions from rule file (${configPath})`;
+            }
+        }
+    }
+    /**
+     * Gets a human-readable label for a connector type.
+     */
+    getConnectorLabel(type) {
+        switch (type) {
+            case 'hook': {
+                return 'Hook';
+            }
+            case 'mcp': {
+                return 'MCP';
+            }
+            case 'rules': {
+                return 'Rules';
+            }
+        }
+    }
+    /**
+     * Handles the case when connectors are already installed.
+     */
+    async handleExistingConnectors(installedConnectors) {
+        const selection = await this.promptForAgentToManage(installedConnectors);
+        if (selection === CONNECT_NEW_AGENT) {
+            return this.promptForNewAgentSelection(installedConnectors);
+        }
+        return selection;
+    }
+    /**
+     * Handles the case when no connectors are installed.
+     */
+    async handleNoConnectorsInstalled() {
+        this.terminal.log('No agents connected yet.\n');
+        return this.promptForNewAgentSelection();
+    }
+    /**
+     * Installs the selected connector and displays result.
+     */
+    async installConnector(agent, connectorType) {
+        const result = await this.connectorManager.switchConnector(agent, connectorType);
+        if (result.success) {
+            // Handle manual setup instructions
+            if (result.installResult.requiresManualSetup && result.installResult.manualInstructions) {
+                this.displayManualInstructions(agent, result.installResult.manualInstructions);
+                return;
+            }
+            if (result.fromType && result.fromType !== result.toType) {
+                this.terminal.log(`${agent} switched from ${this.getConnectorLabel(result.fromType)} to ${this.getConnectorLabel(result.toType)}`);
+                if (result.uninstallResult?.wasInstalled) {
+                    this.terminal.log(`   Uninstalled: ${result.uninstallResult.configPath}`);
+                }
+                this.terminal.log(`   Installed: ${result.installResult.configPath}`);
+            }
+            else if (result.installResult.alreadyInstalled) {
+                this.terminal.log(`${agent} is already connected via ${result.toType}`);
+                this.terminal.log(`   Config: ${result.installResult.configPath}`);
+            }
+            else {
+                this.terminal.log(`${agent} connected via ${result.toType}`);
+                this.terminal.log(`   Installed: ${result.installResult.configPath}`);
+            }
+            // Show restart message for hook connector
+            if ((result.toType === 'hook' || result.toType === 'mcp') && !result.installResult.alreadyInstalled) {
+                this.terminal.warn(`\nPlease restart ${agent} to apply the new ${result.toType}.`);
+            }
+        }
+        else {
+            this.terminal.error(`Failed to configure ${agent}: ${result.message}`);
+        }
+    }
+    /**
+     * Prompts user to select from connected agents or add new.
+     */
+    async promptForAgentToManage(installedConnectors) {
+        const choices = [];
+        // Add installed agents as choices
+        for (const [agent, connectorType] of installedConnectors) {
+            const connector = this.connectorManager.getConnector(connectorType);
+            const configPath = connector.getConfigPath(agent);
+            choices.push({
+                description: configPath,
+                name: `${agent} (${this.getConnectorLabel(connectorType)})`,
+                value: agent,
+            });
+        }
+        // Add separator and "Connect new" option
+        choices.push({
+            name: '+ Connect a new agent',
+            value: CONNECT_NEW_AGENT,
+        });
+        return this.terminal.select({
+            choices,
+            message: 'Manage agent connectors:',
+        });
+    }
+    /**
+     * Prompts the user to select a connector type.
+     */
+    async promptForConnectorType(agent, supportedTypes, currentType) {
+        const choices = supportedTypes.map((type) => {
+            const connector = this.connectorManager.getConnector(type);
+            const configPath = connector.getConfigPath(agent);
+            const isCurrent = type === currentType;
+            const label = this.getConnectorLabel(type);
+            const description = this.getConnectorDescription(type, configPath);
+            return {
+                description,
+                name: isCurrent ? `${label} (current)` : label,
+                value: type,
+            };
+        });
+        return this.terminal.select({
+            choices,
+            message: 'Select connector type:',
+        });
+    }
+    /**
+     * Prompts user to select a new agent (excludes already connected agents).
+     */
+    async promptForNewAgentSelection(installedConnectors) {
+        const connectedAgents = installedConnectors ? new Set(installedConnectors.keys()) : new Set();
+        // Filter out already connected agents
+        const availableAgents = AGENTS.filter((agent) => !connectedAgents.has(agent.value));
+        return this.terminal.search({
+            message: 'Which agent are you using (type to search):',
+            source(input) {
+                if (!input)
+                    return availableAgents;
+                return availableAgents.filter((agent) => agent.name.toLowerCase().includes(input.toLowerCase()) ||
+                    agent.value.toLowerCase().includes(input.toLowerCase()));
+            },
+        });
+    }
+    /**
+     * Prompts the user to confirm switching connectors.
+     */
+    async promptForSwitchConfirmation(agent, fromType, toType) {
+        const fromConnector = this.connectorManager.getConnector(fromType);
+        const fromPath = fromConnector.getConfigPath(agent);
+        this.terminal.warn(`${agent} is currently connected via ${this.getConnectorLabel(fromType)} ${fromPath ? `(${fromPath})` : ''}`);
+        return this.terminal.confirm({
+            default: true,
+            message: `Switch to ${toType}? This will uninstall the current connector.`,
+        });
+    }
+}

package/dist/infra/usecase/init-use-case.d.ts

@@ -1,14 +1,13 @@
 import type { AuthToken } from '../../core/domain/entities/auth-token.js';
 import type { Space } from '../../core/domain/entities/space.js';
 import type { Team } from '../../core/domain/entities/team.js';
+import type { IConnectorManager } from '../../core/interfaces/connectors/i-connector-manager.js';
 import type { ICogitPullService } from '../../core/interfaces/i-cogit-pull-service.js';
 import type { IContextTreeService } from '../../core/interfaces/i-context-tree-service.js';
 import type { IContextTreeSnapshotService } from '../../core/interfaces/i-context-tree-snapshot-service.js';
 import type { IContextTreeWriterService } from '../../core/interfaces/i-context-tree-writer-service.js';
 import type { IFileService } from '../../core/interfaces/i-file-service.js';
-import type { ILegacyRuleDetector } from '../../core/interfaces/i-legacy-rule-detector.js';
 import type { IProjectConfigStore } from '../../core/interfaces/i-project-config-store.js';
-import type { IRuleTemplateService } from '../../core/interfaces/i-rule-template-service.js';
 import type { ISpaceService } from '../../core/interfaces/i-space-service.js';
 import type { ITeamService } from '../../core/interfaces/i-team-service.js';
 import type { ITerminal } from '../../core/interfaces/i-terminal.js';
@@ -17,7 +16,6 @@ import type { ITrackingService } from '../../core/interfaces/i-tracking-service.
 import type { IInitUseCase } from '../../core/interfaces/usecase/i-init-use-case.js';
 import { type Agent } from '../../core/domain/entities/agent.js';
 import { BrvConfig } from '../../core/domain/entities/brv-config.js';
-type CleanupStrategy = 'automatic' | 'manual';
 /**
  * Represents a legacy config that exists but has version issues.
  * Used to display config info during re-initialization prompt.
@@ -33,30 +31,28 @@ export type LegacyProjectConfigInfo = {
 };
 export interface InitUseCaseOptions {
     cogitPullService: ICogitPullService;
+    connectorManager: IConnectorManager;
     contextTreeService: IContextTreeService;
     contextTreeSnapshotService: IContextTreeSnapshotService;
     contextTreeWriterService: IContextTreeWriterService;
     fileService: IFileService;
-    legacyRuleDetector: ILegacyRuleDetector;
     projectConfigStore: IProjectConfigStore;
     spaceService: ISpaceService;
     teamService: ITeamService;
-    templateService: IRuleTemplateService;
     terminal: ITerminal;
     tokenStore: ITokenStore;
     trackingService: ITrackingService;
 }
 export declare class InitUseCase implements IInitUseCase {
     protected readonly cogitPullService: ICogitPullService;
+    protected readonly connectorManager: IConnectorManager;
     protected readonly contextTreeService: IContextTreeService;
     protected readonly contextTreeSnapshotService: IContextTreeSnapshotService;
     protected readonly contextTreeWriterService: IContextTreeWriterService;
     protected readonly fileService: IFileService;
-    protected readonly legacyRuleDetector: ILegacyRuleDetector;
     protected readonly projectConfigStore: IProjectConfigStore;
     protected readonly spaceService: ISpaceService;
     protected readonly teamService: ITeamService;
-    protected readonly templateService: IRuleTemplateService;
     protected readonly terminal: ITerminal;
     protected readonly tokenStore: ITokenStore;
     protected readonly trackingService: ITrackingService;
@@ -71,9 +67,13 @@ export declare class InitUseCase implements IInitUseCase {
     protected ensureAuthenticated(): Promise<AuthToken | undefined>;
     protected fetchAndSelectSpace(token: AuthToken, team: Team): Promise<Space | undefined>;
     protected fetchAndSelectTeam(token: AuthToken): Promise<Team | undefined>;
-    protected generateRulesForAgent(selectedAgent: Agent): Promise<void>;
     protected getExistingConfig(): Promise<BrvConfig | LegacyProjectConfigInfo | undefined>;
     protected initializeMemoryContextDir(name: string, initFn: () => Promise<string>): Promise<void>;
+    /**
+     * Installs the default connector for the selected agent.
+     * Uses ConnectorManager to handle the installation.
+     */
+    protected installConnectorForAgent(selectedAgent: Agent): Promise<void>;
     protected isLegacyProjectConfig(config: BrvConfig | LegacyProjectConfigInfo): config is LegacyProjectConfigInfo;
     /**
      * Checks if the given path represents a README.md placeholder file.
@@ -87,25 +87,6 @@ export declare class InitUseCase implements IInitUseCase {
      * @returns The selected agent
      */
     protected promptForAgentSelection(): Promise<Agent>;
-    /**
-     * Prompts the user to choose cleanup strategy for legacy rules.
-     * This method is protected to allow test overrides.
-     * @returns The chosen cleanup strategy
-     */
-    protected promptForCleanupStrategy(): Promise<CleanupStrategy>;
-    /**
-     * Prompts the user to create a new rule file.
-     * This method is protected to allow test overrides.
-     * @param agent The agent for which the rule file doesn't exist
-     * @param filePath The path where the file would be created
-     * @returns True if the user wants to create the file, false otherwise
-     */
-    protected promptForFileCreation(agent: Agent, filePath: string): Promise<boolean>;
-    /**
-     * Prompts the user to confirm overwriting an existing rule file.
-     * This method is protected to allow test overrides.
-     */
-    protected promptForOverwriteConfirmation(agent: Agent): Promise<boolean>;
     protected promptForSpaceSelection(spaces: Space[]): Promise<Space | undefined>;
     protected promptForTeamSelection(teams: Team[]): Promise<Team | undefined>;
     protected removeAceDirectory(baseDir?: string): Promise<void>;
@@ -119,21 +100,5 @@ export declare class InitUseCase implements IInitUseCase {
         };
         token: AuthToken;
     }): Promise<void>;
-    /**
-     * Appends ByteRover rules to a file that has no ByteRover content.
-     */
-    private appendRulesToFile;
-    /**
-     * Creates a new rule file with ByteRover rules.
-     */
-    private createNewRuleFile;
-    private handleLegacyRulesCleanup;
     private logSuccess;
-    private performAutomaticCleanup;
-    private performManualCleanup;
-    /**
-     * Replaces existing ByteRover rules (with boundary markers) with new rules.
-     */
-    private replaceExistingRules;
 }
-export {};