vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/validation/compliance-reporter.js

@@ -0,0 +1,711 @@
+/**
+ * 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 ReportGenerator = require('../utils/report-generator');
+
+/**
+ * Report generator 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 = ReportGenerator || this.createFallbackReportGenerator();
+  }
+
+  /**
+   * Generate comprehensive compliance report
+   */
+  async generateReport(validationResults, options = {}) {
+    const reportOptions = { ...this.options, ...options };
+    
+    try {
+      // Create compliance report
+      const complianceReport = this.createComplianceReport(validationResults, reportOptions);
+      
+      // Calculate metrics if enabled
+      if (reportOptions.includeMetrics) {
+        complianceReport.metrics = this.metricsCalculator.calculateMetrics(complianceReport);
+      }
+      
+      // Generate reports in requested formats
+      const generatedReports = await this.generateReportsInFormats(complianceReport, reportOptions);
+      
+      return {
+        report: complianceReport,
+        files: generatedReports,
+        summary: this.generateReportSummary(complianceReport, generatedReports)
+      };
+      
+    } catch (error) {
+      throw new Error(`Failed to generate compliance report: ${error.message}`);
+    }
+  }
+
+  /**
+   * Create compliance report from validation results
+   */
+  createComplianceReport(validationResults, options) {
+    const report = new ComplianceReport({
+      title: options.title || 'Codebase Compliance Report',
+      description: options.description || 'Comprehensive analysis of codebase compliance with constitutional requirements',
+      scope: options.scope || 'full',
+      scopePath: options.scopePath || process.cwd(),
+      generatedAt: new Date().toISOString()
+    });
+
+    // Process validation results
+    for (const validationResult of validationResults) {
+      const fileSummary = this.createFileSummary(validationResult);
+      report.addFileSummary(fileSummary);
+    }
+
+    return report;
+  }
+
+  /**
+   * Create file summary from validation result
+   */
+  createFileSummary(validationResult) {
+    const fileSummary = new FileComplianceSummary({
+      filePath: validationResult.filePath,
+      lineCount: validationResult.lineCount || 0,
+      fileSize: validationResult.fileSize || 0
+    });
+
+    // Add issues from validation result
+    if (validationResult.issues) {
+      for (const issue of validationResult.issues) {
+        fileSummary.addIssue(new ComplianceIssue({
+          filePath: validationResult.filePath,
+          ...issue
+        }));
+      }
+    }
+
+    // Add line limit violations
+    if (validationResult.lineLimitViolation) {
+      fileSummary.addIssue(new ComplianceIssue({
+        filePath: validationResult.filePath,
+        category: 'file_size',
+        severity: validationResult.lineLimitViolation.severity || 'error',
+        rule: 'file_size_limit',
+        message: validationResult.lineLimitViolation.message,
+        description: `File exceeds 555-line limit with ${validationResult.lineCount} lines`,
+        suggestion: 'Refactor file into smaller modules',
+        lineNumber: null
+      }));
+    }
+
+    return fileSummary;
+  }
+
+  /**
+   * Generate reports in multiple formats
+   */
+  async generateReportsInFormats(complianceReport, options) {
+    const generatedFiles = [];
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const baseName = `compliance-report-${timestamp}`;
+
+    // Ensure output directory exists
+    if (!fs.existsSync(options.outputDir)) {
+      fs.mkdirSync(options.outputDir, { recursive: true });
+    }
+
+    for (const format of options.formats) {
+      try {
+        const fileName = `${baseName}.${format}`;
+        const filePath = path.join(options.outputDir, fileName);
+        
+        await this.generateReportInFormat(complianceReport, format, filePath, options);
+        
+        generatedFiles.push({
+          format,
+          fileName,
+          filePath,
+          size: fs.statSync(filePath).size
+        });
+        
+      } catch (error) {
+        console.warn(`Failed to generate ${format} report: ${error.message}`);
+      }
+    }
+
+    return generatedFiles;
+  }
+
+  /**
+   * Generate report in specific format
+   */
+  async generateReportInFormat(complianceReport, format, filePath, options) {
+    switch (format.toLowerCase()) {
+      case 'json':
+        await this.generateJsonReport(complianceReport, filePath, options);
+        break;
+      case 'html':
+        await this.generateHtmlReport(complianceReport, filePath, options);
+        break;
+      case 'markdown':
+        await this.generateMarkdownReport(complianceReport, filePath, options);
+        break;
+      case 'csv':
+        await this.generateCsvReport(complianceReport, filePath, options);
+        break;
+      case 'pdf':
+        await this.generatePdfReport(complianceReport, filePath, options);
+        break;
+      default:
+        throw new Error(`Unsupported report format: ${format}`);
+    }
+  }
+
+  /**
+   * Generate JSON report
+   */
+  async generateJsonReport(complianceReport, filePath, options) {
+    const reportData = {
+      metadata: {
+        generatedAt: complianceReport.generatedAt,
+        generator: 'ComplianceReporter',
+        version: '1.0.0',
+        options: options
+      },
+      report: complianceReport.toJSON()
+    };
+
+    fs.writeFileSync(filePath, JSON.stringify(reportData, null, 2), 'utf8');
+  }
+
+  /**
+   * Generate HTML report
+   */
+  async generateHtmlReport(complianceReport, filePath, options) {
+    const html = this.generateHtmlContent(complianceReport, options);
+    fs.writeFileSync(filePath, html, 'utf8');
+  }
+
+  /**
+   * Generate Markdown report
+   */
+  async generateMarkdownReport(complianceReport, filePath, options) {
+    const markdown = complianceReport.generateDetailedReport();
+    fs.writeFileSync(filePath, markdown, 'utf8');
+  }
+
+  /**
+   * Generate CSV report
+   */
+  async generateCsvReport(complianceReport, filePath, options) {
+    let csv = 'File Path,Line Count,Status,Compliance Score,Total Issues,Critical Issues,Violation Issues,Warning Issues\n';
+    
+    for (const fileSummary of complianceReport.fileSummaries) {
+      csv += `"${fileSummary.filePath}",${fileSummary.lineCount},${fileSummary.status},${fileSummary.complianceScore},${fileSummary.totalIssues},${fileSummary.criticalIssues},${fileSummary.violationIssues},${fileSummary.warningIssues}\n`;
+    }
+    
+    fs.writeFileSync(filePath, csv, 'utf8');
+  }
+
+  /**
+   * Generate PDF report (placeholder implementation)
+   */
+  async generatePdfReport(complianceReport, filePath, options) {
+    // This would typically use a PDF generation library
+    // For now, generate a text file as placeholder
+    const text = complianceReport.generateDetailedReport();
+    fs.writeFileSync(filePath.replace('.pdf', '.txt'), text, 'utf8');
+  }
+
+  /**
+   * Generate HTML content
+   */
+  generateHtmlContent(complianceReport, options) {
+    const summary = complianceReport.summary;
+    const metrics = complianceReport.metrics;
+    
+    let html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${complianceReport.title}</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; line-height: 1.6; }
+        .header { background: #f4f4f4; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
+        .summary { display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 20px; margin-bottom: 30px; }
+        .metric { background: #f9f9f9; padding: 15px; border-radius: 5px; text-align: center; }
+        .metric h3 { margin: 0 0 10px 0; color: #333; }
+        .metric .value { font-size: 2em; font-weight: bold; margin: 10px 0; }
+        .compliant { color: #28a745; }
+        .warning { color: #ffc107; }
+        .violation { color: #dc3545; }
+        .critical { color: #6f42c1; }
+        table { width: 100%; border-collapse: collapse; margin-bottom: 20px; }
+        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
+        th { background: #f4f4f4; }
+        .status-icon { margin-right: 5px; }
+        .recommendations { background: #e7f3ff; padding: 15px; border-radius: 5px; margin-top: 20px; }
+        .chart { margin: 20px 0; text-align: center; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>${complianceReport.title}</h1>
+        <p><strong>Generated:</strong> ${new Date(complianceReport.generatedAt).toLocaleString()}</p>
+        <p><strong>Scope:</strong> ${complianceReport.scope} (${complianceReport.scopePath})</p>
+        <p><strong>Overall Compliance Score:</strong> <span class="value ${this.getScoreClass(summary.overallComplianceScore)}">${summary.overallComplianceScore.toFixed(1)}%</span></p>
+    </div>
+
+    <div class="summary">
+        <div class="metric">
+            <h3>Total Files</h3>
+            <div class="value">${summary.totalFiles}</div>
+        </div>
+        <div class="metric">
+            <h3>Compliant Files</h3>
+            <div class="value compliant">${summary.compliantFiles}</div>
+        </div>
+        <div class="metric">
+            <h3>Warning Files</h3>
+            <div class="value warning">${summary.warningFiles}</div>
+        </div>
+        <div class="metric">
+            <h3>Violation Files</h3>
+            <div class="value violation">${summary.violationFiles}</div>
+        </div>
+        <div class="metric">
+            <h3>Critical Files</h3>
+            <div class="value critical">${summary.criticalFiles}</div>
+        </div>
+        <div class="metric">
+            <h3>Total Issues</h3>
+            <div class="value">${summary.totalIssues}</div>
+        </div>
+    </div>
+`;
+
+    // Add metrics section if available
+    if (metrics) {
+      html += this.generateMetricsSection(metrics);
+    }
+
+    // Add file details table
+    html += `
+    <h2>File Details</h2>
+    <table>
+        <thead>
+            <tr>
+                <th>File</th>
+                <th>Lines</th>
+                <th>Status</th>
+                <th>Score</th>
+                <th>Issues</th>
+                <th>Details</th>
+            </tr>
+        </thead>
+        <tbody>
+`;
+
+    for (const fileSummary of complianceReport.fileSummaries.sort((a, b) => b.lineCount - a.lineCount)) {
+      const statusIcon = this.getStatusIcon(fileSummary.status);
+      const statusClass = this.getScoreClass(fileSummary.complianceScore);
+      
+      html += `
+            <tr>
+                <td><code>${fileSummary.filePath}</code></td>
+                <td>${fileSummary.lineCount}</td>
+                <td><span class="status-icon">${statusIcon}</span>${fileSummary.status}</td>
+                <td><span class="${statusClass}">${fileSummary.complianceScore.toFixed(1)}%</span></td>
+                <td>${fileSummary.totalIssues}</td>
+                <td>
+                    ${fileSummary.criticalIssues > 0 ? `${fileSummary.criticalIssues} critical` : ''}
+                    ${fileSummary.violationIssues > 0 ? `${fileSummary.violationIssues} violations` : ''}
+                    ${fileSummary.warningIssues > 0 ? `${fileSummary.warningIssues} warnings` : ''}
+                </td>
+            </tr>
+`;
+    }
+
+    html += `
+        </tbody>
+    </table>
+`;
+
+    // Add recommendations
+    if (complianceReport.recommendations.length > 0) {
+      html += this.generateRecommendationsSection(complianceReport.recommendations);
+    }
+
+    html += `
+</body>
+</html>`;
+
+    return html;
+  }
+
+  /**
+   * Generate metrics section for HTML report
+   */
+  generateMetricsSection(metrics) {
+    let html = `
+    <h2>Metrics Analysis</h2>
+    <div class="summary">
+`;
+
+    // Overview metrics
+    if (metrics.overview) {
+      html += `
+        <div class="metric">
+            <h3>Compliance Rate</h3>
+            <div class="value ${this.getScoreClass(metrics.overview.complianceRate)}">${metrics.overview.complianceRate.toFixed(1)}%</div>
+        </div>
+        <div class="metric">
+            <h3>Health Status</h3>
+            <div class="value">${metrics.overview.healthStatus}</div>
+        </div>
+        <div class="metric">
+            <h3>Avg Issues/File</h3>
+            <div class="value">${metrics.overview.averageIssuesPerFile.toFixed(1)}</div>
+        </div>
+`;
+    }
+
+    html += `
+    </div>
+`;
+
+    return html;
+  }
+
+  /**
+   * Generate recommendations section
+   */
+  generateRecommendationsSection(recommendations) {
+    let html = `
+    <div class="recommendations">
+        <h2>Recommendations</h2>
+`;
+
+    for (const rec of recommendations) {
+      const priorityClass = rec.priority === 'critical' ? 'critical' : 
+                           rec.priority === 'high' ? 'violation' : 
+                           rec.priority === 'medium' ? 'warning' : 'compliant';
+      
+      html += `
+        <div style="margin-bottom: 15px;">
+            <h3><span class="${priorityClass}">${rec.title}</span> (${rec.priority})</h3>
+            <p>${rec.description}</p>
+            <p><strong>Action:</strong> ${rec.action}</p>
+        </div>
+`;
+    }
+
+    html += `
+    </div>
+`;
+
+    return html;
+  }
+
+  /**
+   * Get status icon
+   */
+  getStatusIcon(status) {
+    const icons = {
+      compliant: '✅',
+      warning: '⚠️',
+      violation: '❌',
+      critical: '🚨'
+    };
+    return icons[status] || '❓';
+  }
+
+  /**
+   * Get score class for styling
+   */
+  getScoreClass(score) {
+    if (score >= 90) return 'compliant';
+    if (score >= 70) return 'warning';
+    if (score >= 50) return 'violation';
+    return 'critical';
+  }
+
+  /**
+   * Generate report summary
+   */
+  generateReportSummary(complianceReport, generatedFiles) {
+    return {
+      reportId: complianceReport.id,
+      generatedAt: complianceReport.generatedAt,
+      totalFiles: complianceReport.summary.totalFiles,
+      overallComplianceScore: complianceReport.summary.overallComplianceScore,
+      totalIssues: complianceReport.summary.totalIssues,
+      generatedFiles: generatedFiles.map(f => ({
+        format: f.format,
+        fileName: f.fileName,
+        size: f.size
+      })),
+      healthStatus: this.metricsCalculator.getHealthStatus(complianceReport.summary.overallComplianceScore)
+    };
+  }
+
+  /**
+   * Generate executive summary
+   */
+  generateExecutiveSummary(complianceReport) {
+    const summary = complianceReport.summary;
+    const metrics = complianceReport.metrics;
+    
+    return {
+      overview: {
+        totalFiles: summary.totalFiles,
+        complianceScore: summary.overallComplianceScore,
+        healthStatus: metrics?.overview?.healthStatus || 'unknown',
+        totalIssues: summary.totalIssues
+      },
+      keyFindings: this.extractKeyFindings(complianceReport),
+      priorityActions: this.extractPriorityActions(complianceReport),
+      riskAssessment: this.assessOverallRisk(complianceReport),
+      recommendations: complianceReport.recommendations.slice(0, 5) // Top 5 recommendations
+    };
+  }
+
+  /**
+   * Extract key findings
+   */
+  extractKeyFindings(complianceReport) {
+    const findings = [];
+    const summary = complianceReport.summary;
+    
+    if (summary.criticalFiles > 0) {
+      findings.push(`${summary.criticalFiles} files have critical compliance violations`);
+    }
+    
+    if (summary.violationFiles > 0) {
+      findings.push(`${summary.violationFiles} files exceed the 555-line limit`);
+    }
+    
+    if (summary.overallComplianceScore < 80) {
+      findings.push(`Overall compliance score is ${summary.overallComplianceScore.toFixed(1)}%, below target of 90%`);
+    }
+    
+    const largestFile = summary.largestFile;
+    if (largestFile && largestFile.lineCount > 800) {
+      findings.push(`Largest file has ${largestFile.lineCount} lines and requires immediate refactoring`);
+    }
+    
+    return findings;
+  }
+
+  /**
+   * Extract priority actions
+   */
+  extractPriorityActions(complianceReport) {
+    const actions = [];
+    
+    if (complianceReport.summary.criticalFiles > 0) {
+      actions.push({
+        priority: 1,
+        action: 'Address critical violations',
+        description: 'Fix all critical compliance issues immediately'
+      });
+    }
+    
+    if (complianceReport.summary.violationFiles > 0) {
+      actions.push({
+        priority: 2,
+        action: 'Refactor oversized files',
+        description: 'Reduce file sizes to comply with 555-line limit'
+      });
+    }
+    
+    if (complianceReport.summary.overallComplianceScore < 90) {
+      actions.push({
+        priority: 3,
+        action: 'Improve compliance score',
+        description: 'Address violations to achieve 90%+ compliance rate'
+      });
+    }
+    
+    return actions;
+  }
+
+  /**
+   * Assess overall risk
+   */
+  assessOverallRisk(complianceReport) {
+    const score = complianceReport.summary.overallComplianceScore;
+    const criticalFiles = complianceReport.summary.criticalFiles;
+    const violationFiles = complianceReport.summary.violationFiles;
+    
+    let riskLevel = 'low';
+    let riskFactors = [];
+    
+    if (criticalFiles > 0) {
+      riskLevel = 'critical';
+      riskFactors.push(`${criticalFiles} critical files`);
+    } else if (violationFiles > 0) {
+      riskLevel = 'high';
+      riskFactors.push(`${violationFiles} files with violations`);
+    } else if (score < 80) {
+      riskLevel = 'medium';
+      riskFactors.push('Low compliance score');
+    }
+    
+    return {
+      level: riskLevel,
+      score: score,
+      factors: riskFactors,
+      mitigation: this.getMitigationStrategies(riskLevel)
+    };
+  }
+
+  /**
+   * Get mitigation strategies
+   */
+  getMitigationStrategies(riskLevel) {
+    const strategies = {
+      critical: [
+        'Immediately address all critical violations',
+        'Implement daily compliance monitoring',
+        'Establish mandatory code review for large files'
+      ],
+      high: [
+        'Refactor all files exceeding size limits',
+        'Implement pre-commit hooks for validation',
+        'Schedule regular compliance reviews'
+      ],
+      medium: [
+        'Monitor files approaching size limits',
+        'Provide developer training on compliance',
+        'Implement automated compliance checks'
+      ],
+      low: [
+        'Maintain current compliance practices',
+        'Continue regular monitoring',
+        'Focus on prevention'
+      ]
+    };
+    
+    return strategies[riskLevel] || strategies.low;
+  }
+
+  /**
+   * Create fallback report generator
+   */
+  createFallbackReportGenerator() {
+    return {
+      generateReport: (data, format) => {
+        switch (format) {
+          case 'json':
+            return JSON.stringify(data, null, 2);
+          case 'text':
+            return JSON.stringify(data, null, 2);
+          default:
+            return JSON.stringify(data, null, 2);
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate comparison report (comparing two reports)
+   */
+  async generateComparisonReport(oldReport, newReport, options = {}) {
+    const comparison = {
+      metadata: {
+        generatedAt: new Date().toISOString(),
+        oldReportId: oldReport.id,
+        newReportId: newReport.id,
+        comparisonPeriod: this.calculatePeriod(oldReport.generatedAt, newReport.generatedAt)
+      },
+      changes: {
+        filesAdded: newReport.summary.totalFiles - oldReport.summary.totalFiles,
+        filesRemoved: 0, // Would need more complex logic to calculate
+        complianceScoreChange: newReport.summary.overallComplianceScore - oldReport.summary.overallComplianceScore,
+        issuesChange: newReport.summary.totalIssues - oldReport.summary.totalFiles
+      },
+      trends: this.calculateTrends(oldReport, newReport),
+      recommendations: this.generateComparisonRecommendations(oldReport, newReport)
+    };
+
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filePath = path.join(options.outputDir || './reports', `comparison-report-${timestamp}.json`);
+    
+    fs.writeFileSync(filePath, JSON.stringify(comparison, null, 2), 'utf8');
+    
+    return {
+      comparison,
+      filePath
+    };
+  }
+
+  /**
+   * Calculate period between reports
+   */
+  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
+   */
+  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'
+    };
+  }
+
+  /**
+   * Generate comparison recommendations
+   */
+  generateComparisonRecommendations(oldReport, newReport) {
+    const recommendations = [];
+    const scoreChange = newReport.summary.overallComplianceScore - oldReport.summary.overallComplianceScore;
+    
+    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 (scoreChange > 5) {
+      recommendations.push({
+        type: 'positive',
+        title: 'Compliance Improving',
+        description: `Compliance score improved by ${scoreChange.toFixed(1)}%`,
+        action: 'Continue current compliance practices'
+      });
+    }
+    
+    return recommendations;
+  }
+}
+
+module.exports = ComplianceReporter;