@vibe-dev-kit/cli/src/integrations/integration-manager.js

Advanced Command-line toolkit that analyzes your codebase and deploys project-aware rules, memories, commands and agents to any AI coding assistant - VDK is the world's first Vibe Development Kit

/**
 * Integration Manager
 * ------------------
 * Central manager for all VDK integrations (IDEs, AI tools, platforms)
 * Handles discovery, registration, and coordination of integrations.
 */

import chalk from 'chalk';

import { BaseIntegration } from './base-integration.js';

/**
 * Central manager for all VDK integrations
 */
export class IntegrationManager {
  constructor(projectPath = process.cwd()) {
    this.projectPath = projectPath;
    this.integrations = new Map();
    this.detectionResults = new Map();
    this.lastScan = null;
  }

  /**
   * Register an integration
   * @param {BaseIntegration} integration - Integration instance
   */
  register(integration) {
    if (!(integration instanceof BaseIntegration)) {
      throw new Error('Integration must extend BaseIntegration');
    }

    this.integrations.set(integration.name, integration);
  }

  /**
   * Register multiple integrations
   * @param {Array<BaseIntegration>} integrations - Array of integration instances
   */
  registerMultiple(integrations) {
    integrations.forEach((integration) => this.register(integration));
  }

  /**
   * Discover and register all available integrations
   * @param {Object} options - Discovery options
   * @returns {Object} Discovery results
   */
  async discoverIntegrations(options = {}) {
    const { verbose = false } = options;

    // Dynamically import and register all integrations
    const integrationModules = [
      './claude-code-integration.js',
      './cursor-integration.js',
      './windsurf-integration.js',
      './github-copilot-integration.js',
      './generic-ide-integration.js',
    ];

    const results = {
      loaded: [],
      failed: [],
      registered: 0,
    };

    for (const modulePath of integrationModules) {
      try {
        const module = await import(modulePath);
        let foundIntegration = false;

        // Look for integration class exports
        for (const [exportName, exportValue] of Object.entries(module)) {
          if (
            exportName.includes('Integration') &&
            typeof exportValue === 'function' &&
            exportValue.prototype instanceof BaseIntegration
          ) {
            try {
              const integration = new exportValue(this.projectPath);
              this.register(integration);
              results.loaded.push({
                module: modulePath,
                class: exportName,
                name: integration.name,
              });
              results.registered++;
              foundIntegration = true;
            } catch (constructorError) {
              results.failed.push({
                module: modulePath,
                class: exportName,
                error: `Constructor failed: ${constructorError.message}`,
              });
            }
          }
        }

        if (!foundIntegration) {
          results.failed.push({
            module: modulePath,
            error: 'No valid Integration class found in module',
          });
        }
      } catch (error) {
        // Integration module doesn't exist or failed to load - that's OK
        // We only register integrations that are available
        results.failed.push({
          module: modulePath,
          error: error.message,
        });

        if (process.env.VDK_DEBUG || verbose) {
          console.warn(
            chalk.yellow(`Failed to load integration module ${modulePath}: ${error.message}`)
          );
        }
      }
    }

    if (verbose) {
      console.log(chalk.blue(`Discovery complete: ${results.registered} integrations registered`));
      if (results.failed.length > 0 && process.env.VDK_DEBUG) {
        console.log(chalk.gray(`Failed modules: ${results.failed.length}`));
      }
    }

    return results;
  }

  /**
   * Scan all registered integrations for usage
   * @param {Object} options - Scan options
   * @returns {Object} Scan results
   */
  async scanAll(options = {}) {
    const { verbose = false, force = false } = options;

    if (verbose) {
      console.log(chalk.blue('🔍 Scanning for integration usage...'));
    }

    const results = {
      active: [],
      inactive: [],
      recommendations: [],
      errors: [],
      summary: {},
    };

    // Ensure we have integrations to scan
    if (this.integrations.size === 0) {
      if (verbose) {
        console.log(
          chalk.yellow('⚠️ No integrations registered. Run discoverIntegrations() first.')
        );
      }
      results.errors.push('No integrations registered');
      return results;
    }

    for (const [name, integration] of this.integrations) {
      try {
        // Validate integration instance
        if (!integration || typeof integration.getCachedDetection !== 'function') {
          throw new Error(`Invalid integration instance for ${name}`);
        }

        const detection = integration.getCachedDetection(force);
        this.detectionResults.set(name, detection);

        const integrationResult = {
          name,
          isActive: integration.isActive(),
          confidence: integration.getConfidence(),
          indicators: integration.getIndicators(),
          recommendations: integration.getRecommendations(),
          detection,
        };

        if (integrationResult.isActive) {
          results.active.push(integrationResult);
        } else {
          results.inactive.push(integrationResult);
        }

        // Collect all recommendations
        results.recommendations.push(...integrationResult.recommendations);

        if (verbose && integrationResult.indicators.length > 0) {
          console.log(chalk.gray(`  • ${name}: ${integrationResult.confidence} confidence`));
          integrationResult.indicators.forEach((indicator) => {
            console.log(chalk.gray(`    - ${indicator}`));
          });
        }
      } catch (error) {
        const errorInfo = {
          integration: name,
          error: error.message,
          timestamp: new Date().toISOString(),
        };
        results.errors.push(errorInfo);

        if (verbose) {
          console.log(chalk.red(`❌ Failed to scan ${name}: ${error.message}`));
          if (process.env.VDK_DEBUG) {
            console.log(chalk.gray(`Debug: ${error.stack}`));
          }
        }

        // Add to inactive with error indicator
        results.inactive.push({
          name,
          isActive: false,
          confidence: 'error',
          indicators: [`Scan failed: ${error.message}`],
          recommendations: [`Fix ${name} integration configuration`],
          detection: { isUsed: false, confidence: 'error', indicators: [], recommendations: [] },
        });
      }
    }

    // Generate summary
    results.summary = {
      totalIntegrations: this.integrations.size,
      activeIntegrations: results.active.length,
      highConfidenceIntegrations: results.active.filter((r) => r.confidence === 'high').length,
      recommendationCount: results.recommendations.length,
      scanTime: new Date().toISOString(),
    };

    this.lastScan = results;
    return results;
  }

  /**
   * Get integration by name
   * @param {string} name - Integration name
   * @returns {BaseIntegration|null} Integration instance or null
   */
  getIntegration(name) {
    return this.integrations.get(name) || null;
  }

  /**
   * Get all registered integration names
   * @returns {Array<string>} Array of integration names
   */
  getIntegrationNames() {
    return Array.from(this.integrations.keys());
  }

  /**
   * Get all registered integrations
   * @returns {Array<BaseIntegration>} Array of integration instances
   */
  getAllIntegrations() {
    return Array.from(this.integrations.values());
  }

  /**
   * Get active integrations (high confidence)
   * @returns {Array<Object>} Array of active integration results
   */
  getActiveIntegrations() {
    if (!this.lastScan) {
      return [];
    }
    return this.lastScan.active.filter((integration) => integration.confidence === 'high');
  }

  /**
   * Get recommendations for all integrations
   * @returns {Array<string>} Array of recommendations
   */
  getAllRecommendations() {
    if (!this.lastScan) {
      return [];
    }
    return this.lastScan.recommendations;
  }

  /**
   * Initialize active integrations with VDK configuration
   * @param {Object} options - Initialization options
   * @returns {Object} Initialization results
   */
  async initializeActive(options = {}) {
    const { verbose = false } = options;
    const results = {
      successful: [],
      failed: [],
      skipped: [],
    };

    const activeIntegrations = this.getActiveIntegrations();

    if (activeIntegrations.length === 0) {
      if (verbose) {
        console.log(chalk.yellow('No active integrations found to initialize'));
      }
      return results;
    }

    for (const integrationResult of activeIntegrations) {
      const integration = this.getIntegration(integrationResult.name);

      if (!integration) {
        results.failed.push({
          name: integrationResult.name,
          error: 'Integration not found',
        });
        continue;
      }

      try {
        if (verbose) {
          console.log(chalk.blue(`Initializing ${integration.name} integration...`));
        }

        const success = await integration.initialize({
          ...options,
          projectPath: this.projectPath,
        });

        if (success) {
          results.successful.push({
            name: integration.name,
            confidence: integration.getConfidence(),
          });

          if (verbose) {
            console.log(chalk.green(`✅ ${integration.name} initialized successfully`));
          }
        } else {
          results.failed.push({
            name: integration.name,
            error: 'Initialization returned false',
          });
        }
      } catch (error) {
        results.failed.push({
          name: integration.name,
          error: error.message,
        });

        if (verbose) {
          console.log(chalk.red(`❌ Failed to initialize ${integration.name}: ${error.message}`));
        }
      }
    }

    return results;
  }

  /**
   * Get integration status summary for display
   * @returns {Object} Status summary
   */
  getStatusSummary() {
    if (!this.lastScan) {
      return {
        message: 'No integrations scanned yet',
        integrations: [],
      };
    }

    const { summary, active, inactive } = this.lastScan;

    let message = '';
    if (summary.activeIntegrations === 0) {
      message = 'No active integrations detected';
    } else if (summary.highConfidenceIntegrations > 0) {
      message = `${summary.highConfidenceIntegrations} high-confidence integration(s) detected`;
    } else {
      message = `${summary.activeIntegrations} integration(s) detected with varying confidence`;
    }

    return {
      message,
      summary,
      active: active.map((i) => ({
        name: i.name,
        confidence: i.confidence,
        indicatorCount: i.indicators.length,
      })),
      inactive: inactive.map((i) => ({
        name: i.name,
        confidence: i.confidence,
      })),
    };
  }

  /**
   * Clear all cached detection results
   */
  clearCache() {
    for (const integration of this.integrations.values()) {
      integration._detectionCache = null;
      integration._detectionCacheTime = null;
    }
    this.detectionResults.clear();
    this.lastScan = null;
  }

  /**
   * Get integration-specific recommendations
   * @param {string} integrationName - Name of integration
   * @returns {Array<string>} Array of recommendations for this integration
   */
  getIntegrationRecommendations(integrationName) {
    const integration = this.getIntegration(integrationName);
    if (!integration) {
      return [];
    }
    return integration.getRecommendations();
  }

  /**
   * Check if a specific integration is active
   * @param {string} integrationName - Name of integration
   * @returns {boolean} True if integration is active
   */
  isIntegrationActive(integrationName) {
    const integration = this.getIntegration(integrationName);
    if (!integration) {
      return false;
    }
    return integration.isActive();
  }

  /**
   * Get detailed integration information
   * @param {string} integrationName - Name of integration
   * @returns {Object|null} Detailed integration info or null
   */
  getIntegrationDetails(integrationName) {
    const integration = this.getIntegration(integrationName);
    if (!integration) {
      return null;
    }

    const detection = integration.getCachedDetection();
    return {
      name: integration.name,
      isActive: integration.isActive(),
      confidence: integration.getConfidence(),
      indicators: integration.getIndicators(),
      recommendations: integration.getRecommendations(),
      configPaths: integration.getConfigPaths(),
      summary: integration.getSummary(),
      detection,
    };
  }
}