vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/agents/discovery/history-manager.js

@@ -0,0 +1,310 @@
+/**
+ * Agent Discovery - History Manager
+ * 
+ * Manages discovery history and status tracking.
+ */
+
+/**
+ * Record discovery operation in history
+ * @param {string} operation - Operation type
+ * @param {Object} details - Operation details
+ * @param {Object} fileManager - File manager instance
+ * @param {Object} logger - Logger instance
+ */
+async function recordDiscoveryOperation(operation, details, fileManager, logger) {
+  const historyEntry = {
+    timestamp: new Date().toISOString(),
+    operation,
+    ...details
+  };
+
+  let history = [];
+  if (fileManager) {
+    try {
+      const historyData = await fileManager.readFile('discovery-history');
+      history = JSON.parse(historyData || '[]');
+    } catch (error) {
+      // File doesn't exist yet, start with empty history
+    }
+  }
+
+  history.push(historyEntry);
+
+  // Keep only last 100 entries
+  if (history.length > 100) {
+    history = history.slice(-100);
+  }
+
+  if (fileManager) {
+    await fileManager.writeFile('discovery-history', JSON.stringify(history, null, 2));
+  }
+
+  if (logger) {
+    logger.info('Discovery operation recorded', {
+      operation,
+      details
+    });
+  }
+}
+
+/**
+ * Get discovery status
+ * @param {Object} fileManager - File manager instance
+ * @returns {Promise<Object>} - Discovery status
+ */
+async function getDiscoveryStatus(fileManager) {
+  try {
+    if (fileManager) {
+      const statusData = await fileManager.readFile('discovery-status');
+      return {
+        success: true,
+        status: JSON.parse(statusData || '{}')
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: 'Discovery status file not found'
+    };
+  }
+}
+
+/**
+ * Get discovery history
+ * @param {Object} fileManager - File manager instance
+ * @returns {Promise<Object>} - Discovery history
+ */
+async function getDiscoveryHistory(fileManager) {
+  try {
+    if (fileManager) {
+      const historyData = await fileManager.readFile('discovery-history');
+      return {
+        success: true,
+        history: JSON.parse(historyData || '[]')
+      };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: 'Discovery history file not found'
+    };
+  }
+}
+
+/**
+ * Update discovery status
+ * @param {Array} validAgents - Valid agents
+ * @param {number} totalDiscovered - Total discovered count
+ * @param {number} duplicateCount - Duplicate count
+ * @param {Array} warnings - Warnings array
+ * @param {Array} errors - Errors array
+ * @param {Object} fileManager - File manager instance
+ * @param {Object} logger - Logger instance
+ */
+async function updateDiscoveryStatus(validAgents, totalDiscovered, duplicateCount, warnings, errors, fileManager, logger) {
+  const status = {
+    lastDiscovery: new Date().toISOString(),
+    totalDiscovered,
+    validAgents: validAgents.length,
+    duplicates: duplicateCount,
+    warnings: warnings.length,
+    errors: errors.length,
+    agents: validAgents.map(agent => ({
+      id: agent.id,
+      name: agent.name,
+      type: agent.type,
+      version: agent.version,
+      path: agent.path
+    }))
+  };
+
+  if (fileManager) {
+    await fileManager.writeFile('discovery-status', JSON.stringify(status, null, 2));
+  }
+
+  if (logger) {
+    logger.info('Discovery status updated', {
+      totalDiscovered,
+      validAgents: validAgents.length,
+      duplicates: duplicateCount
+    });
+  }
+}
+
+/**
+ * Clear discovery history
+ * @param {Object} fileManager - File manager instance
+ * @param {Object} logger - Logger instance
+ */
+async function clearDiscoveryHistory(fileManager, logger) {
+  try {
+    if (fileManager) {
+      await fileManager.writeFile('discovery-history', '[]');
+    }
+
+    if (logger) {
+      logger.info('Discovery history cleared');
+    }
+
+    return {
+      success: true,
+      message: 'Discovery history cleared successfully'
+    };
+  } catch (error) {
+    if (logger) {
+      logger.error('Failed to clear discovery history', {
+        error: error.message
+      });
+    }
+
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Get discovery statistics
+ * @param {Object} fileManager - File manager instance
+ * @returns {Promise<Object>} - Discovery statistics
+ */
+async function getDiscoveryStatistics(fileManager) {
+  try {
+    const historyResult = await getDiscoveryHistory(fileManager);
+    const statusResult = await getDiscoveryStatus(fileManager);
+
+    if (!historyResult.success || !statusResult.success) {
+      return {
+        success: false,
+        error: 'Failed to retrieve discovery data'
+      };
+    }
+
+    const history = historyResult.history;
+    const status = statusResult.status;
+
+    // Calculate statistics
+    const stats = {
+      totalOperations: history.length,
+      lastDiscovery: status.lastDiscovery,
+      totalAgentsDiscovered: status.totalDiscovered || 0,
+      validAgents: status.validAgents || 0,
+      duplicateRate: status.totalDiscovered > 0 ? 
+        ((status.duplicates || 0) / status.totalDiscovered * 100).toFixed(2) + '%' : '0%',
+      agentTypes: {},
+      recentOperations: history.slice(-10).reverse()
+    };
+
+    // Count agent types
+    if (status.agents) {
+      for (const agent of status.agents) {
+        stats.agentTypes[agent.type] = (stats.agentTypes[agent.type] || 0) + 1;
+      }
+    }
+
+    // Calculate operation frequency
+    const operationCounts = {};
+    for (const operation of history) {
+      operationCounts[operation.operation] = (operationCounts[operation.operation] || 0) + 1;
+    }
+    stats.operationFrequency = operationCounts;
+
+    return {
+      success: true,
+      statistics: stats
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Export discovery data
+ * @param {Object} fileManager - File manager instance
+ * @param {string} format - Export format ('json' or 'csv')
+ * @returns {Promise<Object>} - Export result
+ */
+async function exportDiscoveryData(fileManager, format = 'json') {
+  try {
+    const historyResult = await getDiscoveryHistory(fileManager);
+    const statusResult = await getDiscoveryStatus(fileManager);
+
+    if (!historyResult.success || !statusResult.success) {
+      return {
+        success: false,
+        error: 'Failed to retrieve discovery data for export'
+      };
+    }
+
+    const exportData = {
+      exportedAt: new Date().toISOString(),
+      format,
+      status: statusResult.status,
+      history: historyResult.history
+    };
+
+    let content;
+    let filename;
+
+    if (format === 'csv') {
+      content = convertToCSV(exportData);
+      filename = `discovery-export-${Date.now()}.csv`;
+    } else {
+      content = JSON.stringify(exportData, null, 2);
+      filename = `discovery-export-${Date.now()}.json`;
+    }
+
+    if (fileManager) {
+      await fileManager.writeFile(filename, content);
+    }
+
+    return {
+      success: true,
+      filename,
+      format,
+      size: content.length
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Convert discovery data to CSV format
+ * @param {Object} data - Discovery data
+ * @returns {string} - CSV content
+ */
+function convertToCSV(data) {
+  const headers = ['timestamp', 'operation', 'agentId', 'agentName', 'details'];
+  const rows = [headers.join(',')];
+
+  for (const entry of data.history) {
+    const row = [
+      entry.timestamp || '',
+      entry.operation || '',
+      entry.agentId || '',
+      entry.agentName || '',
+      JSON.stringify(entry.details || {})
+    ];
+    rows.push(row.join(','));
+  }
+
+  return rows.join('\n');
+}
+
+module.exports = {
+  recordDiscoveryOperation,
+  getDiscoveryStatus,
+  getDiscoveryHistory,
+  updateDiscoveryStatus,
+  clearDiscoveryHistory,
+  getDiscoveryStatistics,
+  exportDiscoveryData
+};

package/src/agents/verification/ResultAnalyzer-refactored.js

@@ -0,0 +1,341 @@
+/**
+ * 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');
+const { 
+  determineSeverity, 
+  categorizeResult, 
+  generateRecommendations,
+  calculateConfidence,
+  analyzeDetails,
+  identifyPatterns,
+  identifyRiskFactors
+} = require('./analysis-utils');
+const ReportGenerator = require('./report-generator');
+
+/**
+ * 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;
+    this.reportGenerator = new ReportGenerator({
+      logger: this.logger,
+      includeDetails: this.detailedAnalysis,
+      format: options.reportFormat || 'json'
+    });
+  }
+
+  /**
+   * 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: determineSeverity(testResult),
+      category: categorizeResult(testResult),
+      recommendations: generateRecommendations(testResult),
+      confidence: calculateConfidence(testResult)
+    };
+
+    // Add detailed analysis if enabled
+    if (this.detailedAnalysis) {
+      analysis.details = analyzeDetails(testResult);
+      analysis.patterns = identifyPatterns(testResult);
+      analysis.riskFactors = identifyRiskFactors(testResult);
+    }
+
+    return analysis;
+  }
+
+  /**
+   * Analyze multiple test results
+   * @param {Array} testResults - Array of test results
+   * @returns {Object} - Batch analysis result
+   */
+  analyzeBatchResults(testResults) {
+    const startTime = Date.now();
+    
+    try {
+      if (this.logger) {
+        this.logger.info('Starting batch result analysis', {
+          resultCount: testResults.length,
+          strictMode: this.strictMode
+        });
+      }
+
+      const individualAnalyses = testResults.map(result => 
+        this.analyzeTestResult(result)
+      );
+
+      const batchAnalysis = {
+        metadata: {
+          analyzedAt: new Date().toISOString(),
+          totalResults: testResults.length,
+          analysisDuration: 0,
+          strictMode: this.strictMode
+        },
+        summary: this.generateBatchSummary(individualAnalyses),
+        individualResults: individualAnalyses,
+        recommendations: this.generateBatchRecommendations(individualAnalyses)
+      };
+
+      batchAnalysis.metadata.analysisDuration = Date.now() - startTime;
+
+      if (this.logger) {
+        this.logger.info('Batch analysis completed', {
+          duration: batchAnalysis.metadata.analysisDuration,
+          criticalIssues: batchAnalysis.summary.criticalIssues,
+          successRate: batchAnalysis.summary.successRate
+        });
+      }
+
+      return batchAnalysis;
+
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      
+      if (this.logger) {
+        this.logger.error('Batch analysis failed', {
+          error: error.message,
+          duration
+        });
+      }
+
+      return {
+        metadata: {
+          analyzedAt: new Date().toISOString(),
+          totalResults: testResults.length,
+          analysisDuration: duration,
+          strictMode: this.strictMode,
+          error: error.message
+        },
+        error: error.message,
+        success: false
+      };
+    }
+  }
+
+  /**
+   * Generate batch analysis summary
+   * @param {Array} analyses - Array of individual analyses
+   * @returns {Object} - Batch summary
+   */
+  generateBatchSummary(analyses) {
+    const summary = {
+      totalTests: analyses.length,
+      successfulTests: 0,
+      failedTests: 0,
+      criticalIssues: 0,
+      warningIssues: 0,
+      testTypes: {},
+      severityDistribution: {
+        critical: 0,
+        error: 0,
+        warning: 0,
+        info: 0
+      },
+      averageConfidence: 0
+    };
+
+    let totalConfidence = 0;
+
+    analyses.forEach(analysis => {
+      // Count success/failure
+      if (analysis.success) {
+        summary.successfulTests++;
+      } else {
+        summary.failedTests++;
+      }
+
+      // Count severity
+      summary.severityDistribution[analysis.severity]++;
+
+      // Count critical issues
+      if (analysis.severity === 'critical') {
+        summary.criticalIssues++;
+      } else if (analysis.severity === 'warning') {
+        summary.warningIssues++;
+      }
+
+      // Count test types
+      const testType = analysis.testId ? analysis.testId.split('-')[0] : 'unknown';
+      summary.testTypes[testType] = (summary.testTypes[testType] || 0) + 1;
+
+      // Accumulate confidence
+      totalConfidence += analysis.confidence;
+    });
+
+    // Calculate averages and rates
+    summary.averageConfidence = analyses.length > 0 ? (totalConfidence / analyses.length).toFixed(3) : 0;
+    summary.successRate = analyses.length > 0 ? (summary.successfulTests / analyses.length * 100).toFixed(2) : 0;
+    summary.failureRate = analyses.length > 0 ? (summary.failedTests / analyses.length * 100).toFixed(2) : 0;
+
+    return summary;
+  }
+
+  /**
+   * Generate batch recommendations
+   * @param {Array} analyses - Array of individual analyses
+   * @returns {Array} - Batch recommendations
+   */
+  generateBatchRecommendations(analyses) {
+    const recommendations = [];
+    const failedAnalyses = analyses.filter(a => !a.success);
+
+    // Analyze common failure patterns
+    const failureCategories = {};
+    failedAnalyses.forEach(analysis => {
+      const category = analysis.category;
+      failureCategories[category] = (failureCategories[category] || 0) + 1;
+    });
+
+    // Generate recommendations based on failure patterns
+    Object.entries(failureCategories).forEach(([category, count]) => {
+      if (count > 0) {
+        const priority = count > 3 ? 'critical' : count > 1 ? 'high' : 'medium';
+        recommendations.push({
+          type: 'action',
+          priority,
+          category,
+          count,
+          message: `${count} ${category.replace('_', ' ')} failures detected`,
+          action: `address_${category}_issues`
+        });
+      }
+    });
+
+    // Add confidence-based recommendations
+    const lowConfidenceAnalyses = analyses.filter(a => a.confidence < 0.5);
+    if (lowConfidenceAnalyses.length > 0) {
+      recommendations.push({
+        type: 'quality',
+        priority: 'medium',
+        message: `${lowConfidenceAnalyses.length} tests with low confidence detected`,
+        action: 'improve_test_reliability'
+      });
+    }
+
+    // Sort by priority and relevance
+    recommendations.sort((a, b) => {
+      const priorityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
+      const scoreA = (priorityOrder[a.priority] || 0) + (a.count || 0);
+      const scoreB = (priorityOrder[b.priority] || 0) + (b.count || 0);
+      return scoreB - scoreA;
+    });
+
+    return recommendations.slice(0, 10); // Limit to top 10 recommendations
+  }
+
+  /**
+   * Generate and export analysis report
+   * @param {Array} testResults - Array of test results
+   * @param {string} outputPath - Output file path
+   * @returns {Promise<Object>} - Analysis result and export status
+   */
+  async generateAndExportReport(testResults, outputPath) {
+    try {
+      const analysis = this.analyzeBatchResults(testResults);
+      const report = this.reportGenerator.generateReport(testResults, {
+        analyzerOptions: {
+          strictMode: this.strictMode,
+          detailedAnalysis: this.detailedAnalysis
+        }
+      });
+
+      await this.reportGenerator.exportToFile(report, outputPath);
+
+      return {
+        success: true,
+        analysis,
+        reportPath: outputPath,
+        summary: analysis.summary
+      };
+
+    } catch (error) {
+      if (this.logger) {
+        this.logger.error('Failed to generate and export report', {
+          outputPath,
+          error: error.message
+        });
+      }
+
+      return {
+        success: false,
+        error: error.message,
+        outputPath
+      };
+    }
+  }
+
+  /**
+   * Get analyzer information
+   * @returns {Object} - Analyzer info
+   */
+  getAnalyzerInfo() {
+    return {
+      strictMode: this.strictMode,
+      detailedAnalysis: this.detailedAnalysis,
+      reportFormat: this.reportGenerator.format,
+      features: [
+        'individual test analysis',
+        'batch analysis',
+        'severity assessment',
+        'recommendation generation',
+        'pattern identification',
+        'risk assessment',
+        'report generation'
+      ],
+      capabilities: [
+        'multi-format reports',
+        'confidence scoring',
+        'trend analysis',
+        'batch processing'
+      ]
+    };
+  }
+
+  /**
+   * Create analyzer with default configuration
+   * @param {Object} config - Configuration overrides
+   * @returns {ResultAnalyzer} - Analyzer instance
+   */
+  static createDefault(config = {}) {
+    return new ResultAnalyzer({
+      strictMode: false,
+      detailedAnalysis: true,
+      reportFormat: 'json',
+      ...config
+    });
+  }
+
+  /**
+   * Create analyzer for strict analysis
+   * @param {Object} config - Configuration overrides
+   * @returns {ResultAnalyzer} - Strict analyzer instance
+   */
+  static createStrict(config = {}) {
+    return new ResultAnalyzer({
+      strictMode: true,
+      detailedAnalysis: true,
+      reportFormat: 'json',
+      ...config
+    });
+  }
+}
+
+module.exports = ResultAnalyzer;