vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/verification/test-analyzer.js

@@ -0,0 +1,290 @@
+/**
+ * Verification Result - Test Analyzer
+ * 
+ * Analyzes individual verification test results.
+ */
+
+const { AgentStatus } = require('../AgentStatus');
+const { VerificationType } = require('../VerificationType');
+
+/**
+ * Determine test result severity
+ * @param {Object} testResult - Test result
+ * @returns {string} - Severity level
+ */
+function determineSeverity(testResult) {
+  if (!testResult.success) {
+    if (testResult.error) {
+      const error = testResult.error.toLowerCase();
+      
+      if (error.includes('timeout') || error.includes('hang')) {
+        return 'high';
+      }
+      
+      if (error.includes('permission') || error.includes('access denied')) {
+        return 'high';
+      }
+      
+      if (error.includes('not found') || error.includes('missing')) {
+        return 'medium';
+      }
+    }
+    
+    return 'medium';
+  }
+  
+  return 'low';
+}
+
+/**
+ * Categorize test result
+ * @param {Object} testResult - Test result
+ * @returns {string} - Result category
+ */
+function categorizeResult(testResult) {
+  if (!testResult.success) {
+    if (testResult.error) {
+      const error = testResult.error.toLowerCase();
+      
+      if (error.includes('timeout')) {
+        return 'timeout-failure';
+      }
+      
+      if (error.includes('permission')) {
+        return 'permission-failure';
+      }
+      
+      if (error.includes('not found')) {
+        return 'dependency-failure';
+      }
+      
+      if (error.includes('syntax') || error.includes('parse')) {
+        return 'syntax-failure';
+      }
+    }
+    
+    return 'unknown-failure';
+  }
+  
+  return 'success';
+}
+
+/**
+ * Generate recommendations for test result
+ * @param {Object} testResult - Test result
+ * @returns {Array} - Recommendations
+ */
+function generateRecommendations(testResult) {
+  const recommendations = [];
+  
+  if (!testResult.success) {
+    if (testResult.error) {
+      const error = testResult.error.toLowerCase();
+      
+      if (error.includes('timeout')) {
+        recommendations.push({
+          type: 'performance',
+          message: 'Increase timeout or optimize test performance',
+          priority: 'medium'
+        });
+      }
+      
+      if (error.includes('permission')) {
+        recommendations.push({
+          type: 'permissions',
+          message: 'Check file permissions and access rights',
+          priority: 'high'
+        });
+      }
+      
+      if (error.includes('not found')) {
+        recommendations.push({
+          type: 'dependencies',
+          message: 'Install missing dependencies or verify paths',
+          priority: 'high'
+        });
+      }
+      
+      if (error.includes('syntax')) {
+        recommendations.push({
+          type: 'code-quality',
+          message: 'Fix syntax errors in test code',
+          priority: 'high'
+        });
+      }
+    }
+    
+    // Default recommendation
+    if (recommendations.length === 0) {
+      recommendations.push({
+        type: 'general',
+        message: 'Review test configuration and environment',
+        priority: 'medium'
+      });
+    }
+  } else {
+    // Success recommendations
+    if (testResult.duration && testResult.duration > 10000) {
+      recommendations.push({
+        type: 'performance',
+        message: 'Consider optimizing test performance',
+        priority: 'low'
+      });
+    }
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Calculate confidence score for test result
+ * @param {Object} testResult - Test result
+ * @returns {number} - Confidence score (0-100)
+ */
+function calculateConfidence(testResult) {
+  if (!testResult.success) {
+    return 0;
+  }
+  
+  let confidence = 80; // Base confidence for successful tests
+  
+  // Adjust based on test duration
+  if (testResult.duration) {
+    if (testResult.duration < 1000) {
+      confidence += 10; // Very fast test
+    } else if (testResult.duration > 30000) {
+      confidence -= 10; // Very slow test
+    }
+  }
+  
+  // Adjust based on test type
+  if (testResult.type === VerificationType.FILE_OPERATION) {
+    confidence += 5; // File operations are more reliable
+  }
+  
+  return Math.min(100, Math.max(0, confidence));
+}
+
+/**
+ * Analyze detailed test information
+ * @param {Object} testResult - Test result
+ * @returns {Object} - Detailed analysis
+ */
+function analyzeDetails(testResult) {
+  const details = {};
+  
+  if (testResult.duration) {
+    details.performance = {
+      duration: testResult.duration,
+      category: categorizePerformance(testResult.duration),
+      acceptable: testResult.duration < 30000
+    };
+  }
+  
+  if (testResult.type) {
+    details.testType = {
+      type: testResult.type,
+      reliability: getTestTypeReliability(testResult.type)
+    };
+  }
+  
+  if (testResult.error) {
+    details.error = {
+      message: testResult.error,
+      type: categorizeResult(testResult),
+      recoverable: isRecoverableError(testResult.error)
+    };
+  }
+  
+  return details;
+}
+
+/**
+ * Categorize test performance
+ * @param {number} duration - Test duration in ms
+ * @returns {string} - Performance category
+ */
+function categorizePerformance(duration) {
+  if (duration < 1000) {
+    return 'excellent';
+  } else if (duration < 5000) {
+    return 'good';
+  } else if (duration < 15000) {
+    return 'acceptable';
+  } else if (duration < 30000) {
+    return 'slow';
+  } else {
+    return 'very-slow';
+  }
+}
+
+/**
+ * Get test type reliability
+ * @param {string} testType - Test type
+ * @returns {number} - Reliability score (0-100)
+ */
+function getTestTypeReliability(testType) {
+  const reliabilityScores = {
+    [VerificationType.FILE_OPERATION]: 95,
+    [VerificationType.PROCESS_EXECUTION]: 85,
+    [VerificationType.NETWORK_CONNECTION]: 75,
+    [VerificationType.API_CALL]: 80,
+    [VerificationType.CONFIGURATION_VALIDATION]: 90
+  };
+  
+  return reliabilityScores[testType] || 70;
+}
+
+/**
+ * Check if error is recoverable
+ * @param {string} error - Error message
+ * @returns {boolean} - True if recoverable
+ */
+function isRecoverableError(error) {
+  const recoverablePatterns = [
+    'timeout',
+    'temporary',
+    'retry',
+    'connection refused',
+    'service unavailable'
+  ];
+  
+  const errorLower = error.toLowerCase();
+  return recoverablePatterns.some(pattern => errorLower.includes(pattern));
+}
+
+/**
+ * Analyze single test result
+ * @param {Object} testResult - Test result to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Object} - Analysis result
+ */
+function analyzeTestResult(testResult, options = {}) {
+  const analysis = {
+    testId: testResult.testId,
+    success: testResult.success,
+    severity: determineSeverity(testResult),
+    category: categorizeResult(testResult),
+    recommendations: generateRecommendations(testResult),
+    confidence: calculateConfidence(testResult)
+  };
+
+  // Add detailed analysis if enabled
+  if (options.detailedAnalysis) {
+    analysis.details = analyzeDetails(testResult);
+  }
+
+  return analysis;
+}
+
+module.exports = {
+  determineSeverity,
+  categorizeResult,
+  generateRecommendations,
+  calculateConfidence,
+  analyzeDetails,
+  categorizePerformance,
+  getTestTypeReliability,
+  isRecoverableError,
+  analyzeTestResult
+};

package/src/agents/windows/InstallerFactory.js

@@ -10,6 +10,7 @@ const PowerShellInstaller = require('./PowerShellInstaller');
 const NpmInstaller = require('./NpmInstaller');
 const ChocolateyInstaller = require('./ChocolateyInstaller');
 const DirectInstaller = require('./DirectInstaller');
+const VSCodeExtensionInstaller = require('./VSCodeExtensionInstaller');
 const { InstallationType } = require('../InstallationType');
 
 /**
@@ -45,6 +46,9 @@ class InstallerFactory {
       case InstallationType.DIRECT:
         return new DirectInstaller(installerConfig);
       
+      case InstallationType.VSCODE_EXTENSION:
+        return new VSCodeExtensionInstaller(installerConfig);
+      
       default:
         throw new Error(`Unknown installation type: ${type}`);
     }

package/src/agents/windows/VSCodeExtensionInstaller.js

@@ -0,0 +1,404 @@
+/**
+ * VS Code Extension Installer
+ * 
+ * Installer for VS Code extensions like GitHub Copilot.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs').promises;
+const BaseWindowsInstaller = require('./BaseWindowsInstaller');
+const { InstallationType } = require('../InstallationType');
+
+/**
+ * VS Code Extension Installer class
+ */
+class VSCodeExtensionInstaller extends BaseWindowsInstaller {
+  /**
+   * Create VS Code extension installer
+   * @param {Object} config - Installer configuration
+   */
+  constructor(config = {}) {
+    super({
+      type: InstallationType.VSCODE_EXTENSION,
+      ...config
+    });
+    
+    this.extensionId = config.extensionId || '';
+    this.config = config;
+  }
+
+  /**
+   * Check if VS Code is available
+   * @returns {Promise<boolean>} - True if VS Code is available
+   */
+  async checkPrerequisites() {
+    try {
+      if (this.logger) {
+        await this.logger.info('Checking VS Code prerequisites');
+      }
+
+      // Check if VS Code CLI is available
+      const codeCheck = await this.executeCommand('code --version', { timeout: 10000 });
+      
+      if (!codeCheck.success) {
+        if (this.logger) {
+          await this.logger.warn('VS Code CLI not found', {
+            error: codeCheck.error
+          });
+        }
+        return false;
+      }
+
+      // Parse VS Code version
+      const versionLines = codeCheck.stdout.trim().split('\n');
+      const version = versionLines[0];
+      
+      if (this.logger) {
+        await this.logger.info('VS Code found', { version });
+      }
+
+      return true;
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Prerequisite check failed', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Install VS Code extension
+   * @param {Object} agent - Agent configuration
+   * @param {Object} options - Installation options
+   * @returns {Promise<Object>} - Installation result
+   */
+  async install(agent, options = {}) {
+    const { force = false, timeout = 120000 } = options;
+    
+    if (this.logger) {
+      await this.logger.info('Starting VS Code extension installation', {
+        extensionId: this.extensionId,
+        agentId: agent.id,
+        force
+      });
+    }
+
+    try {
+      // Check prerequisites
+      const prereqCheck = await this.checkPrerequisites();
+      if (!prereqCheck) {
+        throw new Error('VS Code prerequisites not met');
+      }
+
+      // Check if extension is already installed
+      if (!force) {
+        const installed = await this.checkInstalled();
+        if (installed) {
+          if (this.logger) {
+            await this.logger.info('Extension already installed', { extensionId: this.extensionId });
+          }
+          return {
+            success: true,
+            alreadyInstalled: true,
+            message: 'Extension already installed'
+          };
+        }
+      }
+
+      // Install extension
+      const installCommand = `code --install-extension ${this.extensionId}`;
+      const installResult = await this.executeCommand(installCommand, { timeout });
+
+      if (!installResult.success) {
+        throw new Error(`Installation failed: ${installResult.error}`);
+      }
+
+      // Verify installation
+      const verificationResult = await this.verify();
+      if (!verificationResult.success) {
+        throw new Error('Installation verification failed');
+      }
+
+      if (this.logger) {
+        await this.logger.info('Extension installed successfully', { extensionId: this.extensionId });
+      }
+
+      return {
+        success: true,
+        extensionId: this.extensionId,
+        version: verificationResult.version,
+        installOutput: installResult.stdout,
+        message: 'Extension installed successfully'
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Extension installation failed', {
+          extensionId: this.extensionId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        extensionId: this.extensionId
+      };
+    }
+  }
+
+  /**
+   * Check if extension is installed
+   * @returns {Promise<boolean>} - True if installed
+   */
+  async checkInstalled() {
+    try {
+      const checkCommand = `code --list-extensions | grep "${this.extensionId}"`;
+      const result = await this.executeCommand(checkCommand, { timeout: 10000 });
+      
+      return result.success && result.stdout.includes(this.extensionId);
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.warn('Extension check failed', { error: error.message });
+      }
+      return false;
+    }
+  }
+
+  /**
+   * Verify extension installation
+   * @returns {Promise<Object>} - Verification result
+   */
+  async verify() {
+    try {
+      const verifyCommand = `code --list-extensions --show-versions | grep "${this.extensionId}"`;
+      const result = await this.executeCommand(verifyCommand, { timeout: 10000 });
+
+      if (!result.success) {
+        return {
+          success: false,
+          error: result.error
+        };
+      }
+
+      const output = result.stdout.trim();
+      if (!output.includes(this.extensionId)) {
+        return {
+          success: false,
+          error: 'Extension not found in installed extensions'
+        };
+      }
+
+      // Parse version from output
+      const parts = output.split('\t');
+      const version = parts.length > 1 ? parts[1] : 'unknown';
+
+      return {
+        success: true,
+        version,
+        extensionId: this.extensionId,
+        verificationOutput: output
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Uninstall extension
+   * @param {Object} options - Uninstall options
+   * @returns {Promise<Object>} - Uninstall result
+   */
+  async uninstall(options = {}) {
+    const { timeout = 60000 } = options;
+
+    if (this.logger) {
+      await this.logger.info('Uninstalling VS Code extension', { extensionId: this.extensionId });
+    }
+
+    try {
+      const uninstallCommand = `code --uninstall-extension ${this.extensionId}`;
+      const result = await this.executeCommand(uninstallCommand, { timeout });
+
+      if (!result.success) {
+        throw new Error(`Uninstallation failed: ${result.error}`);
+      }
+
+      if (this.logger) {
+        await this.logger.info('Extension uninstalled successfully', { extensionId: this.extensionId });
+      }
+
+      return {
+        success: true,
+        extensionId: this.extensionId,
+        message: 'Extension uninstalled successfully'
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Extension uninstallation failed', {
+          extensionId: this.extensionId,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        extensionId: this.extensionId
+      };
+    }
+  }
+
+  /**
+   * Update extension
+   * @param {Object} options - Update options
+   * @returns {Promise<Object>} - Update result
+   */
+  async update(options = {}) {
+    if (this.logger) {
+      await this.logger.info('Updating VS Code extension', { extensionId: this.extensionId });
+    }
+
+    // For VS Code extensions, update is the same as install
+    return this.install({ ...options, force: true });
+  }
+
+  /**
+   * Get extension info
+   * @returns {Promise<Object>} - Extension info
+   */
+  async getInfo() {
+    try {
+      const infoCommand = `code --list-extensions --show-versions | grep "${this.extensionId}"`;
+      const result = await this.executeCommand(infoCommand, { timeout: 10000 });
+
+      if (!result.success) {
+        return {
+          success: false,
+          error: result.error
+        };
+      }
+
+      const output = result.stdout.trim();
+      const parts = output.split('\t');
+      
+      return {
+        success: true,
+        extensionId: this.extensionId,
+        version: parts.length > 1 ? parts[1] : 'unknown',
+        publisher: parts.length > 0 ? parts[0].split('.')[0] : 'unknown',
+        name: parts.length > 0 ? parts[0].split('.')[1] : this.extensionId,
+        installed: true
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        installed: false
+      };
+    }
+  }
+
+  /**
+   * Configure extension settings
+   * @param {Object} settings - Extension settings
+   * @returns {Promise<Object>} - Configuration result
+   */
+  async configure(settings = {}) {
+    try {
+      if (this.logger) {
+        await this.logger.info('Configuring VS Code extension settings', { 
+          extensionId: this.extensionId,
+          settings: Object.keys(settings)
+        });
+      }
+
+      // Get VS Code user settings path
+      const settingsPath = this.getVSCodeSettingsPath();
+      
+      // Read current settings
+      let currentSettings = {};
+      try {
+        const settingsData = await fs.readFile(settingsPath, 'utf8');
+        currentSettings = JSON.parse(settingsData);
+      } catch (error) {
+        // File doesn't exist or is invalid, start with empty settings
+        currentSettings = {};
+      }
+
+      // Update settings
+      const updatedSettings = {
+        ...currentSettings,
+        ...settings
+      };
+
+      // Write updated settings
+      await fs.writeFile(settingsPath, JSON.stringify(updatedSettings, null, 2), 'utf8');
+
+      if (this.logger) {
+        await this.logger.info('Extension settings configured successfully');
+      }
+
+      return {
+        success: true,
+        settingsPath,
+        configuredSettings: Object.keys(settings)
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        await this.logger.error('Extension configuration failed', { error: error.message });
+      }
+
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Get VS Code settings file path
+   * @returns {string} - Settings file path
+   */
+  getVSCodeSettingsPath() {
+    const homedir = require('os').homedir();
+    
+    if (process.platform === 'win32') {
+      return path.join(homedir, 'AppData', 'Roaming', 'Code', 'User', 'settings.json');
+    } else if (process.platform === 'darwin') {
+      return path.join(homedir, 'Library', 'Application Support', 'Code', 'User', 'settings.json');
+    } else {
+      return path.join(homedir, '.config', 'Code', 'User', 'settings.json');
+    }
+  }
+
+  /**
+   * Get installer capabilities
+   * @returns {Object} - Capabilities
+   */
+  getCapabilities() {
+    return {
+      install: true,
+      uninstall: true,
+      update: true,
+      verify: true,
+      configure: true,
+      getInfo: true,
+      checkInstalled: true,
+      supportedPlatforms: ['win32', 'darwin', 'linux'],
+      requiresInternet: true,
+      requiresVSCode: true
+    };
+  }
+}
+
+module.exports = VSCodeExtensionInstaller;