vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/utils/report-generators/analysis-generator.js

@@ -0,0 +1,115 @@
+/**
+ * Analysis Report Generator
+ * 
+ * Generates analysis reports for file size and code metrics
+ */
+
+const BaseReportGenerator = require('./base-generator');
+
+class AnalysisReportGenerator extends BaseReportGenerator {
+  /**
+   * Generate analysis summary
+   */
+  generateSummary(analysisData) {
+    const files = analysisData.files || [];
+    const totalFiles = files.length;
+    const largeFiles = files.filter(f => f.lineCount > 555).length;
+    const mediumFiles = files.filter(f => f.lineCount > 300 && f.lineCount <= 555).length;
+    const smallFiles = files.filter(f => f.lineCount <= 300).length;
+    
+    const totalLines = files.reduce((sum, f) => sum + f.lineCount, 0);
+    const avgLines = totalFiles > 0 ? Math.round(totalLines / totalFiles) : 0;
+
+    return {
+      totalFiles,
+      totalLines,
+      averageLines: avgLines,
+      sizeDistribution: {
+        small: smallFiles,
+        medium: mediumFiles,
+        large: largeFiles,
+        xlarge: files.filter(f => f.lineCount > 800).length
+      },
+      complianceRate: totalFiles > 0 ? ((totalFiles - largeFiles) / totalFiles * 100).toFixed(1) : 0,
+      needsRefactoring: largeFiles + mediumFiles
+    };
+  }
+
+  /**
+   * Generate recommendations
+   */
+  generateRecommendations(analysisData) {
+    const recommendations = [];
+    const files = analysisData.files || [];
+    
+    // Large file recommendations
+    const largeFiles = files.filter(f => f.lineCount > 555);
+    if (largeFiles.length > 0) {
+      recommendations.push({
+        type: 'urgent',
+        title: `Refactor ${largeFiles.length} Large Files`,
+        description: `${largeFiles.length} files exceed the 555-line limit and require immediate refactoring.`,
+        files: largeFiles.map(f => f.path),
+        priority: 'high'
+      });
+    }
+
+    // Medium file recommendations
+    const mediumFiles = files.filter(f => f.lineCount > 300 && f.lineCount <= 555);
+    if (mediumFiles.length > 0) {
+      recommendations.push({
+        type: 'planning',
+        title: `Plan Refactoring for ${mediumFiles.length} Medium Files`,
+        description: `${mediumFiles.length} files are approaching the size limit and should be planned for refactoring.`,
+        files: mediumFiles.map(f => f.path),
+        priority: 'medium'
+      });
+    }
+
+    // Package-specific recommendations
+    const packageStats = this.analyzePackageStats(files);
+    for (const [pkg, stats] of Object.entries(packageStats)) {
+      if (stats.complianceRate < 80) {
+        recommendations.push({
+          type: 'package',
+          title: `Improve ${pkg} Package Compliance`,
+          description: `Package ${pkg} has ${stats.complianceRate}% compliance rate and needs attention.`,
+          files: stats.files,
+          priority: 'medium'
+        });
+      }
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Generate statistics
+   */
+  generateStatistics(analysisData) {
+    const files = analysisData.files || [];
+    
+    return {
+      fileSizes: this.calculateSizeDistribution(files),
+      packageStats: this.analyzePackageStats(files),
+      fileTypeStats: this.analyzeFileTypeStats(files),
+      complexityMetrics: this.calculateComplexityMetrics(files)
+    };
+  }
+
+  /**
+   * Generate full analysis report data
+   */
+  generate(analysisData) {
+    return {
+      type: 'analysis',
+      metadata: this.metadata,
+      summary: this.generateSummary(analysisData),
+      files: analysisData.files || [],
+      recommendations: this.generateRecommendations(analysisData),
+      statistics: this.generateStatistics(analysisData)
+    };
+  }
+}
+
+module.exports = AnalysisReportGenerator;

package/src/utils/report-generators/base-generator.js

@@ -0,0 +1,141 @@
+/**
+ * Base Report Generator
+ * 
+ * Base class for all report generators with shared utilities
+ */
+
+const path = require('path');
+
+class BaseReportGenerator {
+  constructor(config) {
+    this.config = config;
+    this.metadata = {
+      generatedAt: new Date().toISOString(),
+      version: '1.0.0',
+      config: config.reporting || {}
+    };
+  }
+
+  /**
+   * Extract package name from file path
+   */
+  extractPackageFromPath(filePath) {
+    const match = filePath.match(/packages\/([^\/]+)/);
+    return match ? match[1] : 'root';
+  }
+
+  /**
+   * Calculate size distribution
+   */
+  calculateSizeDistribution(files) {
+    const distribution = {
+      '0-100': 0,
+      '101-200': 0,
+      '201-300': 0,
+      '301-400': 0,
+      '401-500': 0,
+      '501-555': 0,
+      '556+': 0
+    };
+
+    for (const file of files) {
+      const lines = file.lineCount;
+      if (lines <= 100) distribution['0-100']++;
+      else if (lines <= 200) distribution['101-200']++;
+      else if (lines <= 300) distribution['201-300']++;
+      else if (lines <= 400) distribution['301-400']++;
+      else if (lines <= 500) distribution['401-500']++;
+      else if (lines <= 555) distribution['501-555']++;
+      else distribution['556+']++;
+    }
+
+    return distribution;
+  }
+
+  /**
+   * Analyze package statistics
+   */
+  analyzePackageStats(files) {
+    const packageStats = {};
+    
+    for (const file of files) {
+      const pkg = this.extractPackageFromPath(file.path);
+      if (!packageStats[pkg]) {
+        packageStats[pkg] = {
+          totalFiles: 0,
+          totalLines: 0,
+          compliantFiles: 0,
+          files: []
+        };
+      }
+      
+      packageStats[pkg].totalFiles++;
+      packageStats[pkg].totalLines += file.lineCount;
+      packageStats[pkg].files.push(file.path);
+      
+      if (file.lineCount <= 555) {
+        packageStats[pkg].compliantFiles++;
+      }
+    }
+
+    // Calculate compliance rates
+    for (const stats of Object.values(packageStats)) {
+      stats.complianceRate = stats.totalFiles > 0 
+        ? (stats.compliantFiles / stats.totalFiles * 100).toFixed(1)
+        : 0;
+      stats.averageLines = stats.totalFiles > 0
+        ? Math.round(stats.totalLines / stats.totalFiles)
+        : 0;
+    }
+
+    return packageStats;
+  }
+
+  /**
+   * Analyze file type statistics
+   */
+  analyzeFileTypeStats(files) {
+    const typeStats = {};
+    
+    for (const file of files) {
+      const ext = path.extname(file.path);
+      if (!typeStats[ext]) {
+        typeStats[ext] = {
+          count: 0,
+          totalLines: 0,
+          averageLines: 0
+        };
+      }
+      
+      typeStats[ext].count++;
+      typeStats[ext].totalLines += file.lineCount;
+    }
+
+    // Calculate averages
+    for (const stats of Object.values(typeStats)) {
+      stats.averageLines = stats.count > 0
+        ? Math.round(stats.totalLines / stats.count)
+        : 0;
+    }
+
+    return typeStats;
+  }
+
+  /**
+   * Calculate complexity metrics (simplified)
+   */
+  calculateComplexityMetrics(files) {
+    return {
+      totalComplexity: 0,
+      averageComplexity: 0,
+      complexityDistribution: {
+        low: 0,
+        medium: 0,
+        high: 0,
+        veryHigh: 0
+      }
+    };
+  }
+}
+
+module.exports = BaseReportGenerator;

package/src/utils/report-generators/compliance-generator.js

@@ -0,0 +1,41 @@
+/**
+ * Compliance Report Generator
+ * 
+ * Generates compliance reports for constitutional requirements
+ */
+
+const BaseReportGenerator = require('./base-generator');
+
+class ComplianceReportGenerator extends BaseReportGenerator {
+  /**
+   * Generate compliance summary
+   */
+  generateSummary(complianceData) {
+    const metrics = complianceData.metrics || {};
+    
+    return {
+      overallScore: metrics.overallScore || 0,
+      fileComplianceRate: metrics.fileComplianceRate || 0,
+      lineComplianceRate: metrics.lineComplianceRate || 0,
+      violationCount: metrics.violationCount || 0,
+      lastChecked: metrics.lastChecked || new Date().toISOString(),
+      status: metrics.status || 'unknown'
+    };
+  }
+
+  /**
+   * Generate full compliance report data
+   */
+  generate(complianceData) {
+    return {
+      type: 'compliance',
+      metadata: this.metadata,
+      summary: this.generateSummary(complianceData),
+      metrics: complianceData.metrics || {},
+      violations: complianceData.violations || [],
+      trends: complianceData.trends || {}
+    };
+  }
+}
+
+module.exports = ComplianceReportGenerator;

package/src/utils/report-generators/format-handlers.js

@@ -0,0 +1,185 @@
+/**
+ * Report Format Handlers
+ * 
+ * Handles output formatting for different report types
+ */
+
+const fs = require('fs');
+
+const OUTPUT_FORMATS = {
+  JSON: 'json',
+  MARKDOWN: 'markdown',
+  CONSOLE: 'console',
+  HTML: 'html'
+};
+
+class FormatHandler {
+  /**
+   * Output report in specified format
+   */
+  static output(reportData, format, outputPath) {
+    switch (format) {
+      case OUTPUT_FORMATS.JSON:
+        return FormatHandler.outputJSON(reportData, outputPath);
+      case OUTPUT_FORMATS.MARKDOWN:
+        return FormatHandler.outputMarkdown(reportData, outputPath);
+      case OUTPUT_FORMATS.CONSOLE:
+        return FormatHandler.outputConsole(reportData);
+      case OUTPUT_FORMATS.HTML:
+        return FormatHandler.outputHTML(reportData, outputPath);
+      default:
+        throw new Error(`Unsupported output format: ${format}`);
+    }
+  }
+
+  /**
+   * Output JSON format
+   */
+  static outputJSON(reportData, outputPath) {
+    const json = JSON.stringify(reportData, null, 2);
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, json, 'utf8');
+      return { success: true, path: outputPath, format: 'json' };
+    }
+    
+    return { success: true, content: json, format: 'json' };
+  }
+
+  /**
+   * Output Markdown format
+   */
+  static outputMarkdown(reportData, outputPath) {
+    const markdown = FormatHandler.generateMarkdownReport(reportData);
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, markdown, 'utf8');
+      return { success: true, path: outputPath, format: 'markdown' };
+    }
+    
+    return { success: true, content: markdown, format: 'markdown' };
+  }
+
+  /**
+   * Output console format
+   */
+  static outputConsole(reportData) {
+    const consoleOutput = FormatHandler.generateConsoleReport(reportData);
+    console.log(consoleOutput);
+    return { success: true, content: consoleOutput, format: 'console' };
+  }
+
+  /**
+   * Output HTML format
+   */
+  static outputHTML(reportData, outputPath) {
+    const html = FormatHandler.generateHTMLReport(reportData);
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, html, 'utf8');
+      return { success: true, path: outputPath, format: 'html' };
+    }
+    
+    return { success: true, content: html, format: 'html' };
+  }
+
+  /**
+   * Generate Markdown report
+   */
+  static generateMarkdownReport(data) {
+    let markdown = `# ${data.type.charAt(0).toUpperCase() + data.type.slice(1)} Report\n\n`;
+    
+    // Metadata
+    markdown += `**Generated:** ${new Date(data.metadata.generatedAt).toLocaleString()}\n`;
+    markdown += `**Version:** ${data.metadata.version}\n\n`;
+    
+    // Summary
+    if (data.summary) {
+      markdown += `## Summary\n\n`;
+      for (const [key, value] of Object.entries(data.summary)) {
+        markdown += `- **${key}:** ${value}\n`;
+      }
+      markdown += `\n`;
+    }
+    
+    // Recommendations
+    if (data.recommendations && data.recommendations.length > 0) {
+      markdown += `## Recommendations\n\n`;
+      for (const rec of data.recommendations) {
+        markdown += `### ${rec.title} (${rec.priority})\n`;
+        markdown += `${rec.description}\n\n`;
+        if (rec.files && rec.files.length > 0) {
+          markdown += `**Files:**\n`;
+          for (const file of rec.files) {
+            markdown += `- \`${file}\`\n`;
+          }
+          markdown += `\n`;
+        }
+      }
+    }
+    
+    return markdown;
+  }
+
+  /**
+   * Generate console report
+   */
+  static generateConsoleReport(data) {
+    let output = `\n=== ${data.type.toUpperCase()} REPORT ===\n\n`;
+    
+    // Summary
+    if (data.summary) {
+      output += "SUMMARY:\n";
+      for (const [key, value] of Object.entries(data.summary)) {
+        output += `  ${key}: ${value}\n`;
+      }
+      output += "\n";
+    }
+    
+    return output;
+  }
+
+  /**
+   * Generate HTML report
+   */
+  static generateHTMLReport(data) {
+    return `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>${data.type} Report</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 20px; }
+        .header { background: #f5f5f5; padding: 20px; border-radius: 5px; }
+        .summary { margin: 20px 0; }
+        .metric { display: inline-block; margin: 10px; padding: 10px; background: #e9ecef; border-radius: 3px; }
+        table { border-collapse: collapse; width: 100%; }
+        th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
+        th { background-color: #f2f2f2; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>${data.type} Report</h1>
+        <p>Generated: ${new Date(data.metadata.generatedAt).toLocaleString()}</p>
+    </div>
+    
+    <div class="summary">
+        <h2>Summary</h2>
+        ${Object.entries(data.summary || {}).map(([key, value]) => 
+            `<div class="metric"><strong>${key}:</strong> ${value}</div>`
+        ).join('')}
+    </div>
+    
+    <script>
+        // Add interactive features here if needed
+    </script>
+</body>
+</html>`;
+  }
+}
+
+module.exports = {
+  FormatHandler,
+  OUTPUT_FORMATS
+};

package/src/utils/report-generators/refactoring-generator.js

@@ -0,0 +1,46 @@
+/**
+ * Refactoring Report Generator
+ * 
+ * Generates reports for refactoring operations and results
+ */
+
+const BaseReportGenerator = require('./base-generator');
+
+class RefactoringReportGenerator extends BaseReportGenerator {
+  /**
+   * Generate refactoring summary
+   */
+  generateSummary(refactoringData) {
+    const operations = refactoringData.operations || [];
+    const successful = operations.filter(op => op.status === 'success').length;
+    const failed = operations.filter(op => op.status === 'failed').length;
+    const skipped = operations.filter(op => op.status === 'skipped').length;
+
+    return {
+      totalOperations: operations.length,
+      successful,
+      failed,
+      skipped,
+      successRate: operations.length > 0 ? (successful / operations.length * 100).toFixed(1) : 0,
+      filesProcessed: refactoringData.filesProcessed || 0,
+      linesReduced: refactoringData.linesReduced || 0,
+      modulesCreated: refactoringData.modulesCreated || 0
+    };
+  }
+
+  /**
+   * Generate full refactoring report data
+   */
+  generate(refactoringData) {
+    return {
+      type: 'refactoring',
+      metadata: this.metadata,
+      summary: this.generateSummary(refactoringData),
+      operations: refactoringData.operations || [],
+      results: refactoringData.results || [],
+      rollback: refactoringData.rollback || {}
+    };
+  }
+}
+
+module.exports = RefactoringReportGenerator;

package/src/utils/report-generators/validation-generator.js

@@ -0,0 +1,63 @@
+/**
+ * Validation Report Generator
+ * 
+ * Generates validation reports for code quality and compliance checks
+ */
+
+const BaseReportGenerator = require('./base-generator');
+
+class ValidationReportGenerator extends BaseReportGenerator {
+  /**
+   * Generate validation summary
+   */
+  generateSummary(validationData) {
+    const results = validationData.results || [];
+    const errors = results.filter(r => r.severity === 'error').length;
+    const warnings = results.filter(r => r.severity === 'warning').length;
+    const info = results.filter(r => r.severity === 'info').length;
+
+    return {
+      totalIssues: results.length,
+      errors,
+      warnings,
+      info,
+      filesValidated: validationData.filesValidated || 0,
+      passed: errors === 0
+    };
+  }
+
+  /**
+   * Generate compliance metrics
+   */
+  generateComplianceMetrics(validationData) {
+    const results = validationData.results || [];
+    const filesValidated = validationData.filesValidated || 0;
+    
+    const errorCount = results.filter(r => r.severity === 'error').length;
+    const warningCount = results.filter(r => r.severity === 'warning').length;
+    
+    return {
+      overallScore: filesValidated > 0 ? Math.max(0, 100 - (errorCount * 10 + warningCount * 2)) : 0,
+      fileComplianceRate: filesValidated > 0 ? ((filesValidated - errorCount) / filesValidated * 100) : 0,
+      lineComplianceRate: 0,
+      violationCount: errorCount,
+      lastChecked: new Date().toISOString(),
+      status: errorCount === 0 ? 'compliant' : warningCount > 0 ? 'warning' : 'non-compliant'
+    };
+  }
+
+  /**
+   * Generate full validation report data
+   */
+  generate(validationData) {
+    return {
+      type: 'validation',
+      metadata: this.metadata,
+      summary: this.generateSummary(validationData),
+      results: validationData.results || [],
+      compliance: this.generateComplianceMetrics(validationData)
+    };
+  }
+}
+
+module.exports = ValidationReportGenerator;