vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/verification/pattern-recognizer.js

@@ -0,0 +1,369 @@
+/**
+ * Verification Result - Pattern Recognizer
+ * 
+ * Identifies patterns and risk factors in verification results.
+ */
+
+/**
+ * Identify patterns in test result
+ * @param {Object} testResult - Test result
+ * @returns {Array} - Identified patterns
+ */
+function 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 (error.includes('connection') || error.includes('network')) {
+      patterns.push('network-pattern');
+    }
+    
+    if (error.includes('syntax') || error.includes('parse')) {
+      patterns.push('syntax-pattern');
+    }
+    
+    if (error.includes('memory') || error.includes('heap')) {
+      patterns.push('memory-pattern');
+    }
+    
+    if (error.includes('disk') || error.includes('space')) {
+      patterns.push('disk-pattern');
+    }
+  }
+  
+  if (testResult.duration && testResult.duration > 30000) {
+    patterns.push('slow-performance-pattern');
+  }
+  
+  if (testResult.duration && testResult.duration < 100) {
+    patterns.push('fast-performance-pattern');
+  }
+  
+  return patterns;
+}
+
+/**
+ * Identify risk factors
+ * @param {Object} testResult - Test result
+ * @returns {Array} - Risk factors
+ */
+function identifyRiskFactors(testResult) {
+  const riskFactors = [];
+  
+  if (!testResult.success) {
+    // High risk factors
+    if (testResult.error) {
+      const error = testResult.error.toLowerCase();
+      
+      if (error.includes('permission') || error.includes('access denied')) {
+        riskFactors.push({
+          type: 'security',
+          level: 'high',
+          description: 'Permission or access issues detected',
+          impact: 'May prevent agent from functioning properly'
+        });
+      }
+      
+      if (error.includes('not found') || error.includes('missing')) {
+        riskFactors.push({
+          type: 'dependency',
+          level: 'high',
+          description: 'Missing dependencies or files',
+          impact: 'Agent may not have required components'
+        });
+      }
+      
+      if (error.includes('corrupt') || error.includes('invalid')) {
+        riskFactors.push({
+          type: 'integrity',
+          level: 'high',
+          description: 'Data corruption or invalid configuration',
+          impact: 'Agent may behave unpredictably'
+        });
+      }
+    }
+    
+    // Medium risk factors
+    if (testResult.duration && testResult.duration > 60000) {
+      riskFactors.push({
+        type: 'performance',
+        level: 'medium',
+        description: 'Extremely slow test execution',
+        impact: 'May indicate performance bottlenecks'
+      });
+    }
+    
+    if (testResult.error && testResult.error.includes('timeout')) {
+      riskFactors.push({
+        type: 'reliability',
+        level: 'medium',
+        description: 'Test timeout occurred',
+        impact: 'May indicate timing or resource issues'
+      });
+    }
+  } else {
+    // Success but with potential risks
+    if (testResult.duration && testResult.duration > 20000) {
+      riskFactors.push({
+        type: 'performance',
+        level: 'low',
+        description: 'Slow but successful test execution',
+        impact: 'May affect user experience'
+      });
+    }
+  }
+  
+  return riskFactors;
+}
+
+/**
+ * Identify patterns in batch results
+ * @param {Object} batchResult - Batch verification result
+ * @returns {Array} - Batch patterns
+ */
+function identifyBatchPatterns(batchResult) {
+  const patterns = [];
+  
+  if (!batchResult.results || batchResult.results.length === 0) {
+    return patterns;
+  }
+  
+  const results = batchResult.results;
+  const failureRate = results.filter(r => !r.success).length / results.length;
+  
+  // High failure rate pattern
+  if (failureRate > 0.5) {
+    patterns.push('high-failure-rate-pattern');
+  }
+  
+  if (failureRate > 0.2) {
+    patterns.push('moderate-failure-rate-pattern');
+  }
+  
+  // Error type patterns
+  const errorTypes = new Set();
+  results.forEach(result => {
+    if (result.error) {
+      errorTypes.add(result.error.split(':')[0]); // Get error type before details
+    }
+  });
+  
+  if (errorTypes.size > 5) {
+    patterns.push('diverse-error-types-pattern');
+  }
+  
+  // Performance patterns
+  const durations = results
+    .filter(r => r.duration)
+    .map(r => r.duration);
+  
+  if (durations.length > 0) {
+    const avgDuration = durations.reduce((sum, d) => sum + d, 0) / durations.length;
+    const maxDuration = Math.max(...durations);
+    
+    if (avgDuration > 30000) {
+      patterns.push('slow-average-performance-pattern');
+    }
+    
+    if (maxDuration > avgDuration * 3) {
+      patterns.push('performance-variance-pattern');
+    }
+  }
+  
+  // Agent-specific patterns
+  const agentIds = new Set(results.map(r => r.agentId).filter(Boolean));
+  if (agentIds.size > 0) {
+    const agentFailures = {};
+    
+    results.forEach(result => {
+      if (result.agentId && !result.success) {
+        agentFailures[result.agentId] = (agentFailures[result.agentId] || 0) + 1;
+      }
+    });
+    
+    // Check for consistently failing agents
+    Object.entries(agentFailures).forEach(([agentId, failureCount]) => {
+      const agentResults = results.filter(r => r.agentId === agentId);
+      const agentFailureRate = failureCount / agentResults.length;
+      
+      if (agentFailureRate > 0.8) {
+        patterns.push(`agent-${agentId}-consistently-failing-pattern`);
+      }
+    });
+  }
+  
+  return patterns;
+}
+
+/**
+ * Calculate risk score
+ * @param {Array} riskFactors - Risk factors
+ * @returns {number} - Risk score (0-100)
+ */
+function calculateRiskScore(riskFactors) {
+  if (!riskFactors || riskFactors.length === 0) {
+    return 0;
+  }
+  
+  let totalScore = 0;
+  
+  riskFactors.forEach(factor => {
+    let factorScore = 0;
+    
+    switch (factor.level) {
+      case 'high':
+        factorScore = 30;
+        break;
+      case 'medium':
+        factorScore = 15;
+        break;
+      case 'low':
+        factorScore = 5;
+        break;
+      default:
+        factorScore = 10;
+    }
+    
+    // Apply type weighting
+    switch (factor.type) {
+      case 'security':
+        factorScore *= 1.5;
+        break;
+      case 'dependency':
+        factorScore *= 1.3;
+        break;
+      case 'integrity':
+        factorScore *= 1.4;
+        break;
+      case 'performance':
+        factorScore *= 1.1;
+        break;
+      case 'reliability':
+        factorScore *= 1.2;
+        break;
+    }
+    
+    totalScore += factorScore;
+  });
+  
+  return Math.min(100, totalScore);
+}
+
+/**
+ * Get pattern severity
+ * @param {string} pattern - Pattern identifier
+ * @returns {string} - Severity level
+ */
+function getPatternSeverity(pattern) {
+  const severityMap = {
+    'timeout-pattern': 'medium',
+    'permission-pattern': 'high',
+    'missing-dependency-pattern': 'high',
+    'network-pattern': 'medium',
+    'syntax-pattern': 'high',
+    'memory-pattern': 'high',
+    'disk-pattern': 'medium',
+    'slow-performance-pattern': 'medium',
+    'fast-performance-pattern': 'low',
+    'high-failure-rate-pattern': 'high',
+    'moderate-failure-rate-pattern': 'medium',
+    'diverse-error-types-pattern': 'medium',
+    'slow-average-performance-pattern': 'medium',
+    'performance-variance-pattern': 'low'
+  };
+  
+  return severityMap[pattern] || 'medium';
+}
+
+/**
+ * Generate pattern-based recommendations
+ * @param {Array} patterns - Identified patterns
+ * @returns {Array} - Recommendations
+ */
+function generatePatternRecommendations(patterns) {
+  const recommendations = [];
+  
+  patterns.forEach(pattern => {
+    switch (pattern) {
+      case 'timeout-pattern':
+        recommendations.push({
+          type: 'performance',
+          message: 'Increase timeout values or optimize test execution',
+          priority: 'medium'
+        });
+        break;
+        
+      case 'permission-pattern':
+        recommendations.push({
+          type: 'security',
+          message: 'Review and fix file permissions',
+          priority: 'high'
+        });
+        break;
+        
+      case 'missing-dependency-pattern':
+        recommendations.push({
+          type: 'dependencies',
+          message: 'Install missing dependencies and verify paths',
+          priority: 'high'
+        });
+        break;
+        
+      case 'network-pattern':
+        recommendations.push({
+          type: 'network',
+          message: 'Check network connectivity and firewall settings',
+          priority: 'medium'
+        });
+        break;
+        
+      case 'syntax-pattern':
+        recommendations.push({
+          type: 'code-quality',
+          message: 'Fix syntax errors in configuration or code',
+          priority: 'high'
+        });
+        break;
+        
+      case 'slow-performance-pattern':
+        recommendations.push({
+          type: 'performance',
+          message: 'Optimize test performance and resource usage',
+          priority: 'medium'
+        });
+        break;
+        
+      case 'high-failure-rate-pattern':
+        recommendations.push({
+          type: 'reliability',
+          message: 'Investigate systematic issues causing high failure rate',
+          priority: 'high'
+        });
+        break;
+    }
+  });
+  
+  return recommendations;
+}
+
+module.exports = {
+  identifyPatterns,
+  identifyRiskFactors,
+  identifyBatchPatterns,
+  calculateRiskScore,
+  getPatternSeverity,
+  generatePatternRecommendations
+};

package/src/agents/verification/report-generator.js

@@ -0,0 +1,320 @@
+/**
+ * Report Generator
+ * 
+ * Generates analysis reports from verification results.
+ */
+
+const { determineSeverity, categorizeResult, generateRecommendations } = require('./analysis-utils');
+
+/**
+ * Report Generator class
+ */
+class ReportGenerator {
+  constructor(options = {}) {
+    this.logger = options.logger || null;
+    this.includeDetails = options.includeDetails !== false;
+    this.format = options.format || 'json'; // json, html, text
+  }
+
+  /**
+   * Generate analysis report
+   * @param {Array} testResults - Array of test results
+   * @param {Object} options - Report options
+   * @returns {Object} - Generated report
+   */
+  generateReport(testResults, options = {}) {
+    const report = {
+      metadata: this.generateMetadata(testResults, options),
+      summary: this.generateSummary(testResults),
+      details: this.includeDetails ? this.generateDetails(testResults) : null,
+      recommendations: this.generateGlobalRecommendations(testResults)
+    };
+
+    if (this.logger) {
+      this.logger.info('Generated analysis report', {
+        resultCount: testResults.length,
+        format: this.format
+      });
+    }
+
+    return report;
+  }
+
+  /**
+   * Generate report metadata
+   * @param {Array} testResults - Array of test results
+   * @param {Object} options - Report options
+   * @returns {Object} - Report metadata
+   */
+  generateMetadata(testResults, options) {
+    return {
+      generatedAt: new Date().toISOString(),
+      totalResults: testResults.length,
+      reportFormat: this.format,
+      analysisOptions: options,
+      version: '1.0.0'
+    };
+  }
+
+  /**
+   * Generate report summary
+   * @param {Array} testResults - Array of test results
+   * @returns {Object} - Report summary
+   */
+  generateSummary(testResults) {
+    const summary = {
+      totalTests: testResults.length,
+      successfulTests: 0,
+      failedTests: 0,
+      criticalIssues: 0,
+      warningIssues: 0,
+      testTypes: {},
+      severityDistribution: {
+        critical: 0,
+        error: 0,
+        warning: 0,
+        info: 0
+      }
+    };
+
+    testResults.forEach(result => {
+      // Count success/failure
+      if (result.success) {
+        summary.successfulTests++;
+      } else {
+        summary.failedTests++;
+      }
+
+      // Count severity
+      const severity = determineSeverity(result);
+      summary.severityDistribution[severity]++;
+
+      // Count critical issues
+      if (severity === 'critical') {
+        summary.criticalIssues++;
+      } else if (severity === 'warning') {
+        summary.warningIssues++;
+      }
+
+      // Count test types
+      const testType = result.testType || 'unknown';
+      summary.testTypes[testType] = (summary.testTypes[testType] || 0) + 1;
+    });
+
+    // Calculate success rate
+    summary.successRate = (summary.successfulTests / summary.totalTests * 100).toFixed(2);
+    summary.failureRate = (summary.failedTests / summary.totalTests * 100).toFixed(2);
+
+    return summary;
+  }
+
+  /**
+   * Generate detailed analysis
+   * @param {Array} testResults - Array of test results
+   * @returns {Array} - Detailed results
+   */
+  generateDetails(testResults) {
+    return testResults.map(result => ({
+      testId: result.testId,
+      testType: result.testType,
+      success: result.success,
+      severity: determineSeverity(result),
+      category: categorizeResult(result),
+      recommendations: generateRecommendations(result),
+      timestamp: result.timestamp || new Date().toISOString(),
+      duration: result.duration || 0,
+      error: result.error || null,
+      warnings: result.warnings || []
+    }));
+  }
+
+  /**
+   * Generate global recommendations
+   * @param {Array} testResults - Array of test results
+   * @returns {Array} - Global recommendations
+   */
+  generateGlobalRecommendations(testResults) {
+    const recommendations = [];
+    const issues = testResults.filter(r => !r.success);
+
+    // Analyze common failure patterns
+    const failureTypes = {};
+    issues.forEach(issue => {
+      const category = categorizeResult(issue);
+      failureTypes[category] = (failureTypes[category] || 0) + 1;
+    });
+
+    // Generate recommendations based on failure patterns
+    Object.entries(failureTypes).forEach(([category, count]) => {
+      if (count > 0) {
+        const recommendation = this.generateCategoryRecommendation(category, count);
+        if (recommendation) {
+          recommendations.push(recommendation);
+        }
+      }
+    });
+
+    // Sort by priority
+    recommendations.sort((a, b) => {
+      const priorityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+      return (priorityOrder[b.priority] || 0) - (priorityOrder[a.priority] || 0);
+    });
+
+    return recommendations;
+  }
+
+  /**
+   * Generate recommendation for a specific category
+   * @param {string} category - Failure category
+   * @param {number} count - Number of failures
+   * @returns {Object|null} - Recommendation object
+   */
+  generateCategoryRecommendation(category, count) {
+    const recommendations = {
+      installation_failure: {
+        priority: count > 2 ? 'critical' : 'high',
+        message: `${count} installation failures detected. Check system requirements and permissions.`,
+        action: 'verify_installation_requirements'
+      },
+      verification_failure: {
+        priority: 'medium',
+        message: `${count} verification failures detected. Review agent configurations.`,
+        action: 'review_agent_configurations'
+      },
+      configuration_failure: {
+        priority: 'high',
+        message: `${count} configuration failures detected. Check configuration files and parameters.`,
+        action: 'validate_configuration_files'
+      },
+      connectivity_failure: {
+        priority: 'high',
+        message: `${count} connectivity failures detected. Check network settings and firewall.`,
+        action: 'test_network_connectivity'
+      },
+      performance_failure: {
+        priority: 'medium',
+        message: `${count} performance issues detected. Optimize agent settings.`,
+        action: 'optimize_agent_performance'
+      }
+    };
+
+    return recommendations[category] || null;
+  }
+
+  /**
+   * Export report to file
+   * @param {Object} report - Report object
+   * @param {string} filePath - Output file path
+   * @returns {Promise<void>}
+   */
+  async exportToFile(report, filePath) {
+    const fs = require('fs').promises;
+    
+    try {
+      let content;
+      
+      switch (this.format) {
+        case 'json':
+          content = JSON.stringify(report, null, 2);
+          break;
+        case 'html':
+          content = this.generateHTMLReport(report);
+          break;
+        case 'text':
+          content = this.generateTextReport(report);
+          break;
+        default:
+          content = JSON.stringify(report, null, 2);
+      }
+
+      await fs.writeFile(filePath, content, 'utf8');
+      
+      if (this.logger) {
+        this.logger.info('Report exported to file', { filePath, format: this.format });
+      }
+    } catch (error) {
+      if (this.logger) {
+        this.logger.error('Failed to export report to file', {
+          filePath,
+          error: error.message
+        });
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Generate HTML report
+   * @param {Object} report - Report object
+   * @returns {string} - HTML content
+   */
+  generateHTMLReport(report) {
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Verification Analysis Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
+        .critical { color: #d32f2f; }
+        .error { color: #f57c00; }
+        .warning { color: #ff9800; }
+        .success { color: #28a745; }
+        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+        th { background-color: #f2f2f2; }
+    </style>
+</head>
+<body>
+    <h1>Verification Analysis Report</h1>
+    
+    <div class="summary">
+        <h2>Summary</h2>
+        <p>Total Tests: ${report.summary.totalTests}</p>
+        <p>Success Rate: <span class="success">${report.summary.successRate}%</span></p>
+        <p>Failure Rate: <span class="error">${report.summary.failureRate}%</span></p>
+        <p>Critical Issues: <span class="critical">${report.summary.criticalIssues}</span></p>
+        <p>Warning Issues: <span class="warning">${report.summary.warningIssues}</span></p>
+    </div>
+    
+    <h2>Global Recommendations</h2>
+    <ul>
+        ${report.recommendations.map(rec => 
+            `<li><strong>${rec.message}</strong> (Priority: ${rec.priority})</li>`
+        ).join('')}
+    </ul>
+</body>
+</html>`;
+  }
+
+  /**
+   * Generate text report
+   * @param {Object} report - Report object
+   * @returns {string} - Text content
+   */
+  generateTextReport(report) {
+    const { summary, recommendations } = report;
+    
+    return `
+VERIFICATION ANALYSIS REPORT
+Generated: ${report.metadata.generatedAt}
+
+SUMMARY:
+--------
+Total Tests: ${summary.totalTests}
+Successful Tests: ${summary.successfulTests} (${summary.successRate}%)
+Failed Tests: ${summary.failedTests} (${summary.failureRate}%)
+Critical Issues: ${summary.criticalIssues}
+Warning Issues: ${summary.warningIssues}
+
+GLOBAL RECOMMENDATIONS:
+------------------------
+${recommendations.map(rec => 
+    `- [${rec.priority.toUpperCase()}] ${rec.message}`
+).join('\n')}
+`;
+  }
+}
+
+module.exports = ReportGenerator;