vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/validation/comparison-analyzer.js

@@ -0,0 +1,333 @@
+/**
+ * Compliance Report - Comparison Analyzer
+ * 
+ * Analyzes and compares compliance reports over time.
+ */
+
+/**
+ * Generate comparison report between two compliance reports
+ * @param {Object} oldReport - Previous compliance report
+ * @param {Object} newReport - Current compliance report
+ * @param {Object} options - Comparison options
+ * @returns {Object} - Comparison result
+ */
+function generateComparisonReport(oldReport, newReport, options = {}) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const filePath = options.outputDir ? 
+    `${options.outputDir}/comparison-report-${timestamp}.json` :
+    `comparison-report-${timestamp}.json`;
+  
+  const comparison = {
+    metadata: {
+      generatedAt: new Date().toISOString(),
+      oldReportDate: oldReport.generatedAt,
+      newReportDate: newReport.generatedAt,
+      comparisonPeriod: calculatePeriod(oldReport.generatedAt, newReport.generatedAt)
+    },
+    summary: {
+      oldScore: oldReport.summary.overallComplianceScore,
+      newScore: newReport.summary.overallComplianceScore,
+      scoreChange: newReport.summary.overallComplianceScore - oldReport.summary.overallComplianceScore,
+      oldIssues: oldReport.summary.totalIssues,
+      newIssues: newReport.summary.totalIssues,
+      issuesChange: newReport.summary.totalIssues - oldReport.summary.totalIssues,
+      oldFiles: oldReport.summary.totalFiles,
+      newFiles: newReport.summary.totalFiles,
+      filesChange: newReport.summary.totalFiles - oldReport.summary.totalFiles
+    },
+    trends: calculateTrends(oldReport, newReport),
+    recommendations: generateComparisonRecommendations(oldReport, newReport)
+  };
+  
+  // Write comparison to file
+  const fs = require('fs');
+  const path = require('path');
+  fs.writeFileSync(filePath, JSON.stringify(comparison, null, 2), 'utf8');
+  
+  return {
+    comparison,
+    filePath
+  };
+}
+
+/**
+ * Calculate period between reports
+ * @param {string} oldDate - Old report date
+ * @param {string} newDate - New report date
+ * @returns {string} - Period description
+ */
+function calculatePeriod(oldDate, newDate) {
+  const old = new Date(oldDate);
+  const now = new Date(newDate);
+  const days = Math.floor((now - old) / (1000 * 60 * 60 * 24));
+  
+  return `${days} days`;
+}
+
+/**
+ * Calculate trends between reports
+ * @param {Object} oldReport - Previous compliance report
+ * @param {Object} newReport - Current compliance report
+ * @returns {Object} - Trend analysis
+ */
+function calculateTrends(oldReport, newReport) {
+  return {
+    complianceTrend: newReport.summary.overallComplianceScore > oldReport.summary.overallComplianceScore ? 'improving' : 'declining',
+    issueTrend: newReport.summary.totalIssues < oldReport.summary.totalIssues ? 'decreasing' : 'increasing',
+    fileTrend: newReport.summary.totalFiles > oldReport.summary.totalFiles ? 'growing' : 'stable',
+    severityTrend: calculateSeverityTrend(oldReport, newReport),
+    categoryTrend: calculateCategoryTrend(oldReport, newReport)
+  };
+}
+
+/**
+ * Calculate severity trend between reports
+ * @param {Object} oldReport - Previous compliance report
+ * @param {Object} newReport - Current compliance report
+ * @returns {Object} - Severity trend analysis
+ */
+function calculateSeverityTrend(oldReport, newReport) {
+  const oldSeverity = getSeverityDistribution(oldReport);
+  const newSeverity = getSeverityDistribution(newReport);
+  
+  const trends = {};
+  
+  Object.keys(oldSeverity).forEach(severity => {
+    const oldCount = oldSeverity[severity] || 0;
+    const newCount = newSeverity[severity] || 0;
+    
+    if (newCount > oldCount) {
+      trends[severity] = 'increasing';
+    } else if (newCount < oldCount) {
+      trends[severity] = 'decreasing';
+    } else {
+      trends[severity] = 'stable';
+    }
+  });
+  
+  return trends;
+}
+
+/**
+ * Calculate category trend between reports
+ * @param {Object} oldReport - Previous compliance report
+ * @param {Object} newReport - Current compliance report
+ * @returns {Object} - Category trend analysis
+ */
+function calculateCategoryTrend(oldReport, newReport) {
+  const oldCategories = getCategoryDistribution(oldReport);
+  const newCategories = getCategoryDistribution(newReport);
+  
+  const trends = {};
+  
+  Object.keys(oldCategories).forEach(category => {
+    const oldCount = oldCategories[category] || 0;
+    const newCount = newCategories[category] || 0;
+    
+    if (newCount > oldCount) {
+      trends[category] = 'increasing';
+    } else if (newCount < oldCount) {
+      trends[category] = 'decreasing';
+    } else {
+      trends[category] = 'stable';
+    }
+  });
+  
+  return trends;
+}
+
+/**
+ * Get severity distribution from report
+ * @param {Object} report - Compliance report
+ * @returns {Object} - Severity distribution
+ */
+function getSeverityDistribution(report) {
+  const distribution = {
+    critical: 0,
+    high: 0,
+    medium: 0,
+    low: 0
+  };
+  
+  if (report.files) {
+    report.files.forEach(file => {
+      if (file.issues) {
+        file.issues.forEach(issue => {
+          const severity = issue.severity || 'medium';
+          if (distribution[severity] !== undefined) {
+            distribution[severity]++;
+          }
+        });
+      }
+    });
+  }
+  
+  return distribution;
+}
+
+/**
+ * Get category distribution from report
+ * @param {Object} report - Compliance report
+ * @returns {Object} - Category distribution
+ */
+function getCategoryDistribution(report) {
+  const distribution = {};
+  
+  if (report.files) {
+    report.files.forEach(file => {
+      if (file.issues) {
+        file.issues.forEach(issue => {
+          const category = issue.category || 'general';
+          distribution[category] = (distribution[category] || 0) + 1;
+        });
+      }
+    });
+  }
+  
+  return distribution;
+}
+
+/**
+ * Generate comparison recommendations
+ * @param {Object} oldReport - Previous compliance report
+ * @param {Object} newReport - Current compliance report
+ * @returns {Array} - Recommendations
+ */
+function generateComparisonRecommendations(oldReport, newReport) {
+  const recommendations = [];
+  const scoreChange = newReport.summary.overallComplianceScore - oldReport.summary.overallComplianceScore;
+  
+  // Negative trends
+  if (scoreChange < -5) {
+    recommendations.push({
+      type: 'urgent',
+      title: 'Compliance Score Declining',
+      description: `Compliance score decreased by ${Math.abs(scoreChange).toFixed(1)}%`,
+      action: 'Investigate and address causes of compliance decline'
+    });
+  }
+  
+  if (newReport.summary.totalIssues > oldReport.summary.totalIssues) {
+    recommendations.push({
+      type: 'quality',
+      title: 'Increasing Issue Count',
+      description: `Total issues increased from ${oldReport.summary.totalIssues} to ${newReport.summary.totalIssues}`,
+      action: 'Review code quality and development practices'
+    });
+  }
+  
+  // Positive trends
+  if (scoreChange > 5) {
+    recommendations.push({
+      type: 'positive',
+      title: 'Compliance Improving',
+      description: `Compliance score improved by ${scoreChange.toFixed(1)}%`,
+      action: 'Continue current compliance practices'
+    });
+  }
+  
+  if (newReport.summary.totalIssues < oldReport.summary.totalIssues) {
+    recommendations.push({
+      type: 'positive',
+      title: 'Issues Decreasing',
+      description: `Total issues decreased from ${oldReport.summary.totalIssues} to ${newReport.summary.totalIssues}`,
+      action: 'Maintain focus on code quality and compliance'
+    });
+  }
+  
+  // Stability recommendations
+  if (Math.abs(scoreChange) < 1) {
+    recommendations.push({
+      type: 'monitoring',
+      title: 'Compliance Stable',
+      description: 'Compliance score has remained stable',
+      action: 'Continue monitoring and consider continuous integration improvements'
+    });
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Generate trend summary
+ * @param {Object} trends - Trend analysis
+ * @returns {string} - Trend summary
+ */
+function generateTrendSummary(trends) {
+  const positive = [];
+  const negative = [];
+  
+  Object.entries(trends).forEach(([key, trend]) => {
+    if (trend === 'improving' || trend === 'decreasing') {
+      positive.push(key);
+    } else if (trend === 'declining' || trend === 'increasing') {
+      negative.push(key);
+    }
+  });
+  
+  let summary = 'Trends show ';
+  
+  if (positive.length > 0 && negative.length > 0) {
+    summary += `mixed results with improvements in ${positive.join(', ')} but concerns in ${negative.join(', ')}`;
+  } else if (positive.length > 0) {
+    summary += `positive trends in ${positive.join(', ')}`;
+  } else if (negative.length > 0) {
+    summary += `concerning trends in ${negative.join(', ')}`;
+  } else {
+    summary += 'stable conditions across all metrics';
+  }
+  
+  return summary;
+}
+
+/**
+ * Calculate compliance velocity
+ * @param {Array} reports - Array of compliance reports
+ * @returns {Object} - Velocity metrics
+ */
+function calculateComplianceVelocity(reports) {
+  if (reports.length < 2) {
+    return {
+      averageScoreChange: 0,
+      averageIssueChange: 0,
+      velocity: 'insufficient-data'
+    };
+  }
+  
+  let totalScoreChange = 0;
+  let totalIssueChange = 0;
+  
+  for (let i = 1; i < reports.length; i++) {
+    const scoreChange = reports[i].summary.overallComplianceScore - reports[i-1].summary.overallComplianceScore;
+    const issueChange = reports[i].summary.totalIssues - reports[i-1].summary.totalIssues;
+    
+    totalScoreChange += scoreChange;
+    totalIssueChange += issueChange;
+  }
+  
+  const periods = reports.length - 1;
+  const averageScoreChange = totalScoreChange / periods;
+  const averageIssueChange = totalIssueChange / periods;
+  
+  let velocity = 'stable';
+  if (averageScoreChange > 2) velocity = 'improving';
+  else if (averageScoreChange < -2) velocity = 'declining';
+  
+  return {
+    averageScoreChange,
+    averageIssueChange,
+    velocity,
+    periods
+  };
+}
+
+module.exports = {
+  generateComparisonReport,
+  calculatePeriod,
+  calculateTrends,
+  calculateSeverityTrend,
+  calculateCategoryTrend,
+  generateComparisonRecommendations,
+  generateTrendSummary,
+  calculateComplianceVelocity
+};

package/src/validation/compliance-reporter-new.js

@@ -0,0 +1,282 @@
+/**
+ * Compliance Report Generator
+ * 
+ * Generates comprehensive compliance reports in various formats,
+ * integrating validation results, metrics, and recommendations.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ComplianceReport, FileComplianceSummary, ComplianceIssue } = require('../models/compliance-report');
+const MetricsCalculator = require('./metrics-calculator');
+const { 
+  createComplianceReport,
+  calculateComplianceMetrics,
+  generateComplianceRecommendations,
+  validateComplianceReport
+} = require('./compliance-utils');
+
+/**
+ * Report Generator class
+ */
+class ReportGenerator {
+  constructor(options = {}) {
+    this.options = {
+      outputDir: options.outputDir || './reports',
+      formats: options.formats || ['json', 'html', 'markdown'],
+      includeMetrics: options.includeMetrics !== false,
+      includeRecommendations: options.includeRecommendations !== false,
+      includeCharts: options.includeCharts !== false,
+      ...options
+    };
+  }
+
+  generateReport(data, format) {
+    switch (format.toLowerCase()) {
+      case 'json':
+        return this.generateJSONReport(data);
+      case 'html':
+        return this.generateHTMLReport(data);
+      case 'markdown':
+        return this.generateMarkdownReport(data);
+      default:
+        throw new Error(`Unsupported format: ${format}`);
+    }
+  }
+
+  generateJSONReport(data) {
+    return JSON.stringify(data, null, 2);
+  }
+
+  generateHTMLReport(data) {
+    const { report, metrics, recommendations } = data;
+    
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Compliance Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        .header { background: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
+        .summary { display: flex; gap: 20px; margin-bottom: 20px; }
+        .metric { background: #e9ecef; padding: 15px; border-radius: 5px; flex: 1; }
+        .metric h3 { margin: 0 0 10px 0; color: #333; }
+        .metric .value { font-size: 24px; font-weight: bold; color: #007bff; }
+        .issues { background: #fff3cd; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
+        .recommendations { background: #d4edda; padding: 15px; border-radius: 5px; }
+        .recommendation { margin-bottom: 10px; padding: 10px; background: white; border-radius: 3px; }
+        .high { border-left: 4px solid #dc3545; }
+        .medium { border-left: 4px solid #ffc107; }
+        .low { border-left: 4px solid #28a745; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>Compliance Report</h1>
+        <p>Generated: ${report.metadata.generatedAt}</p>
+        <p>Total Files: ${report.metadata.totalFiles}</p>
+    </div>
+    
+    <div class="summary">
+        <div class="metric">
+            <h3>Compliance Rate</h3>
+            <div class="value">${metrics.complianceRate}%</div>
+        </div>
+        <div class="metric">
+            <h3>Total Issues</h3>
+            <div class="value">${metrics.totalIssues}</div>
+        </div>
+        <div class="metric">
+            <h3>Files Over Limit</h3>
+            <div class="value">${metrics.fileMetrics ? metrics.fileMetrics.filesOverLimit : 0}</div>
+        </div>
+    </div>
+    
+    ${metrics.totalIssues > 0 ? `
+    <div class="issues">
+        <h2>Issues Found</h2>
+        <p>${metrics.totalIssues} issues need to be addressed</p>
+    </div>
+    ` : ''}
+    
+    <div class="recommendations">
+        <h2>Recommendations</h2>
+        ${recommendations.map(rec => `
+            <div class="recommendation ${rec.priority}">
+                <strong>${rec.title}</strong>
+                <p>${rec.description}</p>
+            </div>
+        `).join('')}
+    </div>
+</body>
+</html>`;
+  }
+
+  generateMarkdownReport(data) {
+    const { report, metrics, recommendations } = data;
+    
+    return `
+# Compliance Report
+
+**Generated:** ${report.metadata.generatedAt}
+
+## Summary
+
+- **Total Files:** ${report.metadata.totalFiles}
+- **Compliance Rate:** ${metrics.complianceRate}%
+- **Total Issues:** ${metrics.totalIssues}
+- **Files Over Limit:** ${metrics.fileMetrics ? metrics.fileMetrics.filesOverLimit : 0}
+
+${metrics.totalIssues > 0 ? `
+## Issues
+
+${metrics.totalIssues} issues need to be addressed.
+
+` : ''}
+
+## Recommendations
+
+${recommendations.map(rec => `
+### ${rec.title} (${rec.priority})
+
+${rec.description}
+
+`).join('')}
+    `.trim();
+  }
+}
+
+/**
+ * Compliance Reporter class
+ */
+class ComplianceReporter {
+  constructor(options = {}) {
+    this.options = {
+      outputDir: options.outputDir || './reports',
+      formats: options.formats || ['json', 'html', 'markdown'],
+      includeMetrics: options.includeMetrics !== false,
+      includeRecommendations: options.includeRecommendations !== false,
+      includeCharts: options.includeCharts !== false,
+      ...options
+    };
+    
+    this.metricsCalculator = new MetricsCalculator();
+    this.reportGenerator = new ReportGenerator(this.options);
+  }
+
+  async generateReport(validationResults, options = {}) {
+    const reportOptions = { ...this.options, ...options };
+    
+    try {
+      const complianceReport = createComplianceReport(validationResults, reportOptions);
+      
+      let metrics = null;
+      if (reportOptions.includeMetrics) {
+        metrics = calculateComplianceMetrics(complianceReport);
+      }
+      
+      let recommendations = null;
+      if (reportOptions.includeRecommendations) {
+        recommendations = generateComplianceRecommendations(complianceReport);
+      }
+      
+      const reportData = {
+        report: complianceReport,
+        metrics,
+        recommendations
+      };
+      
+      const generatedReports = await this.generateReportsInFormats(reportData, reportOptions);
+      
+      return {
+        success: true,
+        report: complianceReport,
+        metrics,
+        recommendations,
+        generatedReports,
+        summary: {
+          totalFiles: validationResults.length,
+          complianceRate: metrics ? metrics.complianceRate : 0,
+          totalIssues: metrics ? metrics.totalIssues : 0,
+          formats: Object.keys(generatedReports)
+        }
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        report: null,
+        metrics: null,
+        recommendations: null
+      };
+    }
+  }
+
+  async generateReportsInFormats(reportData, options) {
+    const reports = {};
+    const formats = options.formats || ['json'];
+    
+    await fs.promises.mkdir(this.options.outputDir, { recursive: true });
+    
+    for (const format of formats) {
+      try {
+        const content = this.reportGenerator.generateReport(reportData, format);
+        const filename = `compliance-report.${format}`;
+        const filepath = path.join(this.options.outputDir, filename);
+        
+        await fs.promises.writeFile(filepath, content, 'utf8');
+        reports[format] = {
+          success: true,
+          filepath,
+          size: content.length
+        };
+      } catch (error) {
+        reports[format] = {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+    
+    return reports;
+  }
+
+  getReporterInfo() {
+    return {
+      supportedFormats: ['json', 'html', 'markdown'],
+      defaultOptions: this.options,
+      features: [
+        'multi-format output',
+        'metrics calculation',
+        'recommendations generation',
+        'compliance validation'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new ComplianceReporter({
+      outputDir: './reports',
+      formats: ['json', 'html'],
+      includeMetrics: true,
+      includeRecommendations: true,
+      ...config
+    });
+  }
+
+  static createForCI(config = {}) {
+    return new ComplianceReporter({
+      outputDir: './compliance-reports',
+      formats: ['json', 'markdown'],
+      includeMetrics: true,
+      includeRecommendations: true,
+      includeCharts: false,
+      ...config
+    });
+  }
+}
+
+module.exports = ComplianceReporter;