vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/validation-framework.js

@@ -0,0 +1,518 @@
+/**
+ * Validation Framework
+ * 
+ * Comprehensive validation framework for file size refactoring operations.
+ * Provides validation rules, execution, and reporting capabilities.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const RefactoringConfig = require('../config/refactoring-config');
+
+/**
+ * Validation rule types
+ */
+const VALIDATION_TYPES = {
+  SYNTAX: 'syntax',
+  SEMANTIC: 'semantic',
+  STRUCTURAL: 'structural',
+  FUNCTIONAL: 'functional',
+  COMPLIANCE: 'compliance'
+};
+
+/**
+ * Validation severity levels
+ */
+const SEVERITY_LEVELS = {
+  ERROR: 'error',
+  WARNING: 'warning',
+  INFO: 'info'
+};
+
+/**
+ * Validation result structure
+ */
+class ValidationResult {
+  constructor(type, severity, message, filePath = null, line = null, column = null) {
+    this.type = type;
+    this.severity = severity;
+    this.message = message;
+    this.filePath = filePath;
+    this.line = line;
+    this.column = column;
+    this.timestamp = new Date().toISOString();
+  }
+}
+
+/**
+ * Validation framework class
+ */
+class ValidationFramework {
+  constructor(config = RefactoringConfig) {
+    this.config = config;
+    this.rules = new Map();
+    this.results = [];
+    this.setupDefaultRules();
+  }
+
+  /**
+   * Setup default validation rules
+   */
+  setupDefaultRules() {
+    // File size validation
+    this.addRule(VALIDATION_TYPES.COMPLIANCE, {
+      name: 'file-size-limit',
+      severity: SEVERITY_LEVELS.ERROR,
+      validate: (filePath, content) => this.validateFileSize(filePath, content)
+    });
+
+    // Syntax validation
+    this.addRule(VALIDATION_TYPES.SYNTAX, {
+      name: 'javascript-syntax',
+      severity: SEVERITY_LEVELS.ERROR,
+      validate: (filePath, content) => this.validateJavaScriptSyntax(filePath, content)
+    });
+
+    // Import validation
+    this.addRule(VALIDATION_TYPES.SEMANTIC, {
+      name: 'import-statements',
+      severity: SEVERITY_LEVELS.WARNING,
+      validate: (filePath, content) => this.validateImports(filePath, content)
+    });
+
+    // Export validation
+    this.addRule(VALIDATION_TYPES.SEMANTIC, {
+      name: 'export-statements',
+      severity: SEVERITY_LEVELS.WARNING,
+      validate: (filePath, content) => this.validateExports(filePath, content)
+    });
+
+    // Function length validation
+    this.addRule(VALIDATION_TYPES.STRUCTURAL, {
+      name: 'function-length',
+      severity: SEVERITY_LEVELS.WARNING,
+      validate: (filePath, content) => this.validateFunctionLength(filePath, content)
+    });
+
+    // Class length validation
+    this.addRule(VALIDATION_TYPES.STRUCTURAL, {
+      name: 'class-length',
+      severity: SEVERITY_LEVELS.WARNING,
+      validate: (filePath, content) => this.validateClassLength(filePath, content)
+    });
+
+    // Nesting depth validation
+    this.addRule(VALIDATION_TYPES.STRUCTURAL, {
+      name: 'nesting-depth',
+      severity: SEVERITY_LEVELS.WARNING,
+      validate: (filePath, content) => this.validateNestingDepth(filePath, content)
+    });
+
+    // Circular dependency validation
+    this.addRule(VALIDATION_TYPES.SEMANTIC, {
+      name: 'circular-dependencies',
+      severity: SEVERITY_LEVELS.ERROR,
+      validate: (filePath, content) => this.validateCircularDependencies(filePath, content)
+    });
+  }
+
+  /**
+   * Add a validation rule
+   */
+  addRule(type, rule) {
+    if (!this.rules.has(type)) {
+      this.rules.set(type, []);
+    }
+    this.rules.get(type).push(rule);
+  }
+
+  /**
+   * Validate a single file
+   */
+  validateFile(filePath, content = null) {
+    const results = [];
+    
+    try {
+      // Read file content if not provided
+      if (!content) {
+        content = fs.readFileSync(filePath, 'utf8');
+      }
+
+      // Skip excluded files
+      if (this.config.isExcluded(filePath)) {
+        return results;
+      }
+
+      // Run all validation rules
+      for (const [type, rules] of this.rules) {
+        for (const rule of rules) {
+          try {
+            const ruleResults = rule.validate(filePath, content);
+            if (Array.isArray(ruleResults)) {
+              results.push(...ruleResults);
+            } else if (ruleResults) {
+              results.push(ruleResults);
+            }
+          } catch (error) {
+            results.push(new ValidationResult(
+              VALIDATION_TYPES.SYNTAX,
+              SEVERITY_LEVELS.ERROR,
+              `Validation rule '${rule.name}' failed: ${error.message}`,
+              filePath
+            ));
+          }
+        }
+      }
+    } catch (error) {
+      results.push(new ValidationResult(
+        VALIDATION_TYPES.SYNTAX,
+        SEVERITY_LEVELS.ERROR,
+        `File validation failed: ${error.message}`,
+        filePath
+      ));
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate multiple files
+   */
+  validateFiles(filePaths) {
+    const allResults = [];
+    
+    for (const filePath of filePaths) {
+      const results = this.validateFile(filePath);
+      allResults.push(...results);
+    }
+
+    this.results = allResults;
+    return allResults;
+  }
+
+  /**
+   * Validate file size limit
+   */
+  validateFileSize(filePath, content) {
+    const lines = content.split('\n');
+    const lineCount = lines.length;
+    const limits = this.config.getLimits(filePath);
+    
+    if (lineCount > limits.maxFileSize) {
+      return new ValidationResult(
+        VALIDATION_TYPES.COMPLIANCE,
+        SEVERITY_LEVELS.ERROR,
+        `File exceeds maximum size limit: ${lineCount} lines (limit: ${limits.maxFileSize})`,
+        filePath
+      );
+    }
+    
+    if (lineCount > limits.warningThreshold) {
+      return new ValidationResult(
+        VALIDATION_TYPES.COMPLIANCE,
+        SEVERITY_LEVELS.WARNING,
+        `File approaches size limit: ${lineCount} lines (warning: ${limits.warningThreshold})`,
+        filePath
+      );
+    }
+
+    return null;
+  }
+
+  /**
+   * Validate JavaScript syntax
+   */
+  validateJavaScriptSyntax(filePath, content) {
+    const ext = path.extname(filePath);
+    
+    // Only validate JavaScript/TypeScript files
+    if (!['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+      return null;
+    }
+
+    try {
+      // Try to parse with Node.js
+      const vm = require('vm');
+      const script = new vm.Script(content, {
+        filename: path.basename(filePath)
+      });
+      return null;
+    } catch (error) {
+      const match = error.message.match(/at position (\d+)/);
+      const position = match ? parseInt(match[1]) : null;
+      
+      return new ValidationResult(
+        VALIDATION_TYPES.SYNTAX,
+        SEVERITY_LEVELS.ERROR,
+        `JavaScript syntax error: ${error.message}`,
+        filePath,
+        null,
+        position
+      );
+    }
+  }
+
+  /**
+   * Validate import statements
+   */
+  validateImports(filePath, content) {
+    const results = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Check for import statements
+      if (line.startsWith('import ')) {
+        // Check for missing semicolon
+        if (!line.endsWith(';')) {
+          results.push(new ValidationResult(
+            VALIDATION_TYPES.SEMANTIC,
+            SEVERITY_LEVELS.WARNING,
+            'Import statement missing semicolon',
+            filePath,
+            i + 1
+          ));
+        }
+        
+        // Check for unused imports (basic check)
+        const importMatch = line.match(/import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/);
+        if (importMatch) {
+          const importPath = importMatch[1];
+          if (importPath.startsWith('./') || importPath.startsWith('../')) {
+            const resolvedPath = path.resolve(path.dirname(filePath), importPath);
+            if (!fs.existsSync(resolvedPath + '.js') && !fs.existsSync(resolvedPath + '.ts')) {
+              results.push(new ValidationResult(
+                VALIDATION_TYPES.SEMANTIC,
+                SEVERITY_LEVELS.ERROR,
+                `Import target not found: ${importPath}`,
+                filePath,
+                i + 1
+              ));
+            }
+          }
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate export statements
+   */
+  validateExports(filePath, content) {
+    const results = [];
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Check for export statements
+      if (line.startsWith('export ')) {
+        // Check for missing semicolon
+        if (!line.endsWith(';') && !line.includes('function') && !line.includes('class')) {
+          results.push(new ValidationResult(
+            VALIDATION_TYPES.SEMANTIC,
+            SEVERITY_LEVELS.WARNING,
+            'Export statement missing semicolon',
+            filePath,
+            i + 1
+          ));
+        }
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate function length
+   */
+  validateFunctionLength(filePath, content) {
+    const results = [];
+    const validationRules = this.config.validation;
+    const maxFunctionLength = validationRules?.maxFunctionLength || 50;
+    
+    // Simple regex-based function detection
+    const functionPattern = /(?:function\s+\w+|=>\s*{|\w+\s*:\s*function|\w+\s*\([^)]*\)\s*{)/g;
+    const lines = content.split('\n');
+    
+    let match;
+    while ((match = functionPattern.exec(content)) !== null) {
+      const startPos = match.index;
+      const lineNum = content.substring(0, startPos).split('\n').length;
+      
+      // Find function end (simplified)
+      let braceCount = 0;
+      let functionEndPos = startPos;
+      let inFunction = false;
+      
+      for (let i = startPos; i < content.length; i++) {
+        if (content[i] === '{') {
+          braceCount++;
+          inFunction = true;
+        } else if (content[i] === '}') {
+          braceCount--;
+          if (inFunction && braceCount === 0) {
+            functionEndPos = i;
+            break;
+          }
+        }
+      }
+      
+      const functionContent = content.substring(startPos, functionEndPos);
+      const functionLines = functionContent.split('\n').length;
+      
+      if (functionLines > maxFunctionLength) {
+        results.push(new ValidationResult(
+          VALIDATION_TYPES.STRUCTURAL,
+          SEVERITY_LEVELS.WARNING,
+          `Function exceeds maximum length: ${functionLines} lines (limit: ${maxFunctionLength})`,
+          filePath,
+          lineNum
+        ));
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate class length
+   */
+  validateClassLength(filePath, content) {
+    const results = [];
+    const validationRules = this.config.validation;
+    const maxClassLength = validationRules?.maxClassLength || 200;
+    
+    // Simple regex-based class detection
+    const classPattern = /class\s+\w+/g;
+    
+    let match;
+    while ((match = classPattern.exec(content)) !== null) {
+      const startPos = match.index;
+      const lineNum = content.substring(0, startPos).split('\n').length;
+      
+      // Find class end (simplified)
+      let braceCount = 0;
+      let classEndPos = startPos;
+      let inClass = false;
+      
+      for (let i = startPos; i < content.length; i++) {
+        if (content[i] === '{') {
+          braceCount++;
+          inClass = true;
+        } else if (content[i] === '}') {
+          braceCount--;
+          if (inClass && braceCount === 0) {
+            classEndPos = i;
+            break;
+          }
+        }
+      }
+      
+      const classContent = content.substring(startPos, classEndPos);
+      const classLines = classContent.split('\n').length;
+      
+      if (classLines > maxClassLength) {
+        results.push(new ValidationResult(
+          VALIDATION_TYPES.STRUCTURAL,
+          SEVERITY_LEVELS.WARNING,
+          `Class exceeds maximum length: ${classLines} lines (limit: ${maxClassLength})`,
+          filePath,
+          lineNum
+        ));
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate nesting depth
+   */
+  validateNestingDepth(filePath, content) {
+    const results = [];
+    const validationRules = this.config.validation;
+    const maxNestingDepth = validationRules?.maxNestingDepth || 5;
+    
+    const lines = content.split('\n');
+    
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const indentation = line.match(/^\s*/)[0].length;
+      const nestingDepth = Math.floor(indentation / 2); // Assume 2 spaces per level
+      
+      if (nestingDepth > maxNestingDepth) {
+        results.push(new ValidationResult(
+          VALIDATION_TYPES.STRUCTURAL,
+          SEVERITY_LEVELS.WARNING,
+          `Nesting depth exceeds maximum: ${nestingDepth} levels (limit: ${maxNestingDepth})`,
+          filePath,
+          i + 1
+        ));
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Validate circular dependencies (simplified)
+   */
+  validateCircularDependencies(filePath, content) {
+    // This is a simplified implementation
+    // A full implementation would build a dependency graph
+    return [];
+  }
+
+  /**
+   * Get validation summary
+   */
+  getSummary() {
+    const summary = {
+      total: this.results.length,
+      errors: 0,
+      warnings: 0,
+      info: 0,
+      byType: {},
+      byFile: {}
+    };
+
+    for (const result of this.results) {
+      // Count by severity
+      if (result.severity === SEVERITY_LEVELS.ERROR) summary.errors++;
+      else if (result.severity === SEVERITY_LEVELS.WARNING) summary.warnings++;
+      else if (result.severity === SEVERITY_LEVELS.INFO) summary.info++;
+
+      // Count by type
+      if (!summary.byType[result.type]) {
+        summary.byType[result.type] = 0;
+      }
+      summary.byType[result.type]++;
+
+      // Count by file
+      if (!summary.byFile[result.filePath]) {
+        summary.byFile[result.filePath] = 0;
+      }
+      summary.byFile[result.filePath]++;
+    }
+
+    return summary;
+  }
+
+  /**
+   * Check if validation passed (no errors)
+   */
+  isValid() {
+    return this.results.every(result => result.severity !== SEVERITY_LEVELS.ERROR);
+  }
+}
+
+module.exports = {
+  ValidationFramework,
+  ValidationResult,
+  VALIDATION_TYPES,
+  SEVERITY_LEVELS
+};

package/src/validation/compliance-analyzer.js

@@ -0,0 +1,197 @@
+/**
+ * Compliance Analyzer
+ * 
+ * Analyzes validation results and provides compliance metrics.
+ */
+
+const { VALIDATION_SEVERITY } = require('./line-limit-result');
+
+/**
+ * Compliance analyzer class
+ */
+class ComplianceAnalyzer {
+  constructor(defaultLimit = 555) {
+    this.defaultLimit = defaultLimit;
+  }
+
+  /**
+   * Get compliance summary for validation results
+   */
+  getComplianceSummary(results) {
+    const summary = {
+      totalFiles: results.length,
+      compliant: 0,
+      warnings: 0,
+      violations: 0,
+      critical: 0,
+      totalLines: 0,
+      averageLines: 0,
+      largestFile: null,
+      smallestFile: null,
+      complianceRate: 0,
+      byStatus: {
+        compliant: 0,
+        warning: 0,
+        violation: 0,
+        critical: 0
+      },
+      violations: [],
+      recommendations: []
+    };
+    
+    let totalLines = 0;
+    
+    for (const result of results) {
+      summary.totalLines += result.lineCount;
+      
+      if (result.isCompliant()) {
+        summary.compliant++;
+      } else if (result.violation) {
+        if (result.violation.severity === VALIDATION_SEVERITY.CRITICAL) {
+          summary.critical++;
+        } else if (result.violation.severity === VALIDATION_SEVERITY.ERROR) {
+          summary.violations++;
+        } else if (result.violation.severity === VALIDATION_SEVERITY.WARNING) {
+          summary.warnings++;
+        }
+        
+        summary.violations.push(result.violation);
+      }
+      
+      // Update status counts
+      const status = result.getComplianceStatus();
+      summary.byStatus[status]++;
+      
+      // Track largest and smallest files
+      if (!summary.largestFile || result.lineCount > summary.largestFile.lineCount) {
+        summary.largestFile = result;
+      }
+      
+      if (!summary.smallestFile || result.lineCount < summary.smallestFile.lineCount) {
+        summary.smallestFile = result;
+      }
+    }
+    
+    // Calculate averages and rates
+    summary.averageLines = summary.totalFiles > 0 ? 
+      Math.round(summary.totalLines / summary.totalFiles) : 0;
+    
+    summary.complianceRate = summary.totalFiles > 0 ? 
+      ((summary.compliant / summary.totalFiles) * 100).toFixed(1) : 0;
+    
+    // Generate recommendations
+    summary.recommendations = this.generateRecommendations(summary);
+    
+    return summary;
+  }
+
+  /**
+   * Generate recommendations based on validation results
+   */
+  generateRecommendations(summary) {
+    const recommendations = [];
+    
+    if (summary.critical > 0) {
+      recommendations.push({
+        type: 'critical',
+        priority: 'high',
+        title: `Address ${summary.critical} Critical Violations`,
+        description: `${summary.critical} files severely exceed the 555-line limit and require immediate refactoring.`,
+        action: 'Refactor critical files immediately'
+      });
+    }
+    
+    if (summary.violations > 0) {
+      recommendations.push({
+        type: 'violation',
+        priority: 'high',
+        title: `Fix ${summary.violations} Line Limit Violations`,
+        description: `${summary.violations} files exceed the 555-line limit and must be refactored.`,
+        action: 'Refactor files to comply with limit'
+      });
+    }
+    
+    if (summary.warnings > 0) {
+      recommendations.push({
+        type: 'warning',
+        priority: 'medium',
+        title: `Monitor ${summary.warnings} Files Approaching Limit`,
+        description: `${summary.warnings} files are approaching the 555-line limit and should be monitored.`,
+        action: 'Plan refactoring for warning files'
+      });
+    }
+    
+    if (summary.largestFile && summary.largestFile.lineCount > 1000) {
+      recommendations.push({
+        type: 'large_file',
+        priority: 'medium',
+        title: 'Consider Splitting Very Large File',
+        description: `Largest file has ${summary.largestFile.lineCount} lines and may benefit from splitting.`,
+        action: 'Consider splitting into smaller modules'
+      });
+    }
+    
+    if (summary.complianceRate < 80) {
+      recommendations.push({
+        type: 'compliance',
+        priority: 'high',
+        title: 'Improve Overall Compliance',
+        description: `Overall compliance rate is ${summary.complianceRate}%. Target is 100%.`,
+        action: 'Address all violations to improve compliance'
+      });
+    }
+    
+    return recommendations;
+  }
+
+  /**
+   * Filter results by compliance status
+   */
+  filterByStatus(results, status) {
+    return results.filter(result => result.getComplianceStatus() === status);
+  }
+
+  /**
+   * Filter results by severity
+   */
+  filterBySeverity(results, severity) {
+    return results.filter(result => 
+      result.violation && result.violation.severity === severity
+    );
+  }
+
+  /**
+   * Sort results by line count
+   */
+  sortByLineCount(results, descending = true) {
+    return [...results].sort((a, b) => {
+      return descending ? b.lineCount - a.lineCount : a.lineCount - b.lineCount;
+    });
+  }
+
+  /**
+   * Get files exceeding limit
+   */
+  getViolatingFiles(results, limit = null) {
+    return results.filter(result => {
+      const fileLimit = limit || this.defaultLimit;
+      return result.lineCount > fileLimit;
+    });
+  }
+
+  /**
+   * Get files approaching limit
+   */
+  getApproachingLimitFiles(results, limit = null, threshold = 0.9) {
+    const fileLimit = limit || this.defaultLimit;
+    const warningThreshold = Math.floor(fileLimit * threshold);
+    
+    return results.filter(result => 
+      result.lineCount > warningThreshold && result.lineCount <= fileLimit
+    );
+  }
+}
+
+module.exports = {
+  ComplianceAnalyzer
+};