vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/discovery/agent-validator.js

@@ -0,0 +1,262 @@
+/**
+ * Agent Discovery - Validator
+ * 
+ * Validates and deduplicates discovered agents.
+ */
+
+/**
+ * Validate and deduplicate discovered agents
+ * @param {Array} agents - Discovered agents
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Array>} - Valid, deduplicated agents
+ */
+async function validateAndDeduplicateAgents(agents, logger = null) {
+  const validAgents = [];
+  const seenIds = new Set();
+  const seenPaths = new Set();
+
+  for (const agent of agents) {
+    // Validate required fields
+    if (!validateRequiredFields(agent, logger)) {
+      continue;
+    }
+
+    // Check for duplicates
+    if (seenIds.has(agent.id)) {
+      if (logger) {
+        await logger.warn('Duplicate agent ID found: ' + agent.id);
+      }
+      continue;
+    }
+
+    if (seenPaths.has(agent.path)) {
+      if (logger) {
+        await logger.warn('Duplicate agent path found: ' + agent.path);
+      }
+      continue;
+    }
+
+    // Additional validation
+    await validateAgentDetails(agent, logger);
+
+    validAgents.push(agent);
+    seenIds.add(agent.id);
+    seenPaths.add(agent.path);
+  }
+
+  return validAgents;
+}
+
+/**
+ * Validate required agent fields
+ * @param {Object} agent - Agent object
+ * @param {Object} logger - Logger instance
+ * @returns {boolean} - True if valid
+ */
+function validateRequiredFields(agent, logger) {
+  const requiredFields = ['id', 'name', 'path'];
+  
+  for (const field of requiredFields) {
+    if (!agent[field]) {
+      if (logger) {
+        logger.warn('Invalid agent configuration: missing required field', {
+          field,
+          agent: agent.id || 'unknown'
+        });
+      }
+      return false;
+    }
+  }
+  
+  return true;
+}
+
+/**
+ * Validate agent details
+ * @param {Object} agent - Agent object
+ * @param {Object} logger - Logger instance
+ */
+async function validateAgentDetails(agent, logger) {
+  // Check version
+  if (agent.version === 'unknown') {
+    if (logger) {
+      logger.warn(`Agent ${agent.id} has unknown version`);
+    }
+  }
+
+  // Validate path exists
+  try {
+    const fs = require('fs').promises;
+    await fs.access(agent.path);
+  } catch (error) {
+    if (logger) {
+      logger.warn(`Agent ${agent.id} path not accessible: ${agent.path}`);
+    }
+  }
+
+  // Validate capabilities
+  if (!Array.isArray(agent.capabilities)) {
+    agent.capabilities = [];
+    if (logger) {
+      logger.warn(`Agent ${agent.id} has invalid capabilities, reset to empty array`);
+    }
+  }
+
+  // Validate type
+  const validTypes = ['ai-agent', 'cli-tool', 'automation-bot', 'unknown'];
+  if (!validTypes.includes(agent.type)) {
+    agent.type = 'unknown';
+    if (logger) {
+      logger.warn(`Agent ${agent.id} has invalid type, set to unknown`);
+    }
+  }
+}
+
+/**
+ * Validate single agent configuration
+ * @param {Object} agent - Agent to validate
+ * @returns {Object} - Validation result
+ */
+function validateAgent(agent) {
+  const errors = [];
+  const warnings = [];
+
+  // Required fields
+  if (!agent.id) errors.push('Missing agent ID');
+  if (!agent.name) errors.push('Missing agent name');
+  if (!agent.path) errors.push('Missing agent path');
+
+  // Format validation
+  if (agent.id && !/^[a-z0-9-]+$/.test(agent.id)) {
+    errors.push('Agent ID must contain only lowercase letters, numbers, and hyphens');
+  }
+
+  if (agent.name && agent.name.length > 100) {
+    warnings.push('Agent name is very long (>100 characters)');
+  }
+
+  if (agent.description && agent.description.length > 500) {
+    warnings.push('Agent description is very long (>500 characters)');
+  }
+
+  // Type validation
+  const validTypes = ['ai-agent', 'cli-tool', 'automation-bot', 'unknown'];
+  if (agent.type && !validTypes.includes(agent.type)) {
+    errors.push(`Invalid agent type: ${agent.type}. Must be one of: ${validTypes.join(', ')}`);
+  }
+
+  // Version validation
+  if (agent.version && !/^\d+\.\d+(\.\d+)?(-.*)?$/.test(agent.version)) {
+    warnings.push(`Version format may be invalid: ${agent.version}`);
+  }
+
+  // Capability validation
+  if (agent.capabilities) {
+    if (!Array.isArray(agent.capabilities)) {
+      errors.push('Capabilities must be an array');
+    } else {
+      const validCapabilities = [
+        'chat', 'code-generation', 'file-processing', 'web-interaction',
+        'cli-interface', 'help', 'automation', 'analysis', 'monitoring'
+      ];
+      
+      for (const cap of agent.capabilities) {
+        if (!validCapabilities.includes(cap)) {
+          warnings.push(`Unknown capability: ${cap}`);
+        }
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * Filter agents by criteria
+ * @param {Array} agents - Agents to filter
+ * @param {Object} criteria - Filter criteria
+ * @returns {Array} - Filtered agents
+ */
+function filterAgents(agents, criteria) {
+  return agents.filter(agent => {
+    // Type filter
+    if (criteria.type && agent.type !== criteria.type) {
+      return false;
+    }
+
+    // Capability filter
+    if (criteria.capability && (!agent.capabilities || !agent.capabilities.includes(criteria.capability))) {
+      return false;
+    }
+
+    // Name filter
+    if (criteria.name && !agent.name.toLowerCase().includes(criteria.name.toLowerCase())) {
+      return false;
+    }
+
+    // Version filter
+    if (criteria.version && !agent.version.includes(criteria.version)) {
+      return false;
+    }
+
+    // Path filter
+    if (criteria.path && !agent.path.includes(criteria.path)) {
+      return false;
+    }
+
+    return true;
+  });
+}
+
+/**
+ * Sort agents by criteria
+ * @param {Array} agents - Agents to sort
+ * @param {string} sortBy - Sort field
+ * @param {string} order - Sort order ('asc' or 'desc')
+ * @returns {Array} - Sorted agents
+ */
+function sortAgents(agents, sortBy = 'name', order = 'asc') {
+  return [...agents].sort((a, b) => {
+    let aValue = a[sortBy];
+    let bValue = b[sortBy];
+
+    // Handle missing values
+    if (aValue === undefined) aValue = '';
+    if (bValue === undefined) bValue = '';
+
+    // String comparison
+    if (typeof aValue === 'string' && typeof bValue === 'string') {
+      const comparison = aValue.toLowerCase().localeCompare(bValue.toLowerCase());
+      return order === 'desc' ? -comparison : comparison;
+    }
+
+    // Number comparison
+    if (typeof aValue === 'number' && typeof bValue === 'number') {
+      const comparison = aValue - bValue;
+      return order === 'desc' ? -comparison : comparison;
+    }
+
+    // Date comparison
+    if (aValue instanceof Date && bValue instanceof Date) {
+      const comparison = aValue.getTime() - bValue.getTime();
+      return order === 'desc' ? -comparison : comparison;
+    }
+
+    // Default comparison
+    const comparison = String(aValue).localeCompare(String(bValue));
+    return order === 'desc' ? -comparison : comparison;
+  });
+}
+
+module.exports = {
+  validateAndDeduplicateAgents,
+  validateAgent,
+  validateRequiredFields,
+  validateAgentDetails,
+  filterAgents,
+  sortAgents
+};

package/src/agents/discovery/discovery-results.js

@@ -0,0 +1,176 @@
+/**
+ * Discovery Results
+ * 
+ * Classes and utilities for managing discovery results.
+ */
+
+/**
+ * Discovered agent information
+ */
+class DiscoveredAgent {
+  constructor(fileInfo, commandHelp = '') {
+    this.name = fileInfo.name;
+    this.path = fileInfo.path;
+    this.type = fileInfo.type;
+    this.help = commandHelp;
+    this.confidence = 0;
+    this.metadata = {
+      discoveredAt: new Date().toISOString(),
+      source: 'filesystem_scan',
+      verified: false
+    };
+  }
+
+  /**
+   * Set confidence level
+   * @param {number} confidence - Confidence score (0-1)
+   */
+  setConfidence(confidence) {
+    this.confidence = Math.max(0, Math.min(1, confidence));
+    this.metadata.confidenceCalculatedAt = new Date().toISOString();
+  }
+
+  /**
+   * Mark as verified
+   * @param {boolean} verified - Verification status
+   */
+  setVerified(verified = true) {
+    this.metadata.verified = verified;
+    this.metadata.verifiedAt = new Date().toISOString();
+  }
+
+  /**
+   * Add additional metadata
+   * @param {string} key - Metadata key
+   * @param {*} value - Metadata value
+   */
+  addMetadata(key, value) {
+    this.metadata[key] = value;
+  }
+
+  /**
+   * Convert to JSON
+   * @returns {Object} - JSON representation
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      path: this.path,
+      type: this.type,
+      help: this.help,
+      confidence: this.confidence,
+      metadata: this.metadata
+    };
+  }
+}
+
+/**
+ * Discovery session result
+ */
+class DiscoveryResult {
+  constructor(sessionId = null) {
+    this.sessionId = sessionId || this.generateSessionId();
+    this.agents = [];
+    this.warnings = [];
+    this.errors = [];
+    this.metadata = {
+      startedAt: new Date().toISOString(),
+      completedAt: null,
+      duration: 0,
+      pathsScanned: [],
+      totalFiles: 0,
+      agentCandidates: 0
+    };
+  }
+
+  /**
+   * Generate unique session ID
+   * @returns {string} - Session ID
+   */
+  generateSessionId() {
+    return `discovery_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Add discovered agent
+   * @param {DiscoveredAgent} agent - Discovered agent
+   */
+  addAgent(agent) {
+    if (agent instanceof DiscoveredAgent) {
+      this.agents.push(agent);
+      this.metadata.agentCandidates++;
+    }
+  }
+
+  /**
+   * Add warning
+   * @param {string} warning - Warning message
+   * @param {Object} context - Warning context
+   */
+  addWarning(warning, context = {}) {
+    this.warnings.push({
+      message: warning,
+      context,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Add error
+   * @param {Error|string} error - Error object or message
+   * @param {Object} context - Error context
+   */
+  addError(error, context = {}) {
+    this.errors.push({
+      message: error.message || error,
+      stack: error.stack,
+      context,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Mark discovery as complete
+   */
+  complete() {
+    this.metadata.completedAt = new Date().toISOString();
+    this.metadata.duration = new Date(this.metadata.completedAt) - new Date(this.metadata.startedAt);
+  }
+
+  /**
+   * Get summary statistics
+   * @returns {Object} - Summary statistics
+   */
+  getSummary() {
+    return {
+      sessionId: this.sessionId,
+      totalAgents: this.agents.length,
+      verifiedAgents: this.agents.filter(a => a.metadata.verified).length,
+      highConfidenceAgents: this.agents.filter(a => a.confidence > 0.7).length,
+      warnings: this.warnings.length,
+      errors: this.errors.length,
+      duration: this.metadata.duration,
+      success: this.errors.length === 0
+    };
+  }
+
+  /**
+   * Convert to JSON
+   * @returns {Object} - JSON representation
+   */
+  toJSON() {
+    return {
+      sessionId: this.sessionId,
+      agents: this.agents.map(a => a.toJSON()),
+      warnings: this.warnings,
+      errors: this.errors,
+      metadata: this.metadata,
+      summary: this.getSummary()
+    };
+  }
+}
+
+module.exports = {
+  DiscoveredAgent,
+  DiscoveryResult
+};

package/src/agents/discovery/discovery-scanner.js

@@ -0,0 +1,268 @@
+/**
+ * Discovery Scanner
+ * 
+ * Core scanning logic for agent discovery.
+ */
+
+const { 
+  commandExists, 
+  getCommandHelp, 
+  scanDirectory, 
+  isAgentTool,
+  getFileMetadata 
+} = require('./discovery-utils');
+
+const { DiscoveredAgent, DiscoveryResult } = require('./discovery-results');
+const { promisify } = require('util');
+const { exec } = require('child_process');
+
+const execAsync = promisify(exec);
+
+/**
+ * Discovery Scanner class
+ */
+class DiscoveryScanner {
+  constructor(options = {}) {
+    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.logger = options.logger || null;
+  }
+
+  /**
+   * Scan all configured paths
+   * @param {string} sessionId - Discovery session ID
+   * @returns {Promise<DiscoveryResult>} - Discovery results
+   */
+  async scanAllPaths(sessionId = null) {
+    const result = new DiscoveryResult(sessionId);
+    
+    try {
+      if (this.logger) {
+        await this.logger.info('Starting discovery scan', {
+          paths: this.discoveryPaths,
+          timeout: this.timeout
+        });
+      }
+
+      result.metadata.pathsScanned = [...this.discoveryPaths];
+
+      // Scan all directories concurrently with limit
+      const scanPromises = this.discoveryPaths.map(path => 
+        this.scanPath(path, result)
+      );
+
+      await Promise.allSettled(scanPromises);
+
+      // Analyze and rank discovered agents
+      await this.analyzeDiscoveredAgents(result);
+
+      result.complete();
+
+      if (this.logger) {
+        await this.logger.info('Discovery scan completed', result.getSummary());
+      }
+
+    } catch (error) {
+      result.addError(error, { phase: 'scanning' });
+      result.complete();
+    }
+
+    return result;
+  }
+
+  /**
+   * Scan a single path
+   * @param {string} scanPath - Path to scan
+   * @param {DiscoveryResult} result - Discovery result object
+   * @returns {Promise<void>}
+   */
+  async scanPath(scanPath, result) {
+    try {
+      const files = await scanDirectory(scanPath);
+      result.metadata.totalFiles += files.length;
+
+      // Process files with concurrency limit
+      const chunks = this.chunkArray(files, this.maxConcurrency);
+      
+      for (const chunk of chunks) {
+        await Promise.allSettled(
+          chunk.map(file => this.processFile(file, result))
+        );
+      }
+
+    } catch (error) {
+      result.addWarning(`Failed to scan path: ${scanPath}`, { error: error.message });
+    }
+  }
+
+  /**
+   * Process a single file
+   * @param {Object} fileInfo - File information
+   * @param {DiscoveryResult} result - Discovery result object
+   * @returns {Promise<void>}
+   */
+  async processFile(fileInfo, result) {
+    try {
+      // Check if it's an agent tool
+      const isAgent = await isAgentTool(fileInfo);
+      
+      if (!isAgent) {
+        return;
+      }
+
+      // Get command help for analysis
+      let commandHelp = '';
+      try {
+        commandHelp = await getCommandHelp(fileInfo.path, this.timeout / 10);
+      } catch (error) {
+        // Help not available, continue without it
+      }
+
+      // Create discovered agent
+      const agent = new DiscoveredAgent(fileInfo, commandHelp);
+      
+      result.addAgent(agent);
+
+    } catch (error) {
+      result.addWarning(`Failed to process file: ${fileInfo.name}`, { 
+        error: error.message 
+      });
+    }
+  }
+
+  /**
+   * Calculate confidence score for discovered agent
+   * @param {DiscoveredAgent} agent - Discovered agent
+   * @returns {Promise<number>} - Confidence score (0-1)
+   */
+  async calculateConfidence(agent) {
+    let confidence = 0;
+
+    // Help text analysis (40% weight)
+    if (agent.help) {
+      const helpLower = agent.help.toLowerCase();
+      const agentKeywords = [
+        'agent', 'ai', 'assistant', 'chat', 'llm', 'model',
+        'openai', 'anthropic', 'claude', 'gpt', 'gemini'
+      ];
+      
+      const keywordMatches = agentKeywords.filter(keyword => 
+        helpLower.includes(keyword.toLowerCase())
+      ).length;
+      
+      confidence += (keywordMatches / agentKeywords.length) * 0.4;
+    }
+
+    // File name analysis (30% weight)
+    const nameLower = agent.name.toLowerCase();
+    const nameKeywords = [
+      'agent', 'ai', 'assistant', 'chat', 'llm', 'claude', 'gpt'
+    ];
+    
+    const nameMatches = nameKeywords.filter(keyword => 
+      nameLower.includes(keyword.toLowerCase())
+    ).length;
+    
+    confidence += (nameMatches / nameKeywords.length) * 0.3;
+
+    // Path analysis (20% weight)
+    const pathLower = agent.path.toLowerCase();
+    const pathIndicators = ['agent', 'ai', 'tools', 'bin'];
+    const pathMatches = pathIndicators.filter(indicator => 
+      pathLower.includes(indicator.toLowerCase())
+    ).length;
+    
+    confidence += (pathMatches / pathIndicators.length) * 0.2;
+
+    // Executable status (10% weight)
+    try {
+      const metadata = await getFileMetadata(agent.path);
+      if (metadata.isExecutable) {
+        confidence += 0.1;
+      }
+    } catch (error) {
+      // Unable to check executable status
+    }
+
+    return Math.min(1, confidence);
+  }
+
+  /**
+   * Analyze and rank discovered agents
+   * @param {DiscoveryResult} result - Discovery result object
+   * @returns {Promise<void>}
+   */
+  async analyzeDiscoveredAgents(result) {
+    // Calculate confidence scores for all agents
+    for (const agent of result.agents) {
+      const confidence = await this.calculateConfidence(agent);
+      agent.setConfidence(confidence);
+    }
+
+    // Sort agents by confidence score
+    result.agents.sort((a, b) => b.confidence - a.confidence);
+
+    // Verify high-confidence agents
+    const highConfidenceAgents = result.agents.filter(a => a.confidence > 0.7);
+    
+    for (const agent of highConfidenceAgents) {
+      try {
+        const isVerified = await this.verifyAgent(agent);
+        agent.setVerified(isVerified);
+      } catch (error) {
+        result.addWarning(`Failed to verify agent: ${agent.name}`, { 
+          error: error.message 
+        });
+      }
+    }
+  }
+
+  /**
+   * Verify a discovered agent
+   * @param {DiscoveredAgent} agent - Agent to verify
+   * @returns {Promise<boolean>} - True if agent is verified
+   */
+  async verifyAgent(agent) {
+    try {
+      // Try to run the agent with --version or --help
+      const verifyCommands = ['--version', '--help', '-v', '-h'];
+      
+      for (const cmd of verifyCommands) {
+        try {
+          await execAsync(`${agent.path} ${cmd}`, {
+            timeout: 5000
+          });
+          return true;
+        } catch (error) {
+          // Try next command
+        }
+      }
+      
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Split array into chunks
+   * @param {Array} array - Array to split
+   * @param {number} size - Chunk size
+   * @returns {Array<Array>} - Array of chunks
+   */
+  chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}
+
+module.exports = DiscoveryScanner;