vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/SimpleAgentCheckService.js

@@ -0,0 +1,472 @@
+/**
+ * Simple Agent Check Service
+ * 
+ * Simplified agent checking that does exactly 5 steps:
+ * 1. Check if agent/IDE is installed
+ * 2. Add test requirement to hostname-specific requirements file
+ * 3. Send simple check command to agent
+ * 4. Check for test result
+ * 5. Delete test requirement (success or failure)
+ * 
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const fsSync = require('fs');
+const os = require('os');
+const { spawn } = require('child_process');
+
+// Constants
+const TEST_REQ_TITLE = 'VCM agent connectivity check';
+const PENDING_HEADER = '## ⏳ Requirements not yet completed';
+const VERIFIED_HEADER = '## ✅ Verified by AI';
+
+/**
+ * Get hostname-based requirements file path
+ */
+function getRequirementsPath(repoPath) {
+  const hostname = os.hostname();
+  return path.join(repoPath, '.vibecodingmachine', `REQUIREMENTS-${hostname}.md`);
+}
+
+/**
+ * Get result file path
+ */
+function getResultFilePath(repoPath) {
+  return path.join(repoPath, '.vibecodingmachine', 'temp', 'TEMP_agent_check.txt');
+}
+
+/**
+ * Simple agent check service class
+ */
+class SimpleAgentCheckService {
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.repoPath = options.repoPath || process.cwd();
+    this.timeout = options.timeout || 60000; // 1 minute default
+  }
+
+  /**
+   * Check if agent is installed
+   */
+  async checkAgentInstallation(agentId, agentConfig) {
+    if (agentConfig.type === 'ide') {
+      // Check if IDE process is running
+      const processName = agentConfig.process;
+      const { exec } = require('child_process');
+      
+      return new Promise((resolve) => {
+        exec(`pgrep -f "${processName}"`, (error, stdout, stderr) => {
+          const isRunning = !error && stdout.trim().length > 0;
+          resolve({ installed: isRunning, processName });
+        });
+      });
+    } else {
+      // For CLI agents, check if command exists
+      const command = agentConfig.command;
+      const { exec } = require('child_process');
+      
+      return new Promise((resolve) => {
+        exec(`which ${command}`, (error, stdout, stderr) => {
+          const isInstalled = !error;
+          resolve({ installed: isInstalled, command });
+        });
+      });
+    }
+  }
+
+  /**
+   * Add test requirement to requirements file
+   */
+  async addTestRequirement(agentId) {
+    const reqPath = getRequirementsPath(this.repoPath);
+    const resultFile = getResultFilePath(this.repoPath);
+    
+    let content = '';
+    try { 
+      content = await fs.readFile(reqPath, 'utf8'); 
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        // Create file with basic structure
+        content = `## ⏳ Requirements not yet completed
+
+## ✅ Verified by AI
+
+`;
+      } else {
+        throw error;
+      }
+    }
+
+    // Already present?
+    if (content.includes(TEST_REQ_TITLE)) {
+      return { added: false, reason: 'already_exists' };
+    }
+
+    const testBlock = `### 1. ${TEST_REQ_TITLE}
+🚦 Current Status: PREPARE
+Create a new file at the following absolute path: ${resultFile}
+The file must contain exactly this text on the first line: VCM_CHECK_OK
+Do not modify any other files. This is an automated connectivity test.
+
+`;
+
+    const pendingIndex = content.indexOf('## ⏳ Requirements not yet completed');
+    if (pendingIndex !== -1) {
+      // Insert after the pending header
+      const afterHeader = pendingIndex + '## ⏳ Requirements not yet completed'.length;
+      const before = content.slice(0, afterHeader);
+      const after = content.slice(afterHeader).replace(/^\n+/, '');
+      const newContent = before + '\n\n' + testBlock + after;
+      await fs.writeFile(reqPath, newContent, 'utf8');
+    } else {
+      // If no pending header, add it
+      const newContent = `## ⏳ Requirements not yet completed
+
+${testBlock}
+
+## ✅ Verified by AI
+
+`;
+      await fs.writeFile(reqPath, newContent, 'utf8');
+    }
+
+    return { added: true, reqPath, resultFile };
+  }
+
+  /**
+   * Send simple check command to agent
+   */
+  async sendCheckCommand(agentId, agentConfig) {
+    if (agentConfig.type === 'ide') {
+      // For IDE agents, use auto mode
+      const CLI_ENTRY_POINT = path.join(this.repoPath, 'bin', 'vibecodingmachine.js');
+      const args = ['auto', 'start', '--ide', agentId, '--max-chats', '1'];
+      
+      return new Promise((resolve) => {
+        const child = spawn('node', args, {
+          cwd: this.repoPath,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: false
+        });
+
+        let output = '';
+        child.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+        
+        child.stderr.on('data', (data) => {
+          output += data.toString();
+        });
+
+        child.on('exit', (code) => {
+          resolve({ success: code === 0, output, exitCode: code });
+        });
+
+        // Timeout
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill();
+            resolve({ success: false, output, exitCode: 'TIMEOUT' });
+          }
+        }, this.timeout);
+      });
+    } else {
+      // For CLI agents, send agent test command
+      const command = agentConfig.command;
+      const args = ['agent', 'test', '--repo', this.repoPath, '--result', getResultFilePath(this.repoPath)];
+      
+      return new Promise((resolve) => {
+        const child = spawn(command, args, {
+          cwd: this.repoPath,
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: false
+        });
+
+        let output = '';
+        child.stdout.on('data', (data) => {
+          output += data.toString();
+        });
+        
+        child.stderr.on('data', (data) => {
+          output += data.toString();
+        });
+
+        child.on('exit', (code) => {
+          resolve({ success: code === 0, output, exitCode: code });
+        });
+
+        // Timeout
+        setTimeout(() => {
+          if (!child.killed) {
+            child.kill();
+            resolve({ success: false, output, exitCode: 'TIMEOUT' });
+          }
+        }, this.timeout);
+      });
+    }
+  }
+
+  /**
+   * Check for test result
+   */
+  async checkTestResult(agentId) {
+    const resultFile = getResultFilePath(this.repoPath);
+    
+    // Wait a bit for file to be created
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    
+    try {
+      if (fsSync.existsSync(resultFile)) {
+        const content = fsSync.readFileSync(resultFile, 'utf8');
+        const success = content.includes('VCM_CHECK_OK');
+        
+        return { success, content };
+      } else {
+        return { success: false, reason: 'file_not_found' };
+      }
+    } catch (error) {
+      return { success: false, reason: 'error', error: error.message };
+    }
+  }
+
+  /**
+   * Remove test requirement
+   */
+  async removeTestRequirement(agentId) {
+    const reqPath = getRequirementsPath(this.repoPath);
+    
+    try {
+      let content = '';
+      try { 
+        content = await fs.readFile(reqPath, 'utf8'); 
+      } catch { 
+        return { removed: false, reason: 'file_not_found' };
+      }
+
+      if (!content.includes(TEST_REQ_TITLE)) {
+        return { removed: false, reason: 'not_found' };
+      }
+
+      const lines = content.split('\n');
+      let blockStart = -1;
+      
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(TEST_REQ_TITLE)) {
+          blockStart = i;
+          break;
+        }
+      }
+
+      if (blockStart === -1) {
+        return { removed: false, reason: 'not_found' };
+      }
+
+      let blockEnd = blockStart + 1;
+      while (blockEnd < lines.length && !lines[blockEnd].startsWith('###') && !lines[blockEnd].startsWith('## ')) {
+        blockEnd++;
+      }
+
+      lines.splice(blockStart, blockEnd - blockStart);
+      const cleaned = lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
+      await fs.writeFile(reqPath, cleaned, 'utf8');
+
+      return { removed: true };
+    } catch (error) {
+      return { removed: false, reason: 'error', error: error.message };
+    }
+  }
+
+  /**
+   * Clean up test result file
+   */
+  async cleanupTestResult(agentId) {
+    const resultFile = getResultFilePath(this.repoPath);
+    
+    try {
+      if (fsSync.existsSync(resultFile)) {
+        fsSync.unlinkSync(resultFile);
+      }
+    } catch (error) {
+      // Silently handle cleanup errors
+    }
+  }
+
+  /**
+   * Check single agent - simplified 5-step process
+   */
+  async checkAgent(agent, options = {}) {
+    const agentId = agent.id;
+    const startTime = Date.now();
+    const onProgress = options.onProgress || (() => {});
+    
+    try {
+      // Step 1: Check installation
+      onProgress(agentId, { 
+        phase: 'step1', 
+        step: 1, 
+        message: 'INSTALLED?',
+        detail: `Checking ${agent.name} installation...`
+      });
+      
+      const installCheck = await this.checkAgentInstallation(agentId, agent);
+      
+      const installDetail = agent.type === 'ide' 
+        ? `Process: ${installCheck.processName || agent.process} - ${installCheck.installed ? 'RUNNING' : 'NOT RUNNING'}`
+        : `Command: ${installCheck.command || agent.command} - ${installCheck.installed ? 'AVAILABLE' : 'NOT FOUND'}`;
+      
+      onProgress(agentId, { 
+        phase: 'step1', 
+        step: 1, 
+        message: 'INSTALLED?',
+        detail: installDetail
+      });
+      
+      if (!installCheck.installed) {
+        const message = agent.type === 'ide' 
+          ? `${agent.name} is not running (process: ${installCheck.processName || agent.process})`
+          : `${agent.name} is not installed (command: ${installCheck.command || agent.command})`;
+        
+        return {
+          success: false,
+          agentId,
+          status: 'not_installed',
+          message,
+          duration: Date.now() - startTime,
+          timestamp: new Date().toISOString()
+        };
+      }
+
+      // Step 2: Add test requirement
+      onProgress(agentId, { 
+        phase: 'step2', 
+        step: 2, 
+        message: 'REQUIREMENTS',
+        detail: 'Adding test requirement to requirements file...'
+      });
+      
+      const reqResult = await this.addTestRequirement(agentId);
+      
+      const reqDetail = reqResult.added 
+        ? `Added test requirement to ${reqResult.reqPath}`
+        : `Failed to add requirement: ${reqResult.reason}`;
+      
+      onProgress(agentId, { 
+        phase: 'step2', 
+        step: 2, 
+        message: 'REQUIREMENTS',
+        detail: reqDetail
+      });
+      
+      if (!reqResult.added) {
+        return {
+          success: false,
+          agentId,
+          status: 'requirement_error',
+          message: `Failed to add test requirement: ${reqResult.reason}`,
+          duration: Date.now() - startTime,
+          timestamp: new Date().toISOString()
+        };
+      }
+
+      // Step 3: Send check command
+      onProgress(agentId, { 
+        phase: 'step3', 
+        step: 3, 
+        message: 'TEST',
+        detail: `Sending check command to ${agent.name}...`
+      });
+      
+      const cmdResult = await this.sendCheckCommand(agentId, agent);
+      
+      const cmdDetail = cmdResult.success 
+        ? `Command sent successfully`
+        : `Command failed: ${cmdResult.exitCode === 'TIMEOUT' ? 'TIMEOUT' : `Exit code ${cmdResult.exitCode}`}`;
+      
+      onProgress(agentId, { 
+        phase: 'step3', 
+        step: 3, 
+        message: 'TEST',
+        detail: cmdDetail
+      });
+      
+      // Step 4: Check test result
+      const testResult = await this.checkTestResult(agentId);
+      
+      const testDetail = testResult.success 
+        ? `Test result: SUCCESS`
+        : `Test result: ${testResult.reason || 'FAILED'}`;
+      
+      onProgress(agentId, { 
+        phase: 'step4', 
+        step: 4, 
+        message: 'DELETE',
+        detail: 'Cleaning up test requirement...'
+      });
+      
+      // Step 5: Remove test requirement
+      const removeResult = await this.removeTestRequirement(agentId);
+      
+      const removeDetail = removeResult.removed 
+        ? `Test requirement removed successfully`
+        : `Remove failed: ${removeResult.reason}`;
+      
+      onProgress(agentId, { 
+        phase: 'step5', 
+        step: 5, 
+        message: 'STATUS',
+        detail: testDetail
+      });
+      
+      // Clean up test result file
+      await this.cleanupTestResult(agentId);
+      
+      // Determine final status
+      let status, message;
+      if (testResult.success) {
+        status = 'reachable';
+        message = `${agent.name} is reachable and responding`;
+      } else if (cmdResult.exitCode === 'TIMEOUT') {
+        status = 'timeout';
+        message = `${agent.name} timed out - may need authentication`;
+      } else if (cmdResult.output && cmdResult.output.toLowerCase().includes('rate limit')) {
+        status = 'rate_limited';
+        message = `${agent.name} is rate limited`;
+      } else {
+        status = 'unreachable';
+        message = `${agent.name} is not responding - check authentication`;
+      }
+
+      const duration = Date.now() - startTime;
+      
+      return {
+        success: testResult.success,
+        agentId,
+        status,
+        message,
+        duration,
+        timestamp: new Date().toISOString(),
+        details: {
+          installCheck,
+          reqResult,
+          cmdResult,
+          testResult
+        }
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        agentId,
+        status: 'error',
+        message: `Check failed: ${error.message}`,
+        duration: Date.now() - startTime,
+        timestamp: new Date().toISOString(),
+        error: error.message
+      };
+    }
+  }
+}
+
+module.exports = SimpleAgentCheckService;

package/src/agents/config-managers/ConfigUtils.js

@@ -0,0 +1,72 @@
+/**
+ * Configuration Utilities Module
+ * 
+ * Provides utility functions for configuration management.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Set nested configuration value
+ * @param {Object} obj - Target object
+ * @param {string} path - Dot-separated path
+ * @param {*} value - Value to set
+ */
+function setNestedValue(obj, path, value) {
+  const keys = path.split('.');
+  let current = obj;
+  
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== 'object') {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  
+  current[keys[keys.length - 1]] = value;
+}
+
+/**
+ * Get nested configuration value
+ * @param {Object} obj - Source object
+ * @param {string} path - Dot-separated path
+ * @returns {*} - Configuration value
+ */
+function getNestedValue(obj, path) {
+  const keys = path.split('.');
+  let current = obj;
+  
+  for (const key of keys) {
+    if (current && typeof current === 'object' && key in current) {
+      current = current[key];
+    } else {
+      return undefined;
+    }
+  }
+  
+  return current;
+}
+
+/**
+ * Deep merge objects
+ * @param {Object} target - Target object
+ * @param {Object} source - Source object
+ */
+function deepMerge(target, source) {
+  for (const key in source) {
+    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+      if (!target[key] || typeof target[key] !== 'object') {
+        target[key] = {};
+      }
+      deepMerge(target[key], source[key]);
+    } else {
+      target[key] = source[key];
+    }
+  }
+}
+
+module.exports = {
+  setNestedValue,
+  getNestedValue,
+  deepMerge
+};

package/src/agents/config-managers/DefaultConfig.js

@@ -0,0 +1,58 @@
+/**
+ * Default Configuration Module
+ * 
+ * Defines default configuration schema.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+/**
+ * Get default configuration schema
+ * @returns {Object} - Default configuration
+ */
+function getDefaultConfig() {
+  return {
+    installation: {
+      timeout: 300000,
+      maxConcurrent: 2,
+      retryAttempts: 3,
+      retryDelay: 5000,
+      autoElevate: false
+    },
+    logging: {
+      level: 'info',
+      file: null,
+      format: 'json',
+      verbose: false
+    },
+    cache: {
+      directory: './cache',
+      maxSize: 100 * 1024 * 1024, // 100MB
+      ttl: 3600000 // 1 hour
+    },
+    network: {
+      timeout: 30000,
+      proxy: null,
+      userAgent: null,
+      rateLimitDelay: 1000
+    },
+    security: {
+      strictMode: true,
+      maxFileSize: 100 * 1024 * 1024, // 100MB
+      allowedExtensions: ['.exe', '.msi', '.zip', '.tar', '.gz']
+    },
+    performance: {
+      monitoring: true,
+      metricsFile: null,
+      flushInterval: 60000
+    },
+    agents: {
+      defaultFile: './config/agents.json',
+      discoveryEnabled: true,
+      autoUpdate: false
+    }
+  };
+}
+
+module.exports = {
+  getDefaultConfig
+};

package/src/agents/config-managers/EnvVarLoader.js

@@ -0,0 +1,66 @@
+/**
+ * Environment Variable Loader Module
+ * 
+ * Handles loading configuration from environment variables.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { setNestedValue } = require('./ConfigUtils');
+
+/**
+ * Load configuration from environment variables
+ * @param {Object} variableMappings - Variable mappings
+ * @param {string} prefix - Environment variable prefix
+ * @param {Object} logger - Logger instance
+ * @returns {Object} - Environment configuration
+ */
+function loadEnvironmentVariables(variableMappings, prefix, logger) {
+  const config = {};
+  
+  for (const [envVar, configPath] of Object.entries(variableMappings)) {
+    const fullEnvVar = prefix + envVar;
+    const value = process.env[fullEnvVar];
+    
+    if (value !== undefined) {
+      setNestedValue(config, configPath, value);
+      
+      if (logger) {
+        logger.debug('Loaded environment variable', {
+          variable: fullEnvVar,
+          configPath,
+          value
+        });
+      }
+    }
+  }
+  
+  return config;
+}
+
+/**
+ * Export configuration to environment file
+ * @param {Object} config - Configuration object
+ * @param {Object} defaultConfig - Default configuration
+ * @param {Object} variableMappings - Variable mappings
+ * @param {string} prefix - Environment variable prefix
+ * @param {Function} getNestedValue - Get nested value function
+ * @returns {Array<string>} - Environment variable lines
+ */
+function exportToEnvironmentVariables(config, defaultConfig, variableMappings, prefix, getNestedValue) {
+  const envVars = [];
+  
+  for (const [envVar, configPath] of Object.entries(variableMappings)) {
+    const value = getNestedValue(config, configPath);
+    if (value !== undefined && value !== getNestedValue(defaultConfig, configPath)) {
+      const fullEnvVar = prefix + envVar;
+      envVars.push(`${fullEnvVar}=${JSON.stringify(value)}`);
+    }
+  }
+  
+  return envVars;
+}
+
+module.exports = {
+  loadEnvironmentVariables,
+  exportToEnvironmentVariables
+};