vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/validation/compliance-report-generator.js

@@ -0,0 +1,343 @@
+/**
+ * Compliance Report Generator
+ * 
+ * Generates comprehensive compliance reports with metrics and analysis.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getComplianceSummary } = require('./constitution-validator');
+
+/**
+ * Compliance Report Generator
+ */
+class ComplianceReportGenerator {
+  constructor(options = {}) {
+    this.options = {
+      outputPath: options.outputPath || './compliance-report.json',
+      format: options.format || 'json', // json, markdown, html
+      includeDetails: options.includeDetails !== false,
+      includeRecommendations: options.includeRecommendations !== false,
+      ...options
+    };
+  }
+
+  /**
+   * Generate compliance report from validation results
+   */
+  generateReport(validationResults, options = {}) {
+    const config = { ...this.options, ...options };
+    const summary = getComplianceSummary(validationResults);
+    
+    const report = {
+      metadata: this._generateMetadata(),
+      summary: this._enhanceSummary(summary),
+      analysis: this._generateAnalysis(validationResults, summary),
+      recommendations: this._generateRecommendations(summary),
+      details: config.includeDetails ? this._generateDetails(validationResults) : undefined
+    };
+
+    return report;
+  }
+
+  /**
+   * Save report to file
+   */
+  async saveReport(report, outputPath) {
+    const filePath = outputPath || this.options.outputPath;
+    
+    try {
+      let content;
+      
+      switch (this.options.format) {
+        case 'json':
+          content = JSON.stringify(report, null, 2);
+          break;
+          
+        case 'markdown':
+          content = this._generateMarkdownReport(report);
+          break;
+          
+        case 'html':
+          content = this._generateHtmlReport(report);
+          break;
+          
+        default:
+          throw new Error(`Unsupported format: ${this.options.format}`);
+      }
+      
+      await fs.promises.writeFile(filePath, content, 'utf8');
+      return filePath;
+      
+    } catch (error) {
+      throw new Error(`Failed to save report: ${error.message}`);
+    }
+  }
+
+  /**
+   * Generate report metadata
+   */
+  _generateMetadata() {
+    return {
+      generatedAt: new Date().toISOString(),
+      generator: 'Vibe Coding Machine - Compliance Report Generator',
+      version: '1.0.0',
+      projectRoot: process.cwd(),
+      nodeVersion: process.version,
+      platform: process.platform
+    };
+  }
+
+  /**
+   * Enhance summary with additional metrics
+   */
+  _enhanceSummary(summary) {
+    return {
+      ...summary,
+      complianceRate: summary.totalFiles > 0 ? (summary.compliantFiles / summary.totalFiles * 100).toFixed(2) : 0,
+      averageIssuesPerFile: summary.nonCompliantFiles > 0 ? (summary.totalIssues / summary.nonCompliantFiles).toFixed(2) : 0,
+      criticalIssues: summary.issuesBySeverity.error || 0,
+      warningIssues: summary.issuesBySeverity.warning || 0,
+      infoIssues: summary.issuesBySeverity.info || 0
+    };
+  }
+
+  /**
+   * Generate analysis section
+   */
+  _generateAnalysis(validationResults, summary) {
+    const analysis = {
+      topIssues: this._getTopIssues(validationResults),
+      fileTypes: this._analyzeFileTypes(validationResults),
+      severityDistribution: summary.issuesBySeverity,
+      categoryDistribution: summary.issuesByCategory,
+      trends: this._generateTrends(validationResults)
+    };
+
+    return analysis;
+  }
+
+  /**
+   * Generate recommendations
+   */
+  _generateRecommendations(summary) {
+    const recommendations = [];
+
+    if (summary.criticalIssues > 0) {
+      recommendations.push({
+        priority: 'high',
+        category: 'critical',
+        title: 'Address Critical Issues',
+        description: `Fix ${summary.criticalIssues} critical issue(s) that prevent compliance`,
+        action: 'Review and fix all error-level issues'
+      });
+    }
+
+    if (summary.complianceRate < 90) {
+      recommendations.push({
+        priority: 'medium',
+        category: 'compliance',
+        title: 'Improve Overall Compliance',
+        description: `Current compliance rate is ${summary.complianceRate}%, target is 90%+`,
+        action: 'Focus on fixing warning-level issues to improve compliance'
+      });
+    }
+
+    if (summary.issuesByCategory.file_size > 0) {
+      recommendations.push({
+        priority: 'high',
+        category: 'file_size',
+        title: 'Reduce File Sizes',
+        description: `${summary.issuesByCategory.file_size} files exceed the 555-line limit`,
+        action: 'Refactor large files into smaller, focused modules'
+      });
+    }
+
+    if (summary.issuesByCategory.code_structure > 5) {
+      recommendations.push({
+        priority: 'medium',
+        category: 'code_structure',
+        title: 'Improve Code Structure',
+        description: `Found ${summary.issuesByCategory.code_structure} code structure issues`,
+        action: 'Review coding standards and apply consistent formatting'
+      });
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Generate detailed issues list
+   */
+  _generateDetails(validationResults) {
+    const details = [];
+    
+    for (const [filePath, issues] of validationResults) {
+      if (issues.length > 0) {
+        details.push({
+          file: filePath,
+          issueCount: issues.length,
+          issues: issues.map(issue => ({
+            rule: issue.rule,
+            severity: issue.severity,
+            category: issue.category,
+            message: issue.message,
+            line: issue.line,
+            column: issue.column
+          }))
+        });
+      }
+    }
+    
+    return details.sort((a, b) => b.issueCount - a.issueCount);
+  }
+
+  /**
+   * Get top issues by frequency
+   */
+  _getTopIssues(validationResults) {
+    const issueCounts = {};
+    
+    for (const [filePath, issues] of validationResults) {
+      for (const issue of issues) {
+        const key = `${issue.rule}:${issue.category}`;
+        issueCounts[key] = (issueCounts[key] || 0) + 1;
+      }
+    }
+    
+    return Object.entries(issueCounts)
+      .map(([key, count]) => {
+        const [rule, category] = key.split(':');
+        return { rule, category, count };
+      })
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 10);
+  }
+
+  /**
+   * Analyze file types
+   */
+  _analyzeFileTypes(validationResults) {
+    const typeStats = {};
+    
+    for (const [filePath, issues] of validationResults) {
+      const ext = path.extname(filePath);
+      if (!typeStats[ext]) {
+        typeStats[ext] = { files: 0, issues: 0, compliant: 0 };
+      }
+      
+      typeStats[ext].files++;
+      typeStats[ext].issues += issues.length;
+      if (issues.length === 0) {
+        typeStats[ext].compliant++;
+      }
+    }
+    
+    return typeStats;
+  }
+
+  /**
+   * Generate trends (placeholder for future enhancement)
+   */
+  _generateTrends(validationResults) {
+    return {
+      note: 'Trend analysis requires historical data',
+      suggestion: 'Run compliance checks regularly to track trends over time'
+    };
+  }
+
+  /**
+   * Generate markdown report
+   */
+  _generateMarkdownReport(report) {
+    const sections = [];
+    
+    sections.push('# Compliance Report');
+    sections.push(`Generated: ${new Date(report.metadata.generatedAt).toLocaleString()}`);
+    sections.push('');
+    
+    // Summary
+    sections.push('## Summary');
+    sections.push(`- Total Files: ${report.summary.totalFiles}`);
+    sections.push(`- Compliant Files: ${report.summary.compliantFiles}`);
+    sections.push(`- Non-Compliant Files: ${report.summary.nonCompliantFiles}`);
+    sections.push(`- Compliance Rate: ${report.summary.complianceRate}%`);
+    sections.push(`- Total Issues: ${report.summary.totalIssues}`);
+    sections.push('');
+    
+    // Recommendations
+    if (report.recommendations.length > 0) {
+      sections.push('## Recommendations');
+      report.recommendations.forEach(rec => {
+        sections.push(`### ${rec.title} (${rec.priority})`);
+        sections.push(`${rec.description}`);
+        sections.push(`**Action:** ${rec.action}`);
+        sections.push('');
+      });
+    }
+    
+    // Top Issues
+    if (report.analysis.topIssues.length > 0) {
+      sections.push('## Top Issues');
+      report.analysis.topIssues.forEach((issue, index) => {
+        sections.push(`${index + 1}. **${issue.rule}** (${issue.category}): ${issue.count} occurrences`);
+      });
+      sections.push('');
+    }
+    
+    return sections.join('\n');
+  }
+
+  /**
+   * Generate HTML report
+   */
+  _generateHtmlReport(report) {
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Compliance Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; }
+        .recommendation { margin: 10px 0; padding: 10px; border-left: 4px solid #007cba; }
+        .high-priority { border-left-color: #d32f2f; }
+        .medium-priority { border-left-color: #f57c00; }
+        .low-priority { border-left-color: #388e3c; }
+    </style>
+</head>
+<body>
+    <h1>Compliance Report</h1>
+    <p>Generated: ${new Date(report.metadata.generatedAt).toLocaleString()}</p>
+    
+    <div class="summary">
+        <h2>Summary</h2>
+        <p>Total Files: ${report.summary.totalFiles}</p>
+        <p>Compliant Files: ${report.summary.compliantFiles}</p>
+        <p>Non-Compliant Files: ${report.summary.nonCompliantFiles}</p>
+        <p>Compliance Rate: ${report.summary.complianceRate}%</p>
+        <p>Total Issues: ${report.summary.totalIssues}</p>
+    </div>
+    
+    <h2>Recommendations</h2>
+    ${report.recommendations.map(rec => `
+        <div class="recommendation ${rec.priority}-priority">
+            <h3>${rec.title} (${rec.priority})</h3>
+            <p>${rec.description}</p>
+            <p><strong>Action:</strong> ${rec.action}</p>
+        </div>
+    `).join('')}
+</body>
+</html>`;
+  }
+}
+
+// Export singleton instance
+const generator = new ComplianceReportGenerator();
+
+module.exports = {
+  ComplianceReportGenerator,
+  generator,
+  generateReport: (results, options) => generator.generateReport(results, options),
+  saveReport: (report, outputPath) => generator.saveReport(report, outputPath)
+};