vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/agents/discovery/AgentDiscoveryService.js

@@ -0,0 +1,707 @@
+/**
+ * Agent Discovery Service
+ * 
+ * Discovers and manages new agent CLI tools.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { spawn, exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Agent Discovery Service class
+ */
+class AgentDiscoveryService {
+  /**
+   * Create discovery service instance
+   * @param {Object} options - Service options
+   */
+  constructor(options = {}) {
+    this.configManager = options.configManager || null;
+    this.logger = options.logger || null;
+    this.fileManager = options.fileManager || null;
+    this.discoveryPaths = options.discoveryPaths || ['/usr/local/bin', '/opt/bin', '/usr/bin/local/bin', '/snap/bin'];
+    this.timeout = options.timeout || 30000;
+    this.maxConcurrency = options.maxConcurrency || 3;
+    this.discoveryHistoryFile = options.discoveryHistoryFile || './discovery-history.json';
+    this.discoveryStatusFile = options.discoveryStatusFile || './discovery-status.json';
+  }
+
+  /**
+   * Discover agents from configured paths
+   * @returns {Promise<Object>} - Discovery result
+   */
+  async discoverAgents() {
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting agent discovery', {
+          paths: this.discoveryPaths,
+          timeout: this.timeout
+        });
+      }
+
+      const discoveredAgents = [];
+      const warnings = [];
+      const errors = [];
+
+      // Discover agents from each path
+      const pathAgents = [];
+      
+      for (const discoveryPath of this.discoveryPaths) {
+        try {
+          const agents = await this.discoverFromPath(discoveryPath);
+          discoveredAgents.push(...agents);
+        } catch (error) {
+          const errorMsg = `Discovery failed for path ${discoveryPath}: ${error.message}`;
+          errors.push(errorMsg);
+          
+          if (this.logger) {
+            await this.logger.error(errorMsg);
+          }
+        }
+      }
+
+      // Validate and deduplicate discovered agents
+      const validAgents = await this.validateAndDeduplicateAgents(discoveredAgents);
+      const duplicateCount = discoveredAgents.length - validAgents.length;
+
+      if (duplicateCount > 0) {
+        warnings.push(`Removed ${duplicateCount} duplicate agents`);
+      }
+
+      // Update discovery status
+      await this.updateDiscoveryStatus(validAgents, discoveredAgents.length, duplicateCount, warnings, errors);
+
+      const duration = Date.now() - startTime;
+
+      if (this.logger) {
+        await this.logger.info('Agent discovery completed', {
+          totalDiscovered: discoveredAgents.length,
+          validAgents: validAgents.length,
+          duplicates: duplicateCount,
+          warnings: warnings.length,
+          errors: errors.length,
+          duration
+        });
+      }
+
+      await this.recordDiscoveryOperation('discover', {
+        totalDiscovered: discoveredAgents.length,
+        validAgents: validAgents.length,
+        duration
+      });
+
+      return {
+        success: errors.length === 0,
+        agents: validAgents,
+        discovered: discoveredAgents,
+        warnings,
+        errors,
+        duration,
+        timestamp: new Date().toISOString()
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      if (this.logger) {
+        await this.logger.error('Agent discovery failed', {
+          error: error.message,
+          duration
+        });
+      }
+
+      return {
+        success: false,
+        agents: [],
+        error: error.message,
+        duration,
+        timestamp: new Date().toISOString()
+      };
+    }
+  }
+
+  /**
+   * Discover agents from each path
+   * @param {string} discoveryPath - Path to search for agents
+   * @returns {Promise<Array>} - Discovered agents
+   */
+  async discoverFromPath(discoveryPath) {
+    try {
+      const stat = await fs.stat(discoveryPath);
+      
+      if (!stat.isDirectory()) {
+        if (this.logger) {
+          await this.logger.warn(`Discovery path is not a directory: ${discoveryPath}`);
+        }
+        return [];
+      }
+
+      const files = await fs.readdir(discoveryPath);
+      const agents = [];
+
+      for (const file of files) {
+        const filePath = path.join(discoveryPath, file);
+        
+        try {
+          const fileStat = await fs.stat(filePath);
+          const isDirectory = await fs.stat(filePath).then(stat => stat.isDirectory());
+          if (isDirectory) {
+            const subAgents = await this.discoverFromPath(filePath);
+            agents.push(...subAgents);
+          } else {
+            // Check if it's an executable file
+            if (fileStat.isFile() && fileStat.mode & parseInt('111', 8)) {
+              const agentInfo = await this.analyzeExecutable(filePath);
+            
+              if (agentInfo) {
+                agents.push(agentInfo);
+                
+                if (this.logger) {
+                  await this.logger.info(`Found potential agent: ${agentInfo.name} (${agentInfo.id})`, {
+                    path: filePath,
+                    type: agentInfo.type
+                  });
+                }
+              }
+            }
+          }
+        } catch (error) {
+          if (this.logger) {
+            await this.logger.warn(`Error analyzing file ${filePath}: ${error.message}`);
+          }
+        }
+      }
+
+      return agents;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error(`Failed to read discovery path ${discoveryPath}: ${error.message}`);
+      }
+      return [];
+    }
+  }
+
+  /**
+   * Analyze executable file for agent information
+   * @param {string} filePath - Path to executable file
+   * @returns {Promise<Object>} - Agent information or null
+   */
+  async analyzeExecutable(filePath) {
+    try {
+      // Get file info
+      const stat = await fs.stat(filePath);
+      const fileName = path.basename(filePath);
+      
+      // Try to get version information
+      let version = 'unknown';
+      let description = '';
+      
+      // Execute file with --help or --version flag
+      try {
+        const { stdout } = await execAsync(`"${filePath}" --version`, {
+          timeout: 5000
+        });
+        
+        // Parse version from output
+        const versionMatch = stdout.match(/(\d+\.\d+\.\d+)/);
+        if (versionMatch) {
+          version = versionMatch[1];
+        }
+        
+        // Try to get description from help output
+        const { stdout: helpOutput } = await execAsync(`"${filePath}" --help`, {
+          timeout: 5000
+        });
+        
+        // Extract description from help output (first line that looks like a description)
+        const helpLines = helpOutput.split('\n');
+        const descriptionLine = helpLines.find(line => 
+          line && !line.startsWith('Usage:') && 
+          !line.startsWith('Options:') &&
+          line.trim().length > 10
+        );
+        
+        if (descriptionLine) {
+          description = descriptionLine.trim();
+        }
+      } catch (versionError) {
+        // Version check failed, continue with unknown version
+      }
+
+      // Determine agent type based on file characteristics
+      let type = 'CLI';
+      if (fileName.includes('gui') || fileName.includes('window') || fileName.includes('app')) {
+        type = 'GUI';
+      }
+
+      // Generate unique ID based on filename
+      const id = this.generateAgentId(fileName, filePath);
+
+      // Determine capabilities based on help output
+      const capabilities = await this.determineCapabilities(filePath, helpOutput);
+
+      return {
+        id,
+        name: this.generateAgentName(fileName, description),
+        path: filePath,
+        version,
+        description,
+        type,
+        capabilities,
+        discovered: true,
+        discoveredAt: new Date().toISOString()
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.warn(`Error analyzing executable ${filePath}: ${error.message}`);
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Generate agent ID from filename and path
+   * @param {string} fileName - File name
+   * @param {string} filePath - File path
+   * @returns {string} - Generated agent ID
+   */
+  generateAgentId(fileName, filePath) {
+    // Use filename as base, make it lowercase and replace special chars
+    const baseId = fileName
+      .toLowerCase()
+      .replace(/[^a-z0-9]/g, '-')
+      .replace(/\.(exe|sh|bat|cmd)$/g, '');
+
+    // Add path hash for uniqueness
+    const pathHash = filePath
+      .split('/')
+      .slice(-2)
+      .join('-')
+      .substring(0, 8);
+
+    return `${baseId}-${pathHash}`;
+  }
+
+  /**
+   * Generate agent name from filename and description
+   * @param {string} fileName - File name
+   * @param {string} description - Description from help output
+   * @returns {string} - Generated agent name
+   */
+  generateAgentName(fileName, description) {
+    // Use description if available, otherwise generate from filename
+    if (description && description.trim()) {
+      return description.trim();
+    }
+
+    // Generate name from filename
+    const name = fileName
+      .replace(/\.(exe|sh|bat|cmd)$/g, '')
+      .replace(/-/g, ' ')
+      .split(' ')
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+
+    return name;
+  }
+
+  /**
+   * Determine agent capabilities from help output
+   * @param {string} filePath - Path to executable
+   * @param {string} helpOutput - Help output from executable
+   * @returns {Array} - Array of capabilities
+   */
+  async determineCapabilities(filePath, helpOutput) {
+    const capabilities = [];
+    const fileName = path.basename(filePath).toLowerCase();
+
+    // Common CLI capabilities
+    if (helpOutput.includes('--check') || helpOutput.includes('check ')) {
+      capabilities.push('check');
+    }
+    if (helpOutput.includes('--install') || helpOutput.includes('install ')) {
+      capabilities.push('install');
+    }
+    if (helpOutput.includes('--verify') || helpOutput.includes('verify ')) {
+      capabilities.push('verify');
+    }
+    if (helpOutput.includes('--logs') || helpOutput.includes('logs ')) {
+      capabilities.push('logs');
+    }
+    if (helpOutput.includes('--status') || helpOutput.includes('status ')) {
+      capabilities.push('status');
+    }
+    if (helpOutput.includes('--update') || helpOutput.includes('update ')) {
+      capabilities.push('update');
+    }
+
+    // GUI-specific capabilities
+    if (fileName.includes('gui') || fileName.includes('window')) {
+      capabilities.push('gui');
+    }
+    if (fileName.includes('app')) {
+      capabilities.push('app-interface');
+    }
+
+    // Add default capabilities based on file type
+    capabilities.push('help');
+
+    return capabilities;
+  }
+
+  /**
+   * Validate and deduplicate discovered agents
+   * @param {Array} agents - Discovered agents
+   * @returns {Array} - Valid, deduplicated agents
+   */
+  async validateAndDeduplicateAgents(agents) {
+    const validAgents = [];
+    const seenIds = new Set();
+    const seenPaths = new Set();
+
+    for (const agent of agents) {
+      // Validate required fields
+      if (!agent.id || !agent.name || !agent.path) {
+        if (this.logger) {
+          await this.logger.warn('Invalid agent configuration: missing required fields', {
+            agent: agent.id || 'unknown'
+          });
+        }
+        continue;
+      }
+
+      // Check for duplicates
+      if (seenIds.has(agent.id)) {
+        if (this.logger) {
+          await this.logger.warn('Duplicate agent ID found: ' + agent.id);
+        }
+        continue;
+      }
+
+      if (seenPaths.has(agent.path)) {
+        if (this.logger) {
+          await this.logger.warn('Duplicate agent path found: ' + agent.path);
+        }
+        continue;
+      }
+
+      // Additional validation
+      if (agent.version === 'unknown') {
+        if (this.logger) {
+          await this.logger.warn(`Agent ${agent.id} has unknown version`);
+        }
+      }
+
+      validAgents.push(agent);
+      seenIds.add(agent.id);
+      seenPaths.add(agent.path);
+    }
+
+    return validAgents;
+  }
+
+  /**
+   * Add discovered agent to configuration
+   * @param {Object} agent - Agent to add
+   * @returns {Promise<Object>} - Addition result
+   */
+  async addAgent(agent) {
+    try {
+      if (this.logger) {
+        await this.logger.info('Adding discovered agent to configuration', {
+          agentId: agent.id,
+          agentName: agent.name,
+          path: agent.path
+        });
+      }
+
+      // Validate agent before adding
+      const validation = this.validateAgent(agent);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: 'Invalid agent configuration: ' + validation.errors.join(', '),
+          agentId: agent.id
+        };
+      }
+
+      // Add to configuration manager
+      if (this.configManager) {
+        await this.configManager.addAgent(agent);
+      }
+
+      // Record addition in history
+      await this.recordDiscoveryOperation('add', {
+        agentId: agent.id,
+        agentName: agent.name
+      });
+
+      return {
+        success: true,
+        agentId: agent.id,
+        message: `Agent ${agent.name} added successfully`
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to add agent', {
+          agentId: agent.id,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        agentId: agent.id
+      };
+    }
+  }
+
+  /**
+   * Remove agent from configuration
+   * @param {string} agentId - ID of agent to remove
+   * @returns {Promise<Object>} - Removal result
+   */
+  async removeAgent(agentId) {
+    try {
+      if (this.logger) {
+        await this.logger.info('Removing agent from configuration', {
+          agentId
+        });
+      }
+
+      // Get agent info before removal
+      let agentInfo = null;
+      if (this.configManager) {
+        agentInfo = await this.configManager.getAgent(agentId);
+      }
+
+      if (!agentInfo) {
+        return {
+          success: false,
+          error: 'Agent not found',
+          agentId
+        };
+      }
+
+      // Remove from configuration manager
+      if (this.configManager) {
+        await this.configManager.removeAgent(agentId);
+      }
+
+      // Record removal in history
+      await this.recordDiscoveryOperation('remove', {
+        agentId,
+        agentName: agentInfo.name
+      });
+
+      return {
+        success: true,
+        agentId,
+        message: `Agent ${agentInfo.name} removed successfully`
+      };
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Failed to remove agent', {
+          agentId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        agentId
+      };
+    }
+  }
+
+  /**
+   * Validate agent configuration
+   * @param {Object} agent - Agent to validate
+   * @returns {Object} - Validation result
+   */
+  validateAgent(agent) {
+    const errors = [];
+
+    // Check required fields
+    if (!agent.id || !agent.id.trim()) {
+      errors.push('Agent ID is required');
+    }
+
+    if (!agent.name || !agent.name.trim()) {
+      errors.push('Agent name is required');
+    }
+
+    if (!agent.path || !agent.path.trim()) {
+      errors.push('Agent path is required');
+    }
+
+    if (!agent.version || !agent.version.trim()) {
+      errors.push('Agent version is required');
+    }
+
+    if (!agent.description || !agent.description.trim()) {
+      errors.push('Agent description is required');
+    }
+
+    if (!agent.type || !['CLI', 'GUI'].includes(agent.type)) {
+      errors.push('Agent type must be CLI or GUI');
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Update discovery status file
+   * @param {Array} validAgents - Valid discovered agents
+   * @param {number} totalDiscovered - Total agents discovered
+   * @param {number} duplicateCount - Number of duplicates removed
+   * @param {Array} warnings - Discovery warnings
+   * @param {Array} errors - Discovery errors
+   */
+  async updateDiscoveryStatus(validAgents, totalDiscovered, duplicateCount, warnings, errors) {
+    const status = {
+      lastDiscovery: new Date().toISOString(),
+      totalDiscovered,
+      validAgents,
+      duplicates: duplicateCount,
+      warnings,
+      errors,
+      discoveryPaths: this.discoveryPaths
+    };
+
+    if (this.fileManager) {
+      await this.fileManager.writeFile('discovery-status', JSON.stringify(status, null, 2));
+    }
+
+    if (this.logger) {
+      await this.logger.info('Discovery status updated', {
+        totalDiscovered,
+        validAgents,
+        duplicates: duplicateCount
+      });
+    }
+  }
+
+  /**
+   * Record discovery operation in history
+   * @param {string} operation - Operation type
+   * @param {Object} details - Operation details
+   */
+  async recordDiscoveryOperation(operation, details) {
+    const historyEntry = {
+      timestamp: new Date().toISOString(),
+      operation,
+      ...details
+    };
+
+    let history = [];
+    if (this.fileManager) {
+      try {
+        const historyData = await this.fileManager.readFile('discovery-history');
+        history = JSON.parse(historyData || '[]');
+      } catch (error) {
+        // File doesn't exist yet, start with empty history
+      }
+    }
+
+    history.push(historyEntry);
+
+    // Keep only last 100 entries
+    if (history.length > 100) {
+      history = history.slice(-100);
+    }
+
+    if (this.fileManager) {
+      await this.fileManager.writeFile('discovery-history', JSON.stringify(history, null, 2));
+    }
+
+    if (this.logger) {
+      await this.logger.info('Discovery operation recorded', {
+        operation,
+        details
+      });
+    }
+  }
+
+  /**
+   * Get discovery status
+   * @returns {Promise<Object>} - Discovery status
+   */
+  async getDiscoveryStatus() {
+    try {
+      if (this.fileManager) {
+        const statusData = await this.fileManager.readFile('discovery-status');
+        return {
+          success: true,
+          status: JSON.parse(statusData || '{}')
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Discovery status file not found'
+      };
+    }
+  }
+
+  /**
+   * Get discovery history
+   * @returns {Promise<Object>} - Discovery history
+   */
+  async getDiscoveryHistory() {
+    try {
+      if (this.fileManager) {
+        const historyData = await this.fileManager.readFile('discovery-history');
+        return {
+          success: true,
+          history: JSON.parse(historyData || '[]')
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: 'Discovery history file not found'
+      };
+    }
+  }
+
+  /**
+   * Get service information
+   * @returns {Object} - Service info
+   */
+  getInfo() {
+    return {
+      name: 'Agent Discovery Service',
+      version: '1.0.0',
+      discoveryPaths: this.discoveryPaths,
+      timeout: this.timeout,
+      maxConcurrency: this.maxConcurrency,
+      features: [
+        'filesystem discovery',
+        'executable analysis',
+        'version detection',
+        'capability detection',
+        'agent validation',
+        'deduplication',
+        'configuration integration',
+        'discovery history',
+        'status tracking',
+        'error handling',
+        'concurrent discovery'
+      ]
+    };
+  }
+}
+
+module.exports = AgentDiscoveryService;