vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/discovery/AgentDiscoveryService.js

@@ -7,10 +7,16 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const { spawn, exec } = require('child_process');
-const { promisify } = require('util');
+const { spawn } = require('child_process');
 
-const execAsync = promisify(exec);
+const { analyzeExecutable } = require('./executable-analyzer');
+const { validateAndDeduplicateAgents, validateAgent } = require('./agent-validator');
+const { 
+  recordDiscoveryOperation, 
+  updateDiscoveryStatus, 
+  getDiscoveryStatus, 
+  getDiscoveryHistory 
+} = require('./history-manager');
 
 /**
  * Agent Discovery Service class
@@ -51,8 +57,6 @@ class AgentDiscoveryService {
       const errors = [];
 
       // Discover agents from each path
-      const pathAgents = [];
-      
       for (const discoveryPath of this.discoveryPaths) {
         try {
           const agents = await this.discoverFromPath(discoveryPath);
@@ -68,7 +72,7 @@ class AgentDiscoveryService {
       }
 
       // Validate and deduplicate discovered agents
-      const validAgents = await this.validateAndDeduplicateAgents(discoveredAgents);
+      const validAgents = await validateAndDeduplicateAgents(discoveredAgents, this.logger);
       const duplicateCount = discoveredAgents.length - validAgents.length;
 
       if (duplicateCount > 0) {
@@ -76,7 +80,7 @@ class AgentDiscoveryService {
       }
 
       // Update discovery status
-      await this.updateDiscoveryStatus(validAgents, discoveredAgents.length, duplicateCount, warnings, errors);
+      await updateDiscoveryStatus(validAgents, discoveredAgents.length, duplicateCount, warnings, errors, this.fileManager, this.logger);
 
       const duration = Date.now() - startTime;
 
@@ -91,11 +95,11 @@ class AgentDiscoveryService {
         });
       }
 
-      await this.recordDiscoveryOperation('discover', {
+      await recordDiscoveryOperation('discover', {
         totalDiscovered: discoveredAgents.length,
         validAgents: validAgents.length,
         duration
-      });
+      }, this.fileManager, this.logger);
 
       return {
         success: errors.length === 0,
@@ -150,14 +154,15 @@ class AgentDiscoveryService {
         
         try {
           const fileStat = await fs.stat(filePath);
-          const isDirectory = await fs.stat(filePath).then(stat => stat.isDirectory());
+          const isDirectory = fileStat.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);
+              const agentInfo = await analyzeExecutable(filePath, this.logger);
             
               if (agentInfo) {
                 agents.push(agentInfo);
@@ -187,225 +192,6 @@ class AgentDiscoveryService {
     }
   }
 
-  /**
-   * 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
@@ -422,7 +208,7 @@ class AgentDiscoveryService {
       }
 
       // Validate agent before adding
-      const validation = this.validateAgent(agent);
+      const validation = validateAgent(agent);
       if (!validation.valid) {
         return {
           success: false,
@@ -437,10 +223,10 @@ class AgentDiscoveryService {
       }
 
       // Record addition in history
-      await this.recordDiscoveryOperation('add', {
+      await recordDiscoveryOperation('add', {
         agentId: agent.id,
         agentName: agent.name
-      });
+      }, this.fileManager, this.logger);
 
       return {
         success: true,
@@ -465,7 +251,7 @@ class AgentDiscoveryService {
 
   /**
    * Remove agent from configuration
-   * @param {string} agentId - ID of agent to remove
+   * @param {string} agentId - Agent ID to remove
    * @returns {Promise<Object>} - Removal result
    */
   async removeAgent(agentId) {
@@ -476,35 +262,29 @@ class AgentDiscoveryService {
         });
       }
 
-      // Get agent info before removal
-      let agentInfo = null;
+      // Remove from configuration manager
+      let removed = false;
       if (this.configManager) {
-        agentInfo = await this.configManager.getAgent(agentId);
+        removed = await this.configManager.removeAgent(agentId);
       }
 
-      if (!agentInfo) {
+      if (!removed) {
         return {
           success: false,
-          error: 'Agent not found',
+          error: 'Agent not found in configuration',
           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
-      });
+      await recordDiscoveryOperation('remove', {
+        agentId
+      }, this.fileManager, this.logger);
 
       return {
         success: true,
         agentId,
-        message: `Agent ${agentInfo.name} removed successfully`
+        message: `Agent ${agentId} removed successfully`
       };
     } catch (error) {
       if (this.logger) {
@@ -522,160 +302,6 @@ class AgentDiscoveryService {
     }
   }
 
-  /**
-   * 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