vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/agents/verification/ResultAnalyzer.js

@@ -0,0 +1,707 @@
+/**
+ * Verification Result Analyzer
+ * 
+ * Analyzes and interprets verification test results.
+ * Follows constitutional requirements: <555 lines, test-first approach.
+ */
+
+const { AgentStatus } = require('../AgentStatus');
+const { VerificationType } = require('../VerificationType');
+
+/**
+ * Verification result analyzer class
+ */
+class ResultAnalyzer {
+  /**
+   * Create result analyzer instance
+   * @param {Object} options - Analyzer options
+   */
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.strictMode = options.strictMode || false;
+    this.detailedAnalysis = options.detailedAnalysis !== false;
+  }
+
+  /**
+   * Analyze single test result
+   * @param {Object} testResult - Test result to analyze
+   * @returns {Object} - Analysis result
+   */
+  analyzeTestResult(testResult) {
+    const analysis = {
+      testId: testResult.testId,
+      success: testResult.success,
+      severity: this.determineSeverity(testResult),
+      category: this.categorizeResult(testResult),
+      recommendations: this.generateRecommendations(testResult),
+      confidence: this.calculateConfidence(testResult)
+    };
+
+    // Add detailed analysis if enabled
+    if (this.detailedAnalysis) {
+      analysis.details = this.analyzeDetails(testResult);
+      analysis.patterns = this.identifyPatterns(testResult);
+      analysis.riskFactors = this.identifyRiskFactors(testResult);
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Analyze agent verification results
+   * @param {Object} verificationResult - Agent verification result
+   * @returns {Object} - Analysis result
+   */
+  analyzeAgentResult(verificationResult) {
+    const analysis = {
+      agentId: verificationResult.agentId,
+      overallSuccess: verificationResult.success,
+      status: this.determineAgentStatus(verificationResult),
+      summary: this.createSummary(verificationResult),
+      issues: this.identifyIssues(verificationResult),
+      recommendations: this.generateAgentRecommendations(verificationResult),
+      confidence: this.calculateAgentConfidence(verificationResult)
+    };
+
+    // Analyze individual test results
+    if (verificationResult.results) {
+      analysis.testAnalyses = verificationResult.results.map(testResult => 
+        this.analyzeTestResult(testResult)
+      );
+      
+      // Aggregate test analysis
+      analysis.testSummary = this.aggregateTestAnalyses(analysis.testAnalyses);
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Analyze batch verification results
+   * @param {Object} batchResult - Batch verification result
+   * @returns {Object} - Analysis result
+   */
+  analyzeBatchResult(batchResult) {
+    const analysis = {
+      batchId: batchResult.batchId || batchResult.testId,
+      overallSuccess: batchResult.success,
+      summary: this.createBatchSummary(batchResult),
+      agentAnalyses: [],
+      patterns: this.identifyBatchPatterns(batchResult),
+      recommendations: this.generateBatchRecommendations(batchResult),
+      confidence: this.calculateBatchConfidence(batchResult)
+    };
+
+    // Analyze individual agent results
+    if (batchResult.results) {
+      analysis.agentAnalyses = batchResult.results.map(agentResult => 
+        this.analyzeAgentResult(agentResult)
+      );
+      
+      // Aggregate agent analyses
+      analysis.agentSummary = this.aggregateAgentAnalyses(analysis.agentAnalyses);
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Determine result severity
+   * @param {Object} testResult - Test result
+   * @returns {string} - Severity level
+   */
+  determineSeverity(testResult) {
+    if (!testResult.success) {
+      // Determine failure severity
+      if (testResult.error) {
+        const error = testResult.error.toLowerCase();
+        
+        if (error.includes('timeout') || error.includes('network')) {
+          return 'medium';
+        } else if (error.includes('permission') || error.includes('access denied')) {
+          return 'high';
+        } else if (error.includes('not found') || error.includes('command not found')) {
+          return 'high';
+        } else {
+          return 'low';
+        }
+      }
+    }
+    
+    return 'none';
+  }
+
+  /**
+   * Categorize test result
+   * @param {Object} testResult - Test result
+   * @returns {string} - Result category
+   */
+  categorizeResult(testResult) {
+    if (!testResult.success) {
+      if (testResult.error) {
+        const error = testResult.error.toLowerCase();
+        
+        if (error.includes('timeout')) {
+          return 'timeout';
+        } else if (error.includes('permission') || error.includes('access')) {
+          return 'permission';
+        } else if (error.includes('not found') || error.includes('missing')) {
+          return 'missing';
+        } else if (error.includes('network') || error.includes('connection')) {
+          return 'network';
+        } else {
+          return 'unknown';
+        }
+      }
+    }
+    
+    return 'success';
+  }
+
+  /**
+   * Generate recommendations for test result
+   * @param {Object} testResult - Test result
+   * @returns {Array} - Recommendations
+   */
+  generateRecommendations(testResult) {
+    const recommendations = [];
+    
+    if (!testResult.success) {
+      const category = this.categorizeResult(testResult);
+      
+      switch (category) {
+        case 'timeout':
+          recommendations.push('Increase timeout value for this test');
+          recommendations.push('Check system performance and resource availability');
+          break;
+          
+        case 'permission':
+          recommendations.push('Check file/directory permissions');
+          recommendations.push('Run with appropriate user privileges');
+          break;
+          
+        case 'missing':
+          recommendations.push('Verify agent installation');
+          recommendations.push('Check command availability in PATH');
+          break;
+          
+        case 'network':
+          recommendations.push('Check network connectivity');
+          recommendations.push('Verify firewall settings');
+          break;
+          
+        default:
+          recommendations.push('Review test configuration');
+          recommendations.push('Check system logs for detailed error information');
+      }
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Calculate confidence score
+   * @param {Object} testResult - Test result
+   * @returns {number} - Confidence score (0-100)
+   */
+  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
+   */
+  analyzeDetails(testResult) {
+    const details = {};
+    
+    if (testResult.duration) {
+      details.performance = {
+        duration: testResult.duration,
+        category: this.categorizePerformance(testResult.duration),
+        acceptable: testResult.duration < 30000
+      };
+    }
+    
+    if (testResult.type) {
+      details.testType = {
+        type: testResult.type,
+        reliability: this.getTestTypeReliability(testResult.type)
+      };
+    }
+    
+    if (testResult.error) {
+      details.error = {
+        message: testResult.error,
+        type: this.categorizeResult(testResult),
+        recoverable: this.isRecoverableError(testResult.error)
+      };
+    }
+    
+    return details;
+  }
+
+  /**
+   * Identify patterns in test result
+   * @param {Object} testResult - Test result
+   * @returns {Array} - Identified patterns
+   */
+  identifyPatterns(testResult) {
+    const patterns = [];
+    
+    if (testResult.error) {
+      const error = testResult.error.toLowerCase();
+      
+      if (error.includes('timeout')) {
+        patterns.push('timeout-pattern');
+      }
+      
+      if (error.includes('permission') || error.includes('access')) {
+        patterns.push('permission-pattern');
+      }
+      
+      if (error.includes('not found')) {
+        patterns.push('missing-dependency-pattern');
+      }
+    }
+    
+    if (testResult.duration && testResult.duration > 30000) {
+      patterns.push('slow-performance-pattern');
+    }
+    
+    return patterns;
+  }
+
+  /**
+   * Identify risk factors
+   * @param {Object} testResult - Test result
+   * @returns {Array} - Risk factors
+   */
+  identifyRiskFactors(testResult) {
+    const risks = [];
+    
+    if (!testResult.success) {
+      const severity = this.determineSeverity(testResult);
+      
+      if (severity === 'high') {
+        risks.push('critical-failure-risk');
+      }
+      
+      if (this.categorizeResult(testResult) === 'permission') {
+        risks.push('security-risk');
+      }
+      
+      if (testResult.type === VerificationType.COMMAND_EXECUTION && !testResult.success) {
+        risks.push('command-execution-risk');
+      }
+    }
+    
+    return risks;
+  }
+
+  /**
+   * Determine agent status based on verification result
+   * @param {Object} verificationResult - Verification result
+   * @returns {string} - Agent status
+   */
+  determineAgentStatus(verificationResult) {
+    if (!verificationResult.success) {
+      return AgentStatus.ERROR;
+    }
+    
+    if (verificationResult.summary) {
+      if (verificationResult.summary.allPassed) {
+        return AgentStatus.VERIFIED;
+      } else if (verificationResult.summary.passed > 0) {
+        return AgentStatus.INSTALLED; // Partial success
+      }
+    }
+    
+    return AgentStatus.ERROR;
+  }
+
+  /**
+   * Create summary for agent result
+   * @param {Object} verificationResult - Verification result
+   * @returns {Object} - Summary
+   */
+  createSummary(verificationResult) {
+    const summary = {
+      agentId: verificationResult.agentId,
+      success: verificationResult.success,
+      duration: verificationResult.duration || 0
+    };
+    
+    if (verificationResult.summary) {
+      summary.tests = verificationResult.summary;
+    }
+    
+    if (verificationResult.results) {
+      summary.totalTests = verificationResult.results.length;
+      summary.passedTests = verificationResult.results.filter(r => r.success).length;
+      summary.failedTests = summary.totalTests - summary.passedTests;
+    }
+    
+    return summary;
+  }
+
+  /**
+   * Identify issues in verification result
+   * @param {Object} verificationResult - Verification result
+   * @returns {Array} - Issues
+   */
+  identifyIssues(verificationResult) {
+    const issues = [];
+    
+    if (!verificationResult.success) {
+      if (verificationResult.error) {
+        issues.push({
+          type: 'verification-failure',
+          severity: 'high',
+          message: verificationResult.error
+        });
+      }
+    }
+    
+    if (verificationResult.results) {
+      verificationResult.results.forEach((testResult, index) => {
+        if (!testResult.success) {
+          issues.push({
+            type: 'test-failure',
+            severity: this.determineSeverity(testResult),
+            testId: testResult.testId,
+            message: testResult.error || 'Test failed'
+          });
+        }
+      });
+    }
+    
+    return issues;
+  }
+
+  /**
+   * Generate recommendations for agent
+   * @param {Object} verificationResult - Verification result
+   * @returns {Array} - Recommendations
+   */
+  generateAgentRecommendations(verificationResult) {
+    const recommendations = [];
+    
+    if (!verificationResult.success) {
+      recommendations.push('Review agent installation and configuration');
+      
+      if (verificationResult.results) {
+        const failedTests = verificationResult.results.filter(r => !r.success);
+        const categories = [...new Set(failedTests.map(t => this.categorizeResult(t)))];
+        
+        categories.forEach(category => {
+          switch (category) {
+            case 'permission':
+              recommendations.push('Check file and directory permissions');
+              break;
+            case 'missing':
+              recommendations.push('Verify agent dependencies are installed');
+              break;
+            case 'timeout':
+              recommendations.push('Increase timeout values or optimize performance');
+              break;
+          }
+        });
+      }
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Calculate confidence for agent result
+   * @param {Object} verificationResult - Verification result
+   * @returns {number} - Confidence score
+   */
+  calculateAgentConfidence(verificationResult) {
+    if (!verificationResult.success || !verificationResult.results) {
+      return 0;
+    }
+    
+    const testConfidences = verificationResult.results.map(testResult => 
+      this.calculateConfidence(testResult)
+    );
+    
+    return Math.round(testConfidences.reduce((sum, conf) => sum + conf, 0) / testConfidences.length);
+  }
+
+  /**
+   * Aggregate test analyses
+   * @param {Array} testAnalyses - Test analyses
+   * @returns {Object} - Aggregated summary
+   */
+  aggregateTestAnalyses(testAnalyses) {
+    const summary = {
+      totalTests: testAnalyses.length,
+      successfulTests: testAnalyses.filter(t => t.success).length,
+      severityDistribution: {},
+      categoryDistribution: {},
+      averageConfidence: 0
+    };
+    
+    // Calculate distributions
+    testAnalyses.forEach(analysis => {
+      const severity = analysis.severity;
+      const category = analysis.category;
+      
+      summary.severityDistribution[severity] = (summary.severityDistribution[severity] || 0) + 1;
+      summary.categoryDistribution[category] = (summary.categoryDistribution[category] || 0) + 1;
+    });
+    
+    // Calculate average confidence
+    const confidences = testAnalyses.map(t => t.confidence).filter(c => c > 0);
+    if (confidences.length > 0) {
+      summary.averageConfidence = Math.round(confidences.reduce((sum, conf) => sum + conf, 0) / confidences.length);
+    }
+    
+    return summary;
+  }
+
+  /**
+   * Categorize performance
+   * @param {number} duration - Test duration in milliseconds
+   * @returns {string} - Performance category
+   */
+  categorizePerformance(duration) {
+    if (duration < 1000) return 'excellent';
+    if (duration < 5000) return 'good';
+    if (duration < 15000) return 'acceptable';
+    if (duration < 30000) return 'slow';
+    return 'very-slow';
+  }
+
+  /**
+   * Get test type reliability
+   * @param {string} testType - Test type
+   * @returns {number} - Reliability score (0-100)
+   */
+  getTestTypeReliability(testType) {
+    const reliability = {
+      [VerificationType.FILE_OPERATION]: 90,
+      [VerificationType.COMMAND_EXECUTION]: 75,
+      [VerificationType.API_CALL]: 80,
+      [VerificationType.NETWORK_TEST]: 60
+    };
+    
+    return reliability[testType] || 50;
+  }
+
+  /**
+   * Check if error is recoverable
+   * @param {string} error - Error message
+   * @returns {boolean} - Whether error is recoverable
+   */
+  isRecoverableError(error) {
+    const recoverablePatterns = [
+      'timeout',
+      'network',
+      'connection',
+      'temporary'
+    ];
+    
+    const errorLower = error.toLowerCase();
+    return recoverablePatterns.some(pattern => errorLower.includes(pattern));
+  }
+
+  /**
+   * Create batch summary
+   * @param {Object} batchResult - Batch result
+   * @returns {Object} - Batch summary
+   */
+  createBatchSummary(batchResult) {
+    const summary = {
+      totalAgents: batchResult.results ? batchResult.results.length : 0,
+      successfulAgents: 0,
+      failedAgents: 0,
+      totalDuration: batchResult.duration || 0
+    };
+    
+    if (batchResult.results) {
+      summary.successfulAgents = batchResult.results.filter(r => r.success).length;
+      summary.failedAgents = summary.totalAgents - summary.successfulAgents;
+    }
+    
+    return summary;
+  }
+
+  /**
+   * Identify batch patterns
+   * @param {Object} batchResult - Batch result
+   * @returns {Array} - Batch patterns
+   */
+  identifyBatchPatterns(batchResult) {
+    const patterns = [];
+    
+    if (batchResult.results) {
+      const failures = batchResult.results.filter(r => !r.success);
+      
+      if (failures.length > 0) {
+        // Check for common failure categories
+        const categories = failures.map(f => this.categorizeResult(f));
+        const commonCategories = categories.filter((cat, index) => categories.indexOf(cat) === index);
+        
+        if (commonCategories.length === 1) {
+          patterns.push(`consistent-${commonCategories[0]}-failures`);
+        }
+        
+        // Check for timeout patterns
+        const timeoutFailures = failures.filter(f => this.categorizeResult(f) === 'timeout');
+        if (timeoutFailures.length > failures.length / 2) {
+          patterns.push('widespread-timeout-issues');
+        }
+      }
+    }
+    
+    return patterns;
+  }
+
+  /**
+   * Generate batch recommendations
+   * @param {Object} batchResult - Batch result
+   * @returns {Array} - Recommendations
+   */
+  generateBatchRecommendations(batchResult) {
+    const recommendations = [];
+    
+    if (batchResult.results) {
+      const failures = batchResult.results.filter(r => !r.success);
+      
+      if (failures.length > 0) {
+        const patterns = this.identifyBatchPatterns(batchResult);
+        
+        patterns.forEach(pattern => {
+          if (pattern.includes('permission')) {
+            recommendations.push('Review system-wide permissions and access rights');
+          } else if (pattern.includes('timeout')) {
+            recommendations.push('Increase timeout values for batch operations');
+          } else if (pattern.includes('missing')) {
+            recommendations.push('Verify all agent dependencies are properly installed');
+          }
+        });
+        
+        if (failures.length === batchResult.results.length) {
+          recommendations.push('Review system configuration and environment');
+        }
+      }
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Calculate batch confidence
+   * @param {Object} batchResult - Batch result
+   * @returns {number} - Confidence score
+   */
+  calculateBatchConfidence(batchResult) {
+    if (!batchResult.results || batchResult.results.length === 0) {
+      return 0;
+    }
+    
+    const agentConfidences = batchResult.results.map(agentResult => 
+      this.calculateAgentConfidence(agentResult)
+    ).filter(conf => conf > 0);
+    
+    if (agentConfidences.length === 0) {
+      return 0;
+    }
+    
+    return Math.round(agentConfidences.reduce((sum, conf) => sum + conf, 0) / agentConfidences.length);
+  }
+
+  /**
+   * Aggregate agent analyses
+   * @param {Array} agentAnalyses - Agent analyses
+   * @returns {Object} - Aggregated summary
+   */
+  aggregateAgentAnalyses(agentAnalyses) {
+    const summary = {
+      totalAgents: agentAnalyses.length,
+      successfulAgents: agentAnalyses.filter(a => a.overallSuccess).length,
+      statusDistribution: {},
+      averageConfidence: 0,
+      commonIssues: []
+    };
+    
+    // Calculate status distribution
+    agentAnalyses.forEach(analysis => {
+      const status = analysis.status;
+      summary.statusDistribution[status] = (summary.statusDistribution[status] || 0) + 1;
+    });
+    
+    // Calculate average confidence
+    const confidences = agentAnalyses.map(a => a.confidence).filter(c => c > 0);
+    if (confidences.length > 0) {
+      summary.averageConfidence = Math.round(confidences.reduce((sum, conf) => sum + conf, 0) / confidences.length);
+    }
+    
+    // Identify common issues
+    const allIssues = agentAnalyses.flatMap(a => a.issues || []);
+    const issueTypes = allIssues.map(issue => issue.type);
+    const issueCounts = {};
+    
+    issueTypes.forEach(type => {
+      issueCounts[type] = (issueCounts[type] || 0) + 1;
+    });
+    
+    // Get most common issues
+    const sortedIssues = Object.entries(issueCounts)
+      .sort(([,a], [,b]) => b - a)
+      .slice(0, 3)
+      .map(([type, count]) => ({ type, count }));
+    
+    summary.commonIssues = sortedIssues;
+    
+    return summary;
+  }
+
+  /**
+   * Get analyzer information
+   * @returns {Object} - Analyzer info
+   */
+  getInfo() {
+    return {
+      name: 'Verification Result Analyzer',
+      version: '1.0.0',
+      strictMode: this.strictMode,
+      detailedAnalysis: this.detailedAnalysis,
+      features: [
+        'test result analysis',
+        'agent result analysis',
+        'batch result analysis',
+        'severity assessment',
+        'recommendation generation',
+        'pattern identification',
+        'confidence scoring'
+      ]
+    };
+  }
+}
+
+module.exports = ResultAnalyzer;