vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/verification/ResultAnalyzer.js

@@ -7,6 +7,25 @@
 
 const { AgentStatus } = require('../AgentStatus');
 const { VerificationType } = require('../VerificationType');
+const { analyzeTestResult } = require('./test-analyzer');
+const { 
+  determineAgentStatus,
+  createSummary,
+  identifyIssues,
+  generateAgentRecommendations,
+  calculateAgentConfidence,
+  createBatchSummary,
+  generateBatchRecommendations,
+  calculateBatchConfidence,
+  aggregateTestAnalyses
+} = require('./batch-analyzer');
+const { 
+  identifyPatterns,
+  identifyRiskFactors,
+  identifyBatchPatterns,
+  calculateRiskScore,
+  generatePatternRecommendations
+} = require('./pattern-recognizer');
 
 /**
  * Verification result analyzer class
@@ -28,20 +47,15 @@ class ResultAnalyzer {
    * @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)
-    };
+    const analysis = analyzeTestResult(testResult, {
+      detailedAnalysis: this.detailedAnalysis
+    });
 
     // Add detailed analysis if enabled
     if (this.detailedAnalysis) {
-      analysis.details = this.analyzeDetails(testResult);
-      analysis.patterns = this.identifyPatterns(testResult);
-      analysis.riskFactors = this.identifyRiskFactors(testResult);
+      analysis.patterns = identifyPatterns(testResult);
+      analysis.riskFactors = identifyRiskFactors(testResult);
+      analysis.riskScore = calculateRiskScore(analysis.riskFactors);
     }
 
     return analysis;
@@ -56,426 +70,11 @@ class ResultAnalyzer {
     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);
+      status: determineAgentStatus(verificationResult),
+      summary: createSummary(verificationResult),
+      issues: identifyIssues(verificationResult),
+      recommendations: generateAgentRecommendations(verificationResult),
+      confidence: calculateAgentConfidence(verificationResult)
     if (confidences.length > 0) {
       summary.averageConfidence = Math.round(confidences.reduce((sum, conf) => sum + conf, 0) / confidences.length);
     }