vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/verification/analysis-utils.js

@@ -0,0 +1,310 @@
+/**
+ * Analysis Utilities
+ * 
+ * Utility functions for verification result analysis.
+ */
+
+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) {
+    // Check for critical failures
+    if (testResult.error && (
+      testResult.error.includes('timeout') ||
+      testResult.error.includes('crash') ||
+      testResult.error.includes('fatal')
+    )) {
+      return 'critical';
+    }
+    
+    // Check for warning-level failures
+    if (testResult.error && (
+      testResult.error.includes('warning') ||
+      testResult.error.includes('deprecated') ||
+      testResult.error.includes('partial')
+    )) {
+      return 'warning';
+    }
+    
+    return 'error';
+  }
+  
+  return 'info';
+}
+
+/**
+ * Categorize test result
+ * @param {Object} testResult - Test result
+ * @returns {string} - Result category
+ */
+function categorizeResult(testResult) {
+  const { testType, success } = testResult;
+  
+  if (!success) {
+    switch (testType) {
+      case 'installation':
+        return 'installation_failure';
+      case 'verification':
+        return 'verification_failure';
+      case 'configuration':
+        return 'configuration_failure';
+      case 'connectivity':
+        return 'connectivity_failure';
+      case 'performance':
+        return 'performance_failure';
+      default:
+        return 'unknown_failure';
+    }
+  }
+  
+  return 'success';
+}
+
+/**
+ * Generate recommendations for test result
+ * @param {Object} testResult - Test result
+ * @returns {Array} - Array of recommendations
+ */
+function generateRecommendations(testResult) {
+  const recommendations = [];
+  const { testType, success, error } = testResult;
+  
+  if (!success) {
+    switch (testType) {
+      case 'installation':
+        recommendations.push({
+          type: 'action',
+          priority: 'high',
+          message: 'Check installation requirements and permissions',
+          action: 'verify_dependencies'
+        });
+        if (error && error.includes('permission')) {
+          recommendations.push({
+            type: 'permission',
+            priority: 'critical',
+            message: 'Run with appropriate permissions',
+            action: 'check_permissions'
+          });
+        }
+        break;
+        
+      case 'verification':
+        recommendations.push({
+          type: 'action',
+          priority: 'medium',
+          message: 'Verify agent configuration and test environment',
+          action: 'check_configuration'
+        });
+        break;
+        
+      case 'connectivity':
+        recommendations.push({
+          type: 'network',
+          priority: 'high',
+          message: 'Check network connectivity and firewall settings',
+          action: 'test_network'
+        });
+        break;
+        
+      case 'performance':
+        recommendations.push({
+          type: 'optimization',
+          priority: 'medium',
+          message: 'Optimize agent configuration for better performance',
+          action: 'optimize_settings'
+        });
+        break;
+    }
+  } else {
+    recommendations.push({
+      type: 'maintenance',
+      priority: 'low',
+      message: 'Regular monitoring recommended',
+      action: 'setup_monitoring'
+    });
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Calculate confidence score for test result
+ * @param {Object} testResult - Test result
+ * @returns {number} - Confidence score (0-1)
+ */
+function calculateConfidence(testResult) {
+  let confidence = 0.5; // Base confidence
+  
+  if (testResult.success) {
+    confidence += 0.4; // Success bonus
+  } else {
+    confidence -= 0.2; // Failure penalty
+  }
+  
+  // Adjust based on test type
+  const { testType, duration } = testResult;
+  switch (testType) {
+    case 'installation':
+      confidence += testResult.success ? 0.1 : -0.1;
+      break;
+    case 'verification':
+      confidence += testResult.success ? 0.2 : -0.1;
+      break;
+  }
+  
+  // Adjust based on duration (faster = more confident)
+  if (duration && duration < 5000) {
+    confidence += 0.1;
+  } else if (duration && duration > 30000) {
+    confidence -= 0.1;
+  }
+  
+  return Math.max(0, Math.min(1, confidence));
+}
+
+/**
+ * Analyze detailed test result information
+ * @param {Object} testResult - Test result
+ * @returns {Object} - Detailed analysis
+ */
+function analyzeDetails(testResult) {
+  const details = {
+    executionTime: testResult.duration || 0,
+    resourceUsage: testResult.resources || {},
+    environment: testResult.environment || {},
+    dependencies: testResult.dependencies || []
+  };
+  
+  // Analyze execution time
+  if (testResult.duration) {
+    details.executionTimeAnalysis = {
+      category: categorizeExecutionTime(testResult.duration),
+      withinExpectedRange: testResult.duration < 30000
+    };
+  }
+  
+  // Analyze resource usage
+  if (testResult.resources) {
+    details.resourceAnalysis = {
+      memoryUsage: testResult.resources.memory || 0,
+      cpuUsage: testResult.resources.cpu || 0,
+      diskUsage: testResult.resources.disk || 0,
+      withinLimits: true // Would need actual limits to compare
+    };
+  }
+  
+  return details;
+}
+
+/**
+ * Categorize execution time
+ * @param {number} duration - Duration in milliseconds
+ * @returns {string} - Time category
+ */
+function categorizeExecutionTime(duration) {
+  if (duration < 1000) return 'fast';
+  if (duration < 5000) return 'normal';
+  if (duration < 15000) return 'slow';
+  if (duration < 30000) return 'very_slow';
+  return 'timeout_risk';
+}
+
+/**
+ * Identify patterns in test results
+ * @param {Object} testResult - Test result
+ * @returns {Array} - Array of identified patterns
+ */
+function identifyPatterns(testResult) {
+  const patterns = [];
+  const { error, warnings } = testResult;
+  
+  // Look for common error patterns
+  if (error) {
+    if (error.includes('permission')) {
+      patterns.push({
+        type: 'permission_error',
+        frequency: 'common',
+        impact: 'high'
+      });
+    }
+    
+    if (error.includes('network') || error.includes('connection')) {
+      patterns.push({
+        type: 'network_error',
+        frequency: 'common',
+        impact: 'medium'
+      });
+    }
+    
+    if (error.includes('timeout')) {
+      patterns.push({
+        type: 'timeout_error',
+        frequency: 'occasional',
+        impact: 'medium'
+      });
+    }
+  }
+  
+  // Look for warning patterns
+  if (warnings && warnings.length > 0) {
+    patterns.push({
+      type: 'multiple_warnings',
+      frequency: warnings.length > 3 ? 'common' : 'occasional',
+      impact: 'low'
+    });
+  }
+  
+  return patterns;
+}
+
+/**
+ * Identify risk factors
+ * @param {Object} testResult - Test result
+ * @returns {Array} - Array of risk factors
+ */
+function identifyRiskFactors(testResult) {
+  const riskFactors = [];
+  const { testType, success, error, duration } = testResult;
+  
+  if (!success) {
+    riskFactors.push({
+      type: 'test_failure',
+      severity: 'high',
+      description: `Test failed: ${error || 'Unknown error'}`
+    });
+  }
+  
+  if (duration && duration > 30000) {
+    riskFactors.push({
+      type: 'timeout_risk',
+      severity: 'medium',
+      description: 'Test execution approaching timeout limit'
+    });
+  }
+  
+  if (testType === 'installation' && !success) {
+    riskFactors.push({
+      type: 'installation_failure',
+      severity: 'high',
+      description: 'Agent installation failed'
+    });
+  }
+  
+  return riskFactors;
+}
+
+module.exports = {
+  determineSeverity,
+  categorizeResult,
+  generateRecommendations,
+  calculateConfidence,
+  analyzeDetails,
+  identifyPatterns,
+  identifyRiskFactors
+};