vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/validation/compliance-reporter.js

@@ -3,18 +3,21 @@
  * 
  * 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');
+const { 
+  createComplianceReport,
+  calculateComplianceMetrics,
+  generateComplianceRecommendations,
+  validateComplianceReport
+} = require('./compliance-utils');
 
 /**
- * Report generator class
+ * Report Generator class
  */
-class ComplianceReporter {
+class ReportGenerator {
   constructor(options = {}) {
     this.options = {
       outputDir: options.outputDir || './reports',
@@ -24,688 +27,372 @@ class ComplianceReporter {
       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) {
+  generateReport(data, format) {
     switch (format.toLowerCase()) {
       case 'json':
-        await this.generateJsonReport(complianceReport, filePath, options);
-        break;
+        return this.generateJSONReport(data);
       case 'html':
-        await this.generateHtmlReport(complianceReport, filePath, options);
-        break;
+        return this.generateHTMLReport(data);
       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;
+        return this.generateMarkdownReport(data);
       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`;
+        throw new Error(`Unsupported format: ${format}`);
     }
-    
-    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');
+  generateJSONReport(data) {
+    return JSON.stringify(data, null, 2);
   }
 
-  /**
-   * Generate HTML content
-   */
-  generateHtmlContent(complianceReport, options) {
-    const summary = complianceReport.summary;
-    const metrics = complianceReport.metrics;
+  generateHTMLReport(data) {
+    const { report, metrics, recommendations } = data;
     
-    let html = `
+    return `
 <!DOCTYPE html>
-<html lang="en">
+<html>
 <head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>${complianceReport.title}</title>
+    <title>Compliance Report</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; }
+        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: 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; }
+        .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>${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>
+        <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>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>
+            <h3>Compliance Rate</h3>
+            <div class="value">${metrics.complianceRate}%</div>
         </div>
         <div class="metric">
-            <h3>Critical Files</h3>
-            <div class="value critical">${summary.criticalFiles}</div>
+            <h3>Total Issues</h3>
+            <div class="value">${metrics.totalIssues}</div>
         </div>
         <div class="metric">
-            <h3>Total Issues</h3>
-            <div class="value">${summary.totalIssues}</div>
+            <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>`;
+  }
 
-    // Add metrics section if available
-    if (metrics) {
-      html += this.generateMetricsSection(metrics);
-    }
+  generateMarkdownReport(data) {
+    const { report, metrics, recommendations } = data;
+    
+    return `
+# Compliance Report
 
-    // 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>
-`;
+**Generated:** ${report.metadata.generatedAt}
 
-    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>
-`;
-    }
+## Summary
 
-    html += `
-        </tbody>
-    </table>
-`;
+- **Total Files:** ${report.metadata.totalFiles}
+- **Compliance Rate:** ${metrics.complianceRate}%
+- **Total Issues:** ${metrics.totalIssues}
+- **Files Over Limit:** ${metrics.fileMetrics ? metrics.fileMetrics.filesOverLimit : 0}
 
-    // Add recommendations
-    if (complianceReport.recommendations.length > 0) {
-      html += this.generateRecommendationsSection(complianceReport.recommendations);
-    }
+${metrics.totalIssues > 0 ? `
+## Issues
 
-    html += `
-</body>
-</html>`;
+${metrics.totalIssues} issues need to be addressed.
 
-    return html;
-  }
+` : ''}
 
-  /**
-   * Generate metrics section for HTML report
-   */
-  generateMetricsSection(metrics) {
-    let html = `
-    <h2>Metrics Analysis</h2>
-    <div class="summary">
-`;
+## Recommendations
 
-    // 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>
-`;
-    }
+${recommendations.map(rec => `
+### ${rec.title} (${rec.priority})
 
-    html += `
-    </div>
-`;
+${rec.description}
 
-    return html;
+`).join('')}
+    `.trim();
   }
+}
 
-  /**
-   * Generate recommendations section
-   */
-  generateRecommendationsSection(recommendations) {
-    let html = `
-    <div class="recommendations">
-        <h2>Recommendations</h2>
-`;
+/**
+ * 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);
+  }
 
-    for (const rec of recommendations) {
-      const priorityClass = rec.priority === 'critical' ? 'critical' : 
-                           rec.priority === 'high' ? 'violation' : 
-                           rec.priority === 'medium' ? 'warning' : 'compliant';
+  async generateReport(validationResults, options = {}) {
+    const reportOptions = { ...this.options, ...options };
+    
+    try {
+      const complianceReport = createComplianceReport(validationResults, reportOptions);
       
-      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;
-  }
+      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)
+        }
+      };
 
-  /**
-   * Get status icon
-   */
-  getStatusIcon(status) {
-    const icons = {
-      compliant: '✅',
-      warning: '⚠️',
-      violation: '❌',
-      critical: '🚨'
-    };
-    return icons[status] || '❓';
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        report: null,
+        metrics: null,
+        recommendations: null
+      };
+    }
   }
 
-  /**
-   * Get score class for styling
-   */
-  getScoreClass(score) {
-    if (score >= 90) return 'compliant';
-    if (score >= 70) return 'warning';
-    if (score >= 50) return 'violation';
-    return 'critical';
+  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;
   }
 
-  /**
-   * Generate report summary
-   */
-  generateReportSummary(complianceReport, generatedFiles) {
+  getReporterInfo() {
     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
+   * @param {Object} options - Generation options
+   * @returns {Object} - Generation result
    */
-  generateExecutiveSummary(complianceReport) {
-    const summary = complianceReport.summary;
-    const metrics = complianceReport.metrics;
+  async generateMarkdownReport(complianceReport, options) {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const filename = `compliance-report-${timestamp}.md`;
+    const filePath = path.join(options.outputDir || this.options.outputDir, filename);
+    
+    const markdownContent = this.generateMarkdownContent(complianceReport, options);
+    fs.writeFileSync(filePath, markdownContent, 'utf8');
     
     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
+      format: 'markdown',
+      filename,
+      filePath,
+      size: markdownContent.length
     };
   }
 
   /**
-   * Extract key findings
+   * Generate Markdown content
+   * @param {Object} complianceReport - Compliance report data
+   * @param {Object} options - Generation options
+   * @returns {string} - Markdown content
    */
-  extractKeyFindings(complianceReport) {
-    const findings = [];
-    const summary = complianceReport.summary;
-    
-    if (summary.criticalFiles > 0) {
-      findings.push(`${summary.criticalFiles} files have critical compliance violations`);
-    }
+  generateMarkdownContent(complianceReport, options) {
+    let markdown = `# ${complianceReport.title}\n\n`;
     
-    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%`);
-    }
+    markdown += `**Generated:** ${new Date(complianceReport.generatedAt).toLocaleString()}\n`;
+    markdown += `**Scope:** ${complianceReport.scope}\n`;
+    markdown += `**Path:** ${complianceReport.scopePath}\n\n`;
     
-    const largestFile = summary.largestFile;
-    if (largestFile && largestFile.lineCount > 800) {
-      findings.push(`Largest file has ${largestFile.lineCount} lines and requires immediate refactoring`);
+    if (complianceReport.description) {
+      markdown += `## Description\n${complianceReport.description}\n\n`;
     }
     
-    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'
-      });
+    // Summary section
+    if (complianceReport.summary) {
+      markdown += `## Executive Summary\n\n`;
+      markdown += `- **Overall Compliance:** ${complianceReport.summary.overallComplianceScore.toFixed(1)}%\n`;
+      markdown += `- **Status:** ${complianceReport.summary.overallStatus}\n`;
+      markdown += `- **Files Analyzed:** ${complianceReport.summary.totalFiles}\n`;
+      markdown += `- **Total Issues:** ${complianceReport.summary.totalIssues}\n\n`;
     }
     
-    if (complianceReport.summary.violationFiles > 0) {
-      actions.push({
-        priority: 2,
-        action: 'Refactor oversized files',
-        description: 'Reduce file sizes to comply with 555-line limit'
+    // Files section
+    if (complianceReport.files && complianceReport.files.length > 0) {
+      markdown += `## File Details\n\n`;
+      markdown += `| File | Lines | Status | Issues | Score |\n`;
+      markdown += `|------|-------|--------|--------|-------|\n`;
+      
+      complianceReport.files.forEach(file => {
+        const status = file.status || 'unknown';
+        const issues = file.issues ? file.issues.length : 0;
+        const score = file.complianceScore ? file.complianceScore.toFixed(1) + '%' : 'N/A';
+        markdown += `| ${file.filePath} | ${file.lineCount || 0} | ${status} | ${issues} | ${score} |\n`;
       });
+      
+      markdown += '\n';
     }
     
-    if (complianceReport.summary.overallComplianceScore < 90) {
-      actions.push({
-        priority: 3,
-        action: 'Improve compliance score',
-        description: 'Address violations to achieve 90%+ compliance rate'
+    // Recommendations section
+    if (complianceReport.recommendations && complianceReport.recommendations.length > 0) {
+      markdown += `## Recommendations\n\n`;
+      
+      complianceReport.recommendations.forEach((rec, index) => {
+        markdown += `### ${index + 1}. ${rec.title} (${rec.priority})\n\n`;
+        markdown += `${rec.description}\n\n`;
+        markdown += `**Action:** ${rec.action}\n\n`;
       });
     }
     
-    return actions;
+    return markdown;
   }
 
   /**
-   * Assess overall risk
+   * Generate report summary
+   * @param {Object} complianceReport - Compliance report
+   * @param {Array} generatedReports - Generated files
+   * @returns {Object} - Summary
    */
-  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');
-    }
-    
+  generateReportSummary(complianceReport, generatedReports) {
     return {
-      level: riskLevel,
-      score: score,
-      factors: riskFactors,
-      mitigation: this.getMitigationStrategies(riskLevel)
+      title: complianceReport.title,
+      generatedAt: complianceReport.generatedAt,
+      formats: generatedReports.map(r => r.format),
+      files: generatedReports.map(r => r.filename),
+      totalSize: generatedReports.reduce((sum, r) => sum + r.size, 0),
+      outputDir: this.options.outputDir
     };
   }
 
   /**
-   * Get mitigation strategies
+   * Generate comparison with previous report
+   * @param {Object} currentReport - Current compliance report
+   * @param {Object} previousReport - Previous compliance report
+   * @param {Object} options - Comparison options
+   * @returns {Object} - Comparison result
    */
-  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;
+  async generateComparison(currentReport, previousReport, options = {}) {
+    try {
+      const comparisonResult = generateComparisonReport(previousReport, currentReport, {
+        ...this.options,
+        ...options
+      });
+      
+      return {
+        success: true,
+        comparison: comparisonResult.comparison,
+        filePath: comparisonResult.filePath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
   }
 
   /**
    * Create fallback report generator
+   * @returns {Object} - Basic 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
+      generateJSON: (data, options) => this.generateJSONReport(data, options),
+      generateHTML: (data, options) => this.generateHTMLReport(data, options),
+      generateMarkdown: (data, options) => this.generateMarkdownReport(data, options)
     };
   }
 
   /**
-   * 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
+   * Get reporter information
+   * @returns {Object} - Reporter info
    */
-  calculateTrends(oldReport, newReport) {
+  getInfo() {
     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'
+      name: 'Compliance Report Generator',
+      version: '1.0.0',
+      supportedFormats: ['json', 'html', 'markdown'],
+      features: [
+        'multi-format output',
+        'metrics calculation',
+        'recommendation generation',
+        'trend analysis',
+        'comparison reports',
+        'custom styling'
+      ]
     };
   }
-
-  /**
-   * 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;