vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/validation/compliance-utils.js

@@ -0,0 +1,278 @@
+/**
+ * Compliance Report Utilities
+ * 
+ * Utility functions for compliance reporting and analysis.
+ */
+
+const { ComplianceReport, FileComplianceSummary, ComplianceIssue } = require('../models/compliance-report');
+
+/**
+ * Create compliance report from validation results
+ * @param {Array} validationResults - Array of validation results
+ * @param {Object} options - Report options
+ * @returns {ComplianceReport} - Compliance report
+ */
+function createComplianceReport(validationResults, options = {}) {
+  const report = new ComplianceReport();
+  
+  // Process validation results
+  validationResults.forEach(result => {
+    if (result.compliant) {
+      report.addCompliantFile(result.filePath, result.metrics);
+    } else {
+      report.addNonCompliantFile(result.filePath, result.issues);
+    }
+  });
+
+  // Add metadata
+  report.addMetadata({
+    generatedAt: new Date().toISOString(),
+    totalFiles: validationResults.length,
+    options: options
+  });
+
+  return report;
+}
+
+/**
+ * Calculate compliance metrics
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {Object} - Calculated metrics
+ */
+function calculateComplianceMetrics(report) {
+  const totalFiles = report.compliantFiles.length + report.nonCompliantFiles.length;
+  const complianceRate = totalFiles > 0 ? (report.compliantFiles.length / totalFiles * 100) : 0;
+  
+  return {
+    totalFiles,
+    compliantFiles: report.compliantFiles.length,
+    nonCompliantFiles: report.nonCompliantFiles.length,
+    complianceRate: complianceRate.toFixed(2),
+    totalIssues: report.getTotalIssues(),
+    issuesByCategory: groupIssuesByCategory(report),
+    issuesBySeverity: groupIssuesBySeverity(report),
+    averageFileSize: calculateAverageFileSize(report),
+    largestFiles: findLargestFiles(report),
+    mostCommonIssues: findMostCommonIssues(report)
+  };
+}
+
+/**
+ * Group issues by category
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {Object} - Issues grouped by category
+ */
+function groupIssuesByCategory(report) {
+  const categories = {};
+  
+  report.nonCompliantFiles.forEach(file => {
+    file.issues.forEach(issue => {
+      const category = issue.category || 'general';
+      categories[category] = (categories[category] || 0) + 1;
+    });
+  });
+  
+  return categories;
+}
+
+/**
+ * Group issues by severity
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {Object} - Issues grouped by severity
+ */
+function groupIssuesBySeverity(report) {
+  const severities = {
+    critical: 0,
+    high: 0,
+    medium: 0,
+    low: 0,
+    info: 0
+  };
+  
+  report.nonCompliantFiles.forEach(file => {
+    file.issues.forEach(issue => {
+      const severity = issue.severity || 'medium';
+      if (severities[severity] !== undefined) {
+        severities[severity]++;
+      }
+    });
+  });
+  
+  return severities;
+}
+
+/**
+ * Calculate average file size
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {number} - Average file size
+ */
+function calculateAverageFileSize(report) {
+  const allFiles = [...report.compliantFiles, ...report.nonCompliantFiles];
+  const totalSize = allFiles.reduce((sum, file) => sum + (file.size || 0), 0);
+  return allFiles.length > 0 ? totalSize / allFiles.length : 0;
+}
+
+/**
+ * Find largest files
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {Array} - Array of largest files
+ */
+function findLargestFiles(report) {
+  const allFiles = [...report.compliantFiles, ...report.nonCompliantFiles];
+  return allFiles
+    .sort((a, b) => (b.size || 0) - (a.size || 0))
+    .slice(0, 10);
+}
+
+/**
+ * Find most common issues
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {Array} - Array of common issues
+ */
+function findMostCommonIssues(report) {
+  const issueCounts = {};
+  
+  report.nonCompliantFiles.forEach(file => {
+    file.issues.forEach(issue => {
+      const key = `${issue.category}:${issue.type}`;
+      issueCounts[key] = (issueCounts[key] || 0) + 1;
+    });
+  });
+  
+  return Object.entries(issueCounts)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 10)
+    .map(([key, count]) => ({
+      key,
+      count,
+      category: key.split(':')[0],
+      type: key.split(':')[1]
+    }));
+}
+
+/**
+ * Generate compliance recommendations
+ * @param {ComplianceReport} report - Compliance report
+ * @returns {Array} - Array of recommendations
+ */
+function generateComplianceRecommendations(report) {
+  const recommendations = [];
+  const metrics = calculateComplianceMetrics(report);
+  
+  // Overall compliance recommendations
+  if (metrics.complianceRate < 80) {
+    recommendations.push({
+      type: 'compliance',
+      priority: 'high',
+      title: 'Low Compliance Rate',
+      description: `Overall compliance rate is ${metrics.complianceRate}%, below target of 80%`,
+      action: 'review_and_fix_non_compliant_files'
+    });
+  }
+  
+  // Critical issues recommendations
+  if (metrics.issuesBySeverity.critical > 0) {
+    recommendations.push({
+      type: 'critical_issues',
+      priority: 'critical',
+      title: 'Critical Compliance Issues',
+      description: `${metrics.issuesBySeverity.critical} critical issues found that require immediate attention`,
+      action: 'address_critical_issues_first'
+    });
+  }
+  
+  // File size recommendations
+  if (metrics.averageFileSize > 800) {
+    recommendations.push({
+      type: 'file_size',
+      priority: 'medium',
+      title: 'Large File Sizes',
+      description: `Average file size is ${metrics.averageFileSize} lines, exceeding the 800-line limit`,
+      action: 'refactor_large_files'
+    });
+  }
+  
+  // Most common issue categories
+  const topCategories = Object.entries(metrics.issuesByCategory)
+    .sort(([, a], [, b]) => b - a)
+    .slice(0, 3);
+  
+  if (topCategories.length > 0) {
+    recommendations.push({
+      type: 'common_issues',
+      priority: 'medium',
+      title: 'Common Issue Categories',
+      description: `Top issue categories: ${topCategories.map(([cat]) => cat).join(', ')}`,
+      action: 'focus_on_common_issue_categories'
+    });
+  }
+  
+  return recommendations;
+}
+
+/**
+ * Create file compliance summary
+ * @param {Object} file - File information
+ * @returns {FileComplianceSummary} - File summary
+ */
+function createFileComplianceSummary(file) {
+  return new FileComplianceSummary({
+    filePath: file.path,
+    size: file.size,
+    lines: file.lines,
+    compliant: file.compliant || false,
+    issues: file.issues || [],
+    metrics: file.metrics || {},
+    lastChecked: new Date().toISOString()
+  });
+}
+
+/**
+ * Validate compliance report
+ * @param {ComplianceReport} report - Compliance report to validate
+ * @returns {Object} - Validation result
+ */
+function validateComplianceReport(report) {
+  const validation = {
+    isValid: true,
+    errors: [],
+    warnings: []
+  };
+  
+  // Check required fields
+  if (!report.metadata) {
+    validation.isValid = false;
+    validation.errors.push('Missing report metadata');
+  }
+  
+  if (!Array.isArray(report.compliantFiles)) {
+    validation.isValid = false;
+    validation.errors.push('Invalid compliant files array');
+  }
+  
+  if (!Array.isArray(report.nonCompliantFiles)) {
+    validation.isValid = false;
+    validation.errors.push('Invalid non-compliant files array');
+  }
+  
+  // Check data consistency
+  const totalFiles = report.compliantFiles.length + report.nonCompliantFiles.length;
+  if (totalFiles !== report.metadata.totalFiles) {
+    validation.warnings.push('File count mismatch in metadata');
+  }
+  
+  return validation;
+}
+
+module.exports = {
+  createComplianceReport,
+  calculateComplianceMetrics,
+  groupIssuesByCategory,
+  groupIssuesBySeverity,
+  calculateAverageFileSize,
+  findLargestFiles,
+  findMostCommonIssues,
+  generateComplianceRecommendations,
+  createFileComplianceSummary,
+  validateComplianceReport
+};