vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/validation/line-limit/line-limit-validator.js

@@ -0,0 +1,208 @@
+/**
+ * Line Limit Validator
+ * 
+ * Main validator that orchestrates file analysis and validation.
+ */
+
+const { FileLineAnalyzer } = require('./file-analyzer');
+const { LineLimitValidationResult, VALIDATION_SEVERITY } = require('./validation-result');
+
+/**
+ * Line limit validator class
+ */
+class LineLimitValidator {
+  constructor(config = {}) {
+    this.config = config;
+    this.defaultLimit = config.limits?.maxFileSize || 555;
+    this.analyzer = new FileLineAnalyzer();
+  }
+
+  /**
+   * Validate a single file
+   */
+  validateFile(filePath, limit = this.defaultLimit) {
+    const result = new LineLimitValidationResult(filePath);
+    result.limit = limit;
+
+    try {
+      const analysis = this.analyzer.analyzeFile(filePath, limit);
+      
+      if (!analysis.shouldAnalyze) {
+        result.addWarning(0, analysis.reason || 'File excluded from analysis');
+        return result;
+      }
+
+      result.lineCount = analysis.lineCount;
+      
+      if (analysis.exceedsLimit) {
+        result.addViolation(
+          analysis.lineCount,
+          `File exceeds ${limit} line limit (${analysis.lineCount} lines, ${analysis.percentage}% of limit)`,
+          analysis.severity
+        );
+      }
+
+      // Add warnings from analysis
+      analysis.warnings.forEach(warning => {
+        result.addWarning(0, warning);
+      });
+
+      // Check for common issues
+      this.checkCommonIssues(filePath, result);
+
+    } catch (error) {
+      result.addViolation(0, `Validation failed: ${error.message}`, VALIDATION_SEVERITY.ERROR);
+    }
+
+    return result;
+  }
+
+  /**
+   * Validate multiple files
+   */
+  validateFiles(filePaths, limit = this.defaultLimit) {
+    const results = [];
+    
+    for (const filePath of filePaths) {
+      const result = this.validateFile(filePath, limit);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Validate a directory recursively
+   */
+  validateDirectory(directoryPath, limit = this.defaultLimit, recursive = true) {
+    const files = this.analyzer.findFilesToAnalyze(directoryPath, recursive);
+    return this.validateFiles(files, limit);
+  }
+
+  /**
+   * Check for common code issues that might affect line count
+   */
+  checkCommonIssues(filePath, result) {
+    try {
+      const content = require('fs').readFileSync(filePath, 'utf8');
+      
+      // Check for trailing whitespace
+      const lines = content.split('\n');
+      let trailingWhitespaceCount = 0;
+      
+      lines.forEach((line, index) => {
+        if (line.endsWith(' ') || line.endsWith('\t')) {
+          trailingWhitespaceCount++;
+          if (trailingWhitespaceCount <= 5) { // Limit warnings to avoid spam
+            result.addWarning(index + 1, 'Line has trailing whitespace');
+          }
+        }
+      });
+
+      if (trailingWhitespaceCount > 5) {
+        result.addWarning(0, `File has ${trailingWhitespaceCount} lines with trailing whitespace`);
+      }
+
+      // Check for very long lines (potential indication of minified code)
+      let longLineCount = 0;
+      lines.forEach((line, index) => {
+        if (line.length > 200) {
+          longLineCount++;
+          if (longLineCount <= 3) {
+            result.addWarning(index + 1, `Very long line (${line.length} characters)`);
+          }
+        }
+      });
+
+      if (longLineCount > 3) {
+        result.addWarning(0, `File has ${longLineCount} very long lines`);
+      }
+
+      // Check if file ends with newline (POSIX standard)
+      if (content.length > 0 && !content.endsWith('\n')) {
+        result.addWarning(lines.length, 'File does not end with newline character');
+      }
+
+    } catch (error) {
+      // If we can't read the file for common issue checks, don't fail the validation
+    }
+  }
+
+  /**
+   * Get validation summary for multiple results
+   */
+  getSummary(results) {
+    const summary = {
+      totalFiles: results.length,
+      validFiles: 0,
+      invalidFiles: 0,
+      totalLines: 0,
+      violations: [],
+      warnings: [],
+      severityBreakdown: {
+        info: 0,
+        warning: 0,
+        error: 0,
+        critical: 0
+      }
+    };
+
+    results.forEach(result => {
+      if (result.isValid) {
+        summary.validFiles++;
+      } else {
+        summary.invalidFiles++;
+      }
+
+      summary.totalLines += result.lineCount;
+      summary.violations.push(...result.violations);
+      summary.warnings.push(...result.warnings);
+      summary.severityBreakdown[result.severity]++;
+    });
+
+    return summary;
+  }
+
+  /**
+   * Format validation results for console output
+   */
+  formatResults(results, verbose = false) {
+    let output = [];
+    
+    const summary = this.getSummary(results);
+    
+    output.push(`\n📊 Line Limit Validation Summary:`);
+    output.push(`   Total files: ${summary.totalFiles}`);
+    output.push(`   Valid files: ${summary.validFiles}`);
+    output.push(`   Invalid files: ${summary.invalidFiles}`);
+    output.push(`   Total lines: ${summary.totalLines}`);
+    
+    if (summary.invalidFiles > 0) {
+      output.push(`\n❌ Files exceeding limit:`);
+      results
+        .filter(result => !result.isValid)
+        .forEach(result => {
+          output.push(`   ${result.formatForConsole()}`);
+        });
+    }
+
+    if (verbose && summary.warnings.length > 0) {
+      output.push(`\n⚠️  Warnings:`);
+      results.forEach(result => {
+        if (result.warnings.length > 0) {
+          output.push(`   ${result.filePath}:`);
+          result.warnings.forEach(warning => {
+            output.push(`     Line ${warning.lineNumber}: ${warning.message}`);
+          });
+        }
+      });
+    }
+
+    return output.join('\n');
+  }
+}
+
+module.exports = {
+  LineLimitValidator,
+  VALIDATION_SEVERITY
+};

package/src/validation/line-limit/validation-result.js

@@ -0,0 +1,144 @@
+/**
+ * Line Limit Validation Result
+ * 
+ * Represents the result of a line limit validation for a single file.
+ */
+
+/**
+ * Validation severity levels
+ */
+const VALIDATION_SEVERITY = {
+  INFO: 'info',
+  WARNING: 'warning',
+  ERROR: 'error',
+  CRITICAL: 'critical'
+};
+
+/**
+ * Validation result class
+ */
+class LineLimitValidationResult {
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.lineCount = 0;
+    this.limit = 555;
+    this.severity = VALIDATION_SEVERITY.INFO;
+    this.violations = [];
+    this.warnings = [];
+    this.isValid = true;
+    this.timestamp = new Date().toISOString();
+  }
+
+  /**
+   * Add a violation to the result
+   */
+  addViolation(lineNumber, message, severity = VALIDATION_SEVERITY.ERROR) {
+    const violation = {
+      lineNumber,
+      message,
+      severity,
+      timestamp: new Date().toISOString()
+    };
+
+    this.violations.push(violation);
+    
+    if (severity === VALIDATION_SEVERITY.ERROR || severity === VALIDATION_SEVERITY.CRITICAL) {
+      this.isValid = false;
+    }
+
+    // Update overall severity based on most severe
+    if (this.getSeverityLevel(severity) > this.getSeverityLevel(this.severity)) {
+      this.severity = severity;
+    }
+  }
+
+  /**
+   * Add a warning to the result
+   */
+  addWarning(lineNumber, message) {
+    this.addViolation(lineNumber, message, VALIDATION_SEVERITY.WARNING);
+    this.warnings.push({
+      lineNumber,
+      message,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  /**
+   * Get numeric severity level for comparison
+   */
+  getSeverityLevel(severity) {
+    const levels = {
+      [VALIDATION_SEVERITY.INFO]: 1,
+      [VALIDATION_SEVERITY.WARNING]: 2,
+      [VALIDATION_SEVERITY.ERROR]: 3,
+      [VALIDATION_SEVERITY.CRITICAL]: 4
+    };
+    return levels[severity] || 0;
+  }
+
+  /**
+   * Check if the file exceeds the line limit
+   */
+  exceedsLimit() {
+    return this.lineCount > this.limit;
+  }
+
+  /**
+   * Get the percentage of the limit used
+   */
+  getPercentageUsed() {
+    if (this.limit === 0) return 0;
+    return Math.round((this.lineCount / this.limit) * 100);
+  }
+
+  /**
+   * Get a summary of the validation result
+   */
+  getSummary() {
+    return {
+      filePath: this.filePath,
+      lineCount: this.lineCount,
+      limit: this.limit,
+      percentageUsed: this.getPercentageUsed(),
+      isValid: this.isValid,
+      severity: this.severity,
+      violationCount: this.violations.length,
+      warningCount: this.warnings.length,
+      exceedsLimit: this.exceedsLimit(),
+      timestamp: this.timestamp
+    };
+  }
+
+  /**
+   * Format the result for console output
+   */
+  formatForConsole() {
+    const status = this.isValid ? '✅' : '❌';
+    const percentage = this.getPercentageUsed();
+    const severity = this.severity.toUpperCase();
+    
+    let output = `${status} ${this.filePath} (${this.lineCount}/${this.limit} lines, ${percentage}%) [${severity}]`;
+    
+    if (this.violations.length > 0) {
+      output += `\n  Violations: ${this.violations.length}`;
+      this.violations.forEach(violation => {
+        output += `\n    Line ${violation.lineNumber}: ${violation.message}`;
+      });
+    }
+    
+    if (this.warnings.length > 0) {
+      output += `\n  Warnings: ${this.warnings.length}`;
+      this.warnings.forEach(warning => {
+        output += `\n    Line ${warning.lineNumber}: ${warning.message}`;
+      });
+    }
+    
+    return output;
+  }
+}
+
+module.exports = {
+  LineLimitValidationResult,
+  VALIDATION_SEVERITY
+};

package/src/validation/line-limit-core.js

@@ -0,0 +1,225 @@
+/**
+ * Line Limit Core Validator
+ * 
+ * Core validation logic for line limit checking.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { LineLimitValidationResult, VALIDATION_SEVERITY } = require('./line-limit-result');
+const RefactoringConfig = require('../config/refactoring-config');
+
+/**
+ * Line limit validator class
+ */
+class LineLimitValidator {
+  constructor(config = RefactoringConfig) {
+    this.config = config;
+    this.defaultLimit = config.limits?.maxFileSize || 800;
+    this.defaultWarningThreshold = config.limits?.warningThreshold || 700;
+    this.defaultCriticalThreshold = config.limits?.criticalThreshold || 1000;
+  }
+
+  /**
+   * Validate a single file
+   */
+  validateFile(filePath, options = {}) {
+    const result = new LineLimitValidationResult(filePath);
+    
+    try {
+      // Set limits based on config or options
+      const limit = options.limit || this.defaultLimit;
+      result.setLimit(limit);
+      
+      if (options.warningThreshold) {
+        result.warningThreshold = options.warningThreshold;
+      } else {
+        result.warningThreshold = Math.floor(limit * 0.9);
+      }
+      
+      if (options.criticalThreshold) {
+        result.criticalThreshold = options.criticalThreshold;
+      } else {
+        result.criticalThreshold = limit * 1.5;
+      }
+      
+      // Check if file exists
+      if (!fs.existsSync(filePath)) {
+        result.addIssue(VALIDATION_SEVERITY.ERROR, 'File not found', filePath);
+        return result;
+      }
+      
+      // Count lines
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lineCount = content.split('\n').length;
+      result.setLineCount(lineCount);
+      
+      // Add additional context issues
+      this.addContextualIssues(result, content);
+      
+    } catch (error) {
+      result.addIssue(VALIDATION_SEVERITY.ERROR, 'Validation failed', error.message);
+    }
+    
+    return result;
+  }
+
+  /**
+   * Validate multiple files
+   */
+  validateFiles(filePaths, options = {}) {
+    const results = [];
+    
+    for (const filePath of filePaths) {
+      const result = this.validateFile(filePath, options);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Validate directory recursively
+   */
+  validateDirectory(dirPath, options = {}) {
+    const results = [];
+    
+    const walkDir = (dir) => {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        
+        if (entry.isDirectory()) {
+          // Skip excluded directories
+          if (!this.shouldSkipDirectory(fullPath)) {
+            walkDir(fullPath);
+          }
+        } else if (entry.isFile()) {
+          // Only validate certain file types
+          if (this.shouldValidateFile(fullPath)) {
+            const result = this.validateFile(fullPath, options);
+            results.push(result);
+          }
+        }
+      }
+    };
+    
+    walkDir(dirPath);
+    return results;
+  }
+
+  /**
+   * Check if directory should be skipped
+   */
+  shouldSkipDirectory(dirPath) {
+    const dirName = path.basename(dirPath);
+    const skipDirs = [
+      'node_modules', '.git', 'dist', 'build', 'coverage',
+      '.vscode', '.idea', '.cursor', '.windsurf',
+      'vendor', 'bower_components'
+    ];
+    
+    return skipDirs.includes(dirName) || dirName.startsWith('.');
+  }
+
+  /**
+   * Check if file should be validated
+   */
+  shouldValidateFile(filePath) {
+    const ext = path.extname(filePath);
+    const validateExts = ['.js', '.jsx', '.ts', '.tsx', '.md', '.json'];
+    
+    return validateExts.includes(ext);
+  }
+
+  /**
+   * Add contextual issues to validation result
+   */
+  addContextualIssues(result, content) {
+    const lines = content.split('\n');
+    
+    // Check for very long lines
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.length > 200) {
+        result.addIssue(
+          VALIDATION_SEVERITY.WARNING,
+          `Very long line at ${i + 1}: ${line.length} characters`,
+          { lineNumber: i + 1, lineLength: line.length }
+        );
+      }
+    }
+    
+    // Check for missing newlines at end of file
+    if (content.length > 0 && !content.endsWith('\n')) {
+      result.addIssue(
+        VALIDATION_SEVERITY.INFO,
+        'File does not end with newline'
+      );
+    }
+    
+    // Check for trailing whitespace
+    let trailingWhitespaceLines = 0;
+    for (const line of lines) {
+      if (line.endsWith(' ') || line.endsWith('\t')) {
+        trailingWhitespaceLines++;
+      }
+    }
+    
+    if (trailingWhitespaceLines > 0) {
+      result.addIssue(
+        VALIDATION_SEVERITY.INFO,
+        `${trailingWhitespaceLines} lines have trailing whitespace`
+      );
+    }
+    
+    // Check for consecutive empty lines
+    let consecutiveEmptyLines = 0;
+    let maxConsecutiveEmpty = 0;
+    
+    for (const line of lines) {
+      if (line.trim() === '') {
+        consecutiveEmptyLines++;
+        maxConsecutiveEmpty = Math.max(maxConsecutiveEmpty, consecutiveEmptyLines);
+      } else {
+        consecutiveEmptyLines = 0;
+      }
+    }
+    
+    if (maxConsecutiveEmpty > 5) {
+      result.addIssue(
+        VALIDATION_SEVERITY.INFO,
+        `${maxConsecutiveEmptyLines} consecutive empty lines found`
+      );
+    }
+  }
+
+  /**
+   * Validate configuration
+   */
+  validateConfig(config = this.config) {
+    const issues = [];
+    
+    if (config.limits?.maxFileSize <= 0) {
+      issues.push('maxFileSize must be greater than 0');
+    }
+    
+    if (config.limits?.warningThreshold >= config.limits?.maxFileSize) {
+      issues.push('warningThreshold must be less than maxFileSize');
+    }
+    
+    if (config.limits?.criticalThreshold <= config.limits?.maxFileSize) {
+      issues.push('criticalThreshold must be greater than maxFileSize');
+    }
+    
+    return {
+      isValid: issues.length === 0,
+      issues
+    };
+  }
+}
+
+module.exports = {
+  LineLimitValidator
+};

package/src/validation/line-limit-reporter.js

@@ -0,0 +1,134 @@
+/**
+ * Line Limit Reporter
+ * 
+ * Generates reports for line limit validation results.
+ */
+
+const fs = require('fs');
+const { VALIDATION_SEVERITY } = require('./line-limit-result');
+const { ComplianceAnalyzer } = require('./compliance-analyzer');
+
+/**
+ * Line limit reporter class
+ */
+class LineLimitReporter {
+  constructor(defaultLimit = 555) {
+    this.defaultLimit = defaultLimit;
+    this.analyzer = new ComplianceAnalyzer(defaultLimit);
+  }
+
+  /**
+   * Export validation results
+   */
+  exportResults(results, format = 'json') {
+    const exportData = {
+      metadata: {
+        exportedAt: new Date().toISOString(),
+        validator: 'LineLimitValidator',
+        version: '1.0.0',
+        config: {
+          defaultLimit: this.defaultLimit
+        }
+      },
+      summary: this.analyzer.getComplianceSummary(results),
+      results: results.map(result => result.getSummary())
+    };
+    
+    if (format === 'json') {
+      return JSON.stringify(exportData, null, 2);
+    }
+    
+    return exportData;
+  }
+
+  /**
+   * Generate compliance report
+   */
+  generateReport(results, outputPath = null) {
+    const summary = this.analyzer.getComplianceSummary(results);
+    
+    let report = '# Line Limit Compliance Report\n\n';
+    
+    // Metadata
+    report += `**Generated:** ${new Date().toLocaleString()}\n`;
+    report += `**Validator:** Line Limit Validator v1.0.0\n`;
+    report += `**Limit:** ${this.defaultLimit} lines\n\n`;
+    
+    // Summary
+    report += `## Summary\n\n`;
+    report += `- **Total Files:** ${summary.totalFiles}\n`;
+    report += `- **Compliant:** ${summary.compliant} (${((summary.compliant / summary.totalFiles) * 100).toFixed(1)}%)\n`;
+    report += `- **Warnings:** ${summary.warnings}\n`;
+    report += `- **Violations:** ${summary.violations}\n`;
+    report += `- **Critical:** ${summary.critical}\n`;
+    report += `- **Compliance Rate:** ${summary.complianceRate}%\n`;
+    report += `- **Average Lines:** ${summary.averageLines}\n`;
+    report += `- **Largest File:** ${summary.largestFile ? summary.largestFile.lineCount : 'N/A'} lines\n`;
+    report += `- **Smallest File:** ${summary.smallestFile ? summary.smallestFile.lineCount : 'N/A'} lines\n\n`;
+    
+    // Violations
+    if (summary.violations.length > 0) {
+      report += `## Violations (${summary.violations.length})\n\n`;
+      
+      for (const violation of summary.violations) {
+        report += `### ${violation.type.toUpperCase()} - ${violation.severity.toUpperCase()}\n`;
+        report += `- **File:** \`${violation.filePath}\`\n`;
+        report += `- **Lines:** ${violation.lineCount}\n`;
+        report += `- **Excess:** ${violation.excessLines} lines\n`;
+        report += `- **Over Limit:** ${violation.percentageOverLimit}%\n`;
+        report += `- **Message:** ${violation.message}\n\n`;
+      }
+    }
+    
+    // Warnings
+    if (summary.warnings > 0) {
+      report += `## Warnings (${summary.warnings})\n\n`;
+      
+      const warningResults = this.analyzer.filterBySeverity(results, VALIDATION_SEVERITY.WARNING);
+      for (const result of warningResults) {
+        report += `### ${result.filePath}\n`;
+        report += `- **Lines:** ${result.lineCount}\n`;
+        report += `- **Message:** ${result.violation.message}\n\n`;
+      }
+    }
+    
+    // Recommendations
+    if (summary.recommendations.length > 0) {
+      report += `## Recommendations\n\n`;
+      
+      for (const rec of summary.recommendations) {
+        report += `### ${rec.title} (${rec.priority})\n`;
+        report += `${rec.description}\n\n`;
+        report += `**Action:** ${rec.action}\n\n`;
+      }
+    }
+    
+    // File details
+    report += `## File Details\n\n`;
+    report += `| File | Lines | Status | Excess | Message |\n`;
+    report += `|------|------|--------|--------|---------|\n`;
+    
+    for (const result of this.analyzer.sortByLineCount(results)) {
+      const status = result.getComplianceStatus();
+      const statusColor = status === 'compliant' ? '✅' : 
+                         status === 'warning' ? '⚠️' : 
+                         status === 'violation' ? '❌' : '🚨';
+      
+      const excess = result.violation ? result.violation.excessLines : 0;
+      const message = result.violation ? result.violation.message : 'Compliant';
+      
+      report += `| \`${result.filePath}\` | ${result.lineCount} | ${statusColor} ${status} | ${excess} | ${message} |\n`;
+    }
+    
+    if (outputPath) {
+      fs.writeFileSync(outputPath, report, 'utf8');
+      console.log(`Report saved to: ${outputPath}`);
+    }
+    
+    return report;
+  }
+}
+
+module.exports = {
+  LineLimitReporter
+};