vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

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

@@ -0,0 +1,440 @@
+/**
+ * Verification Result - Batch Analyzer
+ * 
+ * Analyzes batch verification results and agent summaries.
+ */
+
+const { AgentStatus } = require('../AgentStatus');
+const { analyzeTestResult } = require('./test-analyzer');
+const { identifyBatchPatterns, calculateRiskScore } = require('./pattern-recognizer');
+
+/**
+ * Determine agent status from verification result
+ * @param {Object} verificationResult - Agent verification result
+ * @returns {string} - Agent status
+ */
+function determineAgentStatus(verificationResult) {
+  if (!verificationResult.success) {
+    if (verificationResult.error) {
+      const error = verificationResult.error.toLowerCase();
+      
+      if (error.includes('timeout') || error.includes('hang')) {
+        return AgentStatus.TIMEOUT;
+      }
+      
+      if (error.includes('permission') || error.includes('access')) {
+        return AgentStatus.PERMISSION_DENIED;
+      }
+      
+      if (error.includes('not found')) {
+        return AgentStatus.NOT_FOUND;
+      }
+    }
+    
+    return AgentStatus.FAILED;
+  }
+  
+  // Check individual test results
+  if (verificationResult.results) {
+    const failedTests = verificationResult.results.filter(r => !r.success);
+    const totalTests = verificationResult.results.length;
+    
+    if (failedTests.length === 0) {
+      return AgentStatus.VERIFIED;
+    }
+    
+    if (failedTests.length / totalTests > 0.5) {
+      return AgentStatus.FAILED;
+    }
+    
+    if (failedTests.length / totalTests > 0.2) {
+      return AgentStatus.WARNING;
+    }
+    
+    return AgentStatus.PARTIAL;
+  }
+  
+  return AgentStatus.VERIFIED;
+}
+
+/**
+ * Create summary for agent verification result
+ * @param {Object} verificationResult - Agent verification result
+ * @returns {Object} - Summary
+ */
+function createSummary(verificationResult) {
+  const summary = {
+    totalTests: 0,
+    passedTests: 0,
+    failedTests: 0,
+    skippedTests: 0,
+    duration: verificationResult.duration || 0,
+    timestamp: verificationResult.timestamp || new Date().toISOString()
+  };
+  
+  if (verificationResult.results) {
+    summary.totalTests = verificationResult.results.length;
+    summary.passedTests = verificationResult.results.filter(r => r.success).length;
+    summary.failedTests = verificationResult.results.filter(r => !r.success).length;
+    summary.skippedTests = verificationResult.results.filter(r => r.skipped).length;
+  }
+  
+  // Calculate success rate
+  if (summary.totalTests > 0) {
+    summary.successRate = Math.round((summary.passedTests / summary.totalTests) * 100);
+  } else {
+    summary.successRate = 0;
+  }
+  
+  return summary;
+}
+
+/**
+ * Identify issues in verification result
+ * @param {Object} verificationResult - Agent verification result
+ * @returns {Array} - Identified issues
+ */
+function identifyIssues(verificationResult) {
+  const issues = [];
+  
+  if (!verificationResult.success) {
+    issues.push({
+      type: 'verification-failure',
+      severity: 'high',
+      message: verificationResult.error || 'Unknown verification error',
+      timestamp: new Date().toISOString()
+    });
+  }
+  
+  if (verificationResult.results) {
+    verificationResult.results.forEach((result, index) => {
+      if (!result.success) {
+        issues.push({
+          type: 'test-failure',
+          severity: 'medium',
+          testId: result.testId,
+          message: result.error || 'Test failed',
+          index,
+          timestamp: result.timestamp || new Date().toISOString()
+        });
+      }
+      
+      if (result.duration && result.duration > 30000) {
+        issues.push({
+          type: 'performance-issue',
+          severity: 'low',
+          testId: result.testId,
+          message: `Test took ${result.duration}ms to execute`,
+          index,
+          timestamp: result.timestamp || new Date().toISOString()
+        });
+      }
+    });
+  }
+  
+  return issues;
+}
+
+/**
+ * Generate recommendations for agent
+ * @param {Object} verificationResult - Agent verification result
+ * @returns {Array} - Recommendations
+ */
+function generateAgentRecommendations(verificationResult) {
+  const recommendations = [];
+  
+  if (!verificationResult.success) {
+    if (verificationResult.error) {
+      const error = verificationResult.error.toLowerCase();
+      
+      if (error.includes('timeout')) {
+        recommendations.push({
+          type: 'configuration',
+          message: 'Increase timeout settings for agent verification',
+          priority: 'medium'
+        });
+      }
+      
+      if (error.includes('permission')) {
+        recommendations.push({
+          type: 'permissions',
+          message: 'Check and fix agent file permissions',
+          priority: 'high'
+        });
+      }
+      
+      if (error.includes('not found')) {
+        recommendations.push({
+          type: 'installation',
+          message: 'Verify agent installation and dependencies',
+          priority: 'high'
+        });
+      }
+    }
+  }
+  
+  if (verificationResult.results) {
+    const failedTests = verificationResult.results.filter(r => !r.success);
+    
+    if (failedTests.length > 0) {
+      // Analyze failure patterns
+      const errorTypes = new Set();
+      failedTests.forEach(test => {
+        if (test.error) {
+          errorTypes.add(test.error.split(':')[0]);
+        }
+      });
+      
+      if (errorTypes.size > 3) {
+        recommendations.push({
+          type: 'systematic',
+          message: 'Multiple different failure types detected - investigate environment',
+          priority: 'high'
+        });
+      }
+      
+      // Performance recommendations
+      const slowTests = failedTests.filter(t => t.duration && t.duration > 20000);
+      if (slowTests.length > 0) {
+        recommendations.push({
+          type: 'performance',
+          message: 'Optimize test performance and resource usage',
+          priority: 'medium'
+        });
+      }
+    }
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Calculate confidence for agent result
+ * @param {Object} verificationResult - Agent verification result
+ * @returns {number} - Confidence score (0-100)
+ */
+function calculateAgentConfidence(verificationResult) {
+  if (!verificationResult.success) {
+    return 20; // Low confidence for failed verification
+  }
+  
+  if (!verificationResult.results || verificationResult.results.length === 0) {
+    return 50; // Medium confidence for no test results
+  }
+  
+  const results = verificationResult.results;
+  const successfulTests = results.filter(r => r.success);
+  const successRate = successfulTests.length / results.length;
+  
+  // Base confidence from success rate
+  let confidence = successRate * 80;
+  
+  // Adjust for test count
+  if (results.length >= 5) {
+    confidence += 10; // More tests = higher confidence
+  } else if (results.length < 3) {
+    confidence -= 10; // Fewer tests = lower confidence
+  }
+  
+  // Adjust for performance consistency
+  const durations = results.filter(r => r.duration).map(r => r.duration);
+  if (durations.length > 1) {
+    const avgDuration = durations.reduce((sum, d) => sum + d, 0) / durations.length;
+    const variance = durations.reduce((sum, d) => sum + Math.pow(d - avgDuration, 2), 0) / durations.length;
+    const stdDev = Math.sqrt(variance);
+    
+    if (stdDev < avgDuration * 0.3) {
+      confidence += 5; // Consistent performance
+    } else if (stdDev > avgDuration) {
+      confidence -= 5; // Inconsistent performance
+    }
+  }
+  
+  return Math.min(100, Math.max(0, Math.round(confidence)));
+}
+
+/**
+ * Create summary for batch verification
+ * @param {Object} batchResult - Batch verification result
+ * @returns {Object} - Batch summary
+ */
+function createBatchSummary(batchResult) {
+  const summary = {
+    totalAgents: 0,
+    successfulAgents: 0,
+    failedAgents: 0,
+    totalTests: 0,
+    passedTests: 0,
+    failedTests: 0,
+    duration: batchResult.duration || 0,
+    timestamp: batchResult.timestamp || new Date().toISOString()
+  };
+  
+  if (batchResult.results) {
+    summary.totalAgents = batchResult.results.length;
+    summary.successfulAgents = batchResult.results.filter(r => r.success).length;
+    summary.failedAgents = batchResult.results.filter(r => !r.success).length;
+    
+    // Aggregate test counts
+    batchResult.results.forEach(agentResult => {
+      if (agentResult.results) {
+        summary.totalTests += agentResult.results.length;
+        summary.passedTests += agentResult.results.filter(t => t.success).length;
+        summary.failedTests += agentResult.results.filter(t => !t.success).length;
+      }
+    });
+  }
+  
+  // Calculate rates
+  if (summary.totalAgents > 0) {
+    summary.agentSuccessRate = Math.round((summary.successfulAgents / summary.totalAgents) * 100);
+  } else {
+    summary.agentSuccessRate = 0;
+  }
+  
+  if (summary.totalTests > 0) {
+    summary.testSuccessRate = Math.round((summary.passedTests / summary.totalTests) * 100);
+  } else {
+    summary.testSuccessRate = 0;
+  }
+  
+  return summary;
+}
+
+/**
+ * Generate recommendations for batch
+ * @param {Object} batchResult - Batch verification result
+ * @returns {Array} - Recommendations
+ */
+function generateBatchRecommendations(batchResult) {
+  const recommendations = [];
+  
+  if (!batchResult.success) {
+    recommendations.push({
+      type: 'batch-failure',
+      message: 'Batch verification failed - check system resources',
+      priority: 'high'
+    });
+  }
+  
+  if (batchResult.results) {
+    const agentFailureRate = batchResult.results.filter(r => !r.success).length / batchResult.results.length;
+    
+    if (agentFailureRate > 0.5) {
+      recommendations.push({
+        type: 'systematic',
+        message: 'High agent failure rate - investigate environment issues',
+        priority: 'high'
+      });
+    }
+    
+    if (agentFailureRate > 0.2) {
+      recommendations.push({
+        type: 'quality',
+        message: 'Review agent quality and compatibility',
+        priority: 'medium'
+      });
+    }
+    
+    // Performance recommendations
+    const slowAgents = batchResult.results.filter(r => r.duration && r.duration > 60000);
+    if (slowAgents.length > 0) {
+      recommendations.push({
+        type: 'performance',
+        message: 'Optimize verification performance for slow agents',
+        priority: 'medium'
+      });
+    }
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Calculate confidence for batch result
+ * @param {Object} batchResult - Batch verification result
+ * @returns {number} - Confidence score (0-100)
+ */
+function calculateBatchConfidence(batchResult) {
+  if (!batchResult.success) {
+    return 10; // Very low confidence for failed batch
+  }
+  
+  if (!batchResult.results || batchResult.results.length === 0) {
+    return 30; // Low confidence for empty results
+  }
+  
+  const results = batchResult.results;
+  const successfulAgents = results.filter(r => r.success);
+  const agentSuccessRate = successfulAgents.length / results.length;
+  
+  // Base confidence from agent success rate
+  let confidence = agentSuccessRate * 70;
+  
+  // Adjust for batch size
+  if (results.length >= 10) {
+    confidence += 10; // Larger batch = higher confidence
+  } else if (results.length < 5) {
+    confidence -= 10; // Smaller batch = lower confidence
+  }
+  
+  return Math.min(100, Math.max(0, Math.round(confidence)));
+}
+
+/**
+ * Aggregate test analyses
+ * @param {Array} testAnalyses - Test analysis results
+ * @returns {Object} - Aggregated analysis
+ */
+function aggregateTestAnalyses(testAnalyses) {
+  if (!testAnalyses || testAnalyses.length === 0) {
+    return {
+      totalTests: 0,
+      severityDistribution: {},
+      categoryDistribution: {},
+      averageConfidence: 0,
+      commonPatterns: [],
+      riskScore: 0
+    };
+  }
+  
+  const aggregation = {
+    totalTests: testAnalyses.length,
+    severityDistribution: {},
+    categoryDistribution: {},
+    averageConfidence: 0,
+    commonPatterns: [],
+    riskScore: 0
+  };
+  
+  // Calculate distributions
+  testAnalyses.forEach(analysis => {
+    // Severity distribution
+    const severity = analysis.severity;
+    aggregation.severityDistribution[severity] = (aggregation.severityDistribution[severity] || 0) + 1;
+    
+    // Category distribution
+    const category = analysis.category;
+    aggregation.categoryDistribution[category] = (aggregation.categoryDistribution[category] || 0) + 1;
+  });
+  
+  // Calculate average confidence
+  const confidences = testAnalyses.map(a => a.confidence).filter(c => c > 0);
+  if (confidences.length > 0) {
+    aggregation.averageConfidence = Math.round(confidences.reduce((sum, conf) => sum + conf, 0) / confidences.length);
+  }
+  
+  return aggregation;
+}
+
+module.exports = {
+  determineAgentStatus,
+  createSummary,
+  identifyIssues,
+  generateAgentRecommendations,
+  calculateAgentConfidence,
+  createBatchSummary,
+  generateBatchRecommendations,
+  calculateBatchConfidence,
+  aggregateTestAnalyses
+};