vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -0,0 +1,161 @@
+/**
+ * Discovery Utilities
+ * 
+ * Utility functions for agent discovery operations.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { spawn, exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Check if a command exists on the system
+ * @param {string} command - Command to check
+ * @returns {Promise<boolean>} - True if command exists
+ */
+async function commandExists(command) {
+  try {
+    await execAsync(`which ${command}`);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get command help text
+ * @param {string} command - Command to get help for
+ * @param {number} timeout - Timeout in milliseconds
+ * @returns {Promise<string>} - Help text
+ */
+async function getCommandHelp(command, timeout = 5000) {
+  return new Promise((resolve) => {
+    const child = spawn(command, ['--help'], { 
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout 
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      resolve(stdout || stderr || `Command exited with code ${code}`);
+    });
+
+    child.on('error', (error) => {
+      resolve(`Error: ${error.message}`);
+    });
+  });
+}
+
+/**
+ * Scan directory for executable files
+ * @param {string} dirPath - Directory to scan
+ * @returns {Promise<Array>} - Array of executable files
+ */
+async function scanDirectory(dirPath) {
+  try {
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const executables = [];
+
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const fullPath = path.join(dirPath, entry.name);
+        try {
+          await fs.access(fullPath, fs.constants.X_OK);
+          executables.push({
+            name: entry.name,
+            path: fullPath,
+            type: 'executable'
+          });
+        } catch (error) {
+          // Not executable, skip
+        }
+      }
+    }
+
+    return executables;
+  } catch (error) {
+    return [];
+  }
+}
+
+/**
+ * Check if file is an agent CLI tool
+ * @param {Object} fileInfo - File information
+ * @returns {Promise<boolean>} - True if appears to be an agent
+ */
+async function isAgentTool(fileInfo) {
+  const { name, path: filePath } = fileInfo;
+  
+  // Skip common non-agent executables
+  const skipPatterns = [
+    /^(ls|cd|pwd|cat|echo|rm|cp|mv|mkdir|chmod|chown)/,
+    /^(node|npm|yarn|python|pip|git|curl|wget)/,
+    /^(docker|kubectl|helm|aws|az|gcloud)/
+  ];
+
+  for (const pattern of skipPatterns) {
+    if (pattern.test(name)) {
+      return false;
+    }
+  }
+
+  // Check if it has agent-like help output
+  try {
+    const help = await getCommandHelp(filePath, 3000);
+    const agentKeywords = [
+      'agent', 'ai', 'assistant', 'chat', 'llm', 'model',
+      'openai', 'anthropic', 'claude', 'gpt', 'gemini'
+    ];
+    
+    return agentKeywords.some(keyword => 
+      help.toLowerCase().includes(keyword.toLowerCase())
+    );
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Get file metadata
+ * @param {string} filePath - Path to file
+ * @returns {Promise<Object>} - File metadata
+ */
+async function getFileMetadata(filePath) {
+  try {
+    const stats = await fs.stat(filePath);
+    return {
+      size: stats.size,
+      modified: stats.mtime,
+      created: stats.birthtime,
+      isExecutable: !!(stats.mode & parseInt('111', 8))
+    };
+  } catch (error) {
+    return {
+      size: 0,
+      modified: new Date(),
+      created: new Date(),
+      isExecutable: false
+    };
+  }
+}
+
+module.exports = {
+  commandExists,
+  getCommandHelp,
+  scanDirectory,
+  isAgentTool,
+  getFileMetadata
+};

package/src/agents/discovery/executable-analyzer.js

@@ -0,0 +1,290 @@
+/**
+ * Agent Discovery - Executable Analyzer
+ * 
+ * Analyzes executable files to determine if they are agent tools.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { spawn, exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Analyze executable file for agent information
+ * @param {string} filePath - Path to executable file
+ * @param {Object} logger - Logger instance
+ * @returns {Promise<Object>} - Agent information or null
+ */
+async function analyzeExecutable(filePath, logger = null) {
+  try {
+    // Get file info
+    const stat = await fs.stat(filePath);
+    const fileName = path.basename(filePath);
+    
+    // Basic agent information
+    const agentInfo = {
+      id: generateAgentId(fileName),
+      name: sanitizeAgentName(fileName),
+      path: filePath,
+      type: detectAgentType(fileName),
+      version: 'unknown',
+      capabilities: [],
+      description: '',
+      size: stat.size,
+      modified: stat.mtime,
+      discovered: new Date().toISOString()
+    };
+
+    // Try to extract more information
+    await Promise.allSettled([
+      extractVersion(agentInfo, filePath, logger),
+      extractDescription(agentInfo, filePath, logger),
+      detectCapabilities(agentInfo, filePath, logger)
+    ]);
+
+    return agentInfo;
+  } catch (error) {
+    if (logger) {
+      await logger.warn(`Failed to analyze executable ${filePath}: ${error.message}`);
+    }
+    return null;
+  }
+}
+
+/**
+ * Generate agent ID from filename
+ * @param {string} fileName - Filename
+ * @returns {string} - Agent ID
+ */
+function generateAgentId(fileName) {
+  const baseName = path.parse(fileName).name;
+  return baseName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+}
+
+/**
+ * Sanitize agent name
+ * @param {string} fileName - Filename
+ * @returns {string} - Sanitized name
+ */
+function sanitizeAgentName(fileName) {
+  const baseName = path.parse(fileName).name;
+  return baseName.replace(/[-_]/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+}
+
+/**
+ * Detect agent type from filename
+ * @param {string} fileName - Filename
+ * @returns {string} - Agent type
+ */
+function detectAgentType(fileName) {
+  const name = fileName.toLowerCase();
+  
+  if (name.includes('ai') || name.includes('agent') || name.includes('assistant')) {
+    return 'ai-agent';
+  }
+  if (name.includes('cli') || name.includes('cmd') || name.includes('tool')) {
+    return 'cli-tool';
+  }
+  if (name.includes('bot') || name.includes('automation')) {
+    return 'automation-bot';
+  }
+  
+  return 'unknown';
+}
+
+/**
+ * Extract version from executable
+ * @param {Object} agentInfo - Agent info object
+ * @param {string} filePath - File path
+ * @param {Object} logger - Logger instance
+ */
+async function extractVersion(agentInfo, filePath, logger) {
+  try {
+    // Try common version flags
+    const versionFlags = ['--version', '-v', '--version', '-V'];
+    
+    for (const flag of versionFlags) {
+      try {
+        const { stdout } = await execAsync(`${filePath} ${flag}`, { 
+          timeout: 5000,
+          env: { ...process.env, NO_COLOR: '1' }
+        });
+        
+        const version = parseVersionOutput(stdout);
+        if (version) {
+          agentInfo.version = version;
+          return;
+        }
+      } catch (error) {
+        // Try next flag
+      }
+    }
+
+    // Try to extract from file content (shebang, comments, etc.)
+    const content = await fs.readFile(filePath, 'utf8');
+    const version = extractVersionFromContent(content);
+    if (version) {
+      agentInfo.version = version;
+    }
+  } catch (error) {
+    if (logger) {
+      await logger.debug(`Version extraction failed for ${filePath}: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Parse version output
+ * @param {string} output - Command output
+ * @returns {string|null} - Version string or null
+ */
+function parseVersionOutput(output) {
+  const lines = output.trim().split('\n');
+  
+  for (const line of lines) {
+    // Look for version patterns
+    const versionMatch = line.match(/(\d+\.\d+(\.\d+)?)/);
+    if (versionMatch) {
+      return versionMatch[1];
+    }
+    
+    // Look for "version X.Y.Z" patterns
+    const versionWordMatch = line.match(/version\s+(\d+\.\d+(\.\d+)?)/i);
+    if (versionWordMatch) {
+      return versionWordMatch[1];
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extract version from file content
+ * @param {string} content - File content
+ * @returns {string|null} - Version string or null
+ */
+function extractVersionFromContent(content) {
+  // Look for version in common patterns
+  const patterns = [
+    /version\s*=\s*['"`]([^'"`]+)['"`]/i,
+    /const\s+VERSION\s*=\s*['"`]([^'"`]+)['"`]/i,
+    /__version__\s*=\s*['"`]([^'"`]+)['"`]/i
+  ];
+  
+  for (const pattern of patterns) {
+    const match = content.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Extract description from executable
+ * @param {Object} agentInfo - Agent info object
+ * @param {string} filePath - File path
+ * @param {Object} logger - Logger instance
+ */
+async function extractDescription(agentInfo, filePath, logger) {
+  try {
+    // Try help flag
+    const { stdout } = await execAsync(`${filePath} --help`, { 
+      timeout: 5000,
+      env: { ...process.env, NO_COLOR: '1' }
+    });
+    
+    const description = parseDescriptionFromHelp(stdout);
+    if (description) {
+      agentInfo.description = description;
+    }
+  } catch (error) {
+    if (logger) {
+      await logger.debug(`Description extraction failed for ${filePath}: ${error.message}`);
+    }
+  }
+}
+
+/**
+ * Parse description from help output
+ * @param {string} helpOutput - Help command output
+ * @returns {string} - Description
+ */
+function parseDescriptionFromHelp(helpOutput) {
+  const lines = helpOutput.trim().split('\n');
+  
+  // Look for description in first few lines
+  for (let i = 0; i < Math.min(5, lines.length); i++) {
+    const line = lines[i].trim();
+    
+    // Skip empty lines and common help headers
+    if (!line || line.startsWith('Usage:') || line.startsWith('Options:')) {
+      continue;
+    }
+    
+    // Return first meaningful line as description
+    if (line.length > 10 && !line.startsWith('-')) {
+      return line.substring(0, 200); // Limit length
+    }
+  }
+  
+  return '';
+}
+
+/**
+ * Detect capabilities from executable
+ * @param {Object} agentInfo - Agent info object
+ * @param {string} filePath - File path
+ * @param {Object} logger - Logger instance
+ */
+async function detectCapabilities(agentInfo, filePath, logger) {
+  const capabilities = [];
+  
+  try {
+    // Check if it's a script
+    const content = await fs.readFile(filePath, 'utf8');
+    
+    if (content.includes('chat') || content.includes('conversation')) {
+      capabilities.push('chat');
+    }
+    
+    if (content.includes('code') || content.includes('programming')) {
+      capabilities.push('code-generation');
+    }
+    
+    if (content.includes('file') || content.includes('document')) {
+      capabilities.push('file-processing');
+    }
+    
+    if (content.includes('web') || content.includes('http')) {
+      capabilities.push('web-interaction');
+    }
+    
+    // Check for common CLI patterns
+    if (content.includes('process.argv') || content.includes('yargs') || content.includes('commander')) {
+      capabilities.push('cli-interface');
+    }
+    
+  } catch (error) {
+    if (logger) {
+      await logger.debug(`Capability detection failed for ${filePath}: ${error.message}`);
+    }
+  }
+  
+  // Add default capabilities based on file type
+  capabilities.push('help');
+  
+  agentInfo.capabilities = capabilities;
+}
+
+module.exports = {
+  analyzeExecutable,
+  generateAgentId,
+  sanitizeAgentName,
+  detectAgentType,
+  extractVersion,
+  detectCapabilities
+};