vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/file-size-analyzer.js

@@ -0,0 +1,272 @@
+/**
+ * File Size Analyzer
+ * Utility to scan codebase and identify files exceeding the 555-line constitutional limit
+ * Part of specs/010-555-max-file-size implementation
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Size categories based on line count
+ */
+const SIZE_CATEGORIES = {
+  SMALL: { max: 200, label: 'SMALL' },
+  MEDIUM: { max: 400, label: 'MEDIUM' },
+  LARGE: { max: 555, label: 'LARGE' },
+  XLARGE: { max: Infinity, label: 'XLARGE' }
+};
+
+/**
+ * Refactoring priority based on how far over the limit
+ */
+const REFACTORING_PRIORITIES = {
+  LOW: { threshold: 0, label: 'LOW' },          // Under limit
+  MEDIUM: { threshold: 556, label: 'MEDIUM' },  // 1-200 over limit
+  HIGH: { threshold: 755, label: 'HIGH' },      // 201-500 over limit
+  CRITICAL: { threshold: 1055, label: 'CRITICAL' } // 500+ over limit
+};
+
+/**
+ * Default exclusion patterns
+ */
+const DEFAULT_EXCLUSIONS = [
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'coverage',
+  '.next',
+  '.cache',
+  'vendor',
+  'third-party',
+  'external'
+];
+
+/**
+ * Count lines in a file
+ * @param {string} filePath - Path to file
+ * @returns {number} Line count
+ */
+function countLines(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return content.split('\n').length;
+  } catch (error) {
+    return 0;
+  }
+}
+
+/**
+ * Determine size category for a file
+ * @param {number} lineCount - Number of lines in file
+ * @returns {string} Size category label
+ */
+function getSizeCategory(lineCount) {
+  if (lineCount <= SIZE_CATEGORIES.SMALL.max) return SIZE_CATEGORIES.SMALL.label;
+  if (lineCount <= SIZE_CATEGORIES.MEDIUM.max) return SIZE_CATEGORIES.MEDIUM.label;
+  if (lineCount <= SIZE_CATEGORIES.LARGE.max) return SIZE_CATEGORIES.LARGE.label;
+  return SIZE_CATEGORIES.XLARGE.label;
+}
+
+/**
+ * Determine refactoring priority for a file
+ * @param {number} lineCount - Number of lines in file
+ * @returns {string} Priority label
+ */
+function getRefactoringPriority(lineCount) {
+  if (lineCount <= SIZE_CATEGORIES.LARGE.max) return REFACTORING_PRIORITIES.LOW.label;
+  if (lineCount < REFACTORING_PRIORITIES.HIGH.threshold) return REFACTORING_PRIORITIES.MEDIUM.label;
+  if (lineCount < REFACTORING_PRIORITIES.CRITICAL.threshold) return REFACTORING_PRIORITIES.HIGH.label;
+  return REFACTORING_PRIORITIES.CRITICAL.label;
+}
+
+/**
+ * Check if a path should be excluded
+ * @param {string} filePath - Path to check
+ * @param {string[]} exclusions - Array of exclusion patterns
+ * @returns {boolean} True if should be excluded
+ */
+function shouldExclude(filePath, exclusions) {
+  return exclusions.some(pattern => filePath.includes(pattern));
+}
+
+/**
+ * Recursively scan directory for source files
+ * @param {string} dirPath - Directory to scan
+ * @param {string[]} extensions - File extensions to include
+ * @param {string[]} exclusions - Patterns to exclude
+ * @returns {string[]} Array of file paths
+ */
+function scanDirectory(dirPath, extensions = ['.js', '.jsx', '.ts', '.tsx'], exclusions = DEFAULT_EXCLUSIONS) {
+  const files = [];
+
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+
+      if (shouldExclude(fullPath, exclusions)) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        files.push(...scanDirectory(fullPath, extensions, exclusions));
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (extensions.includes(ext)) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {
+    // Skip directories we can't read
+  }
+
+  return files;
+}
+
+/**
+ * Analyze a single file
+ * @param {string} filePath - Path to file
+ * @param {string} basePath - Base path for relative path calculation
+ * @returns {Object} File analysis object
+ */
+function analyzeFile(filePath, basePath = process.cwd()) {
+  const lineCount = countLines(filePath);
+  const relativePath = path.relative(basePath, filePath);
+
+  return {
+    filePath: relativePath,
+    absolutePath: filePath,
+    lineCount,
+    sizeCategory: getSizeCategory(lineCount),
+    refactoringPriority: getRefactoringPriority(lineCount),
+    exceedsLimit: lineCount > SIZE_CATEGORIES.LARGE.max,
+    overLimit: Math.max(0, lineCount - SIZE_CATEGORIES.LARGE.max)
+  };
+}
+
+/**
+ * Analyze all files in a directory
+ * @param {string} dirPath - Directory to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Object} Analysis results
+ */
+function analyzeDirectory(dirPath, options = {}) {
+  const {
+    extensions = ['.js', '.jsx', '.ts', '.tsx'],
+    exclusions = DEFAULT_EXCLUSIONS,
+    sortBy = 'lineCount'
+  } = options;
+
+  const files = scanDirectory(dirPath, extensions, exclusions);
+  const analyses = files.map(f => analyzeFile(f, dirPath));
+
+  // Sort by specified field (default: lineCount descending)
+  analyses.sort((a, b) => {
+    if (sortBy === 'lineCount') {
+      return b.lineCount - a.lineCount;
+    }
+    return a[sortBy] > b[sortBy] ? 1 : -1;
+  });
+
+  // Calculate statistics
+  const totalFiles = analyses.length;
+  const violations = analyses.filter(a => a.exceedsLimit);
+  const compliantFiles = totalFiles - violations.length;
+
+  const byCategory = {
+    SMALL: analyses.filter(a => a.sizeCategory === 'SMALL').length,
+    MEDIUM: analyses.filter(a => a.sizeCategory === 'MEDIUM').length,
+    LARGE: analyses.filter(a => a.sizeCategory === 'LARGE').length,
+    XLARGE: analyses.filter(a => a.sizeCategory === 'XLARGE').length
+  };
+
+  const byPriority = {
+    LOW: analyses.filter(a => a.refactoringPriority === 'LOW').length,
+    MEDIUM: analyses.filter(a => a.refactoringPriority === 'MEDIUM').length,
+    HIGH: analyses.filter(a => a.refactoringPriority === 'HIGH').length,
+    CRITICAL: analyses.filter(a => a.refactoringPriority === 'CRITICAL').length
+  };
+
+  return {
+    totalFiles,
+    compliantFiles,
+    violations: violations.length,
+    compliancePercentage: totalFiles > 0 ? (compliantFiles / totalFiles * 100).toFixed(2) : 100,
+    byCategory,
+    byPriority,
+    files: analyses,
+    violatingFiles: violations
+  };
+}
+
+/**
+ * Generate a human-readable report
+ * @param {Object} analysis - Analysis results from analyzeDirectory
+ * @returns {string} Formatted report
+ */
+function generateReport(analysis) {
+  const lines = [];
+
+  lines.push('='.repeat(80));
+  lines.push('FILE SIZE COMPLIANCE REPORT');
+  lines.push('Constitutional Limit: 555 lines per file');
+  lines.push('='.repeat(80));
+  lines.push('');
+
+  lines.push('SUMMARY');
+  lines.push('-'.repeat(80));
+  lines.push(`Total Files Scanned:    ${analysis.totalFiles}`);
+  lines.push(`Compliant Files:        ${analysis.compliantFiles}`);
+  lines.push(`Violations:             ${analysis.violations}`);
+  lines.push(`Compliance Rate:        ${analysis.compliancePercentage}%`);
+  lines.push('');
+
+  lines.push('BY SIZE CATEGORY');
+  lines.push('-'.repeat(80));
+  lines.push(`SMALL (≤200 lines):     ${analysis.byCategory.SMALL}`);
+  lines.push(`MEDIUM (201-400):       ${analysis.byCategory.MEDIUM}`);
+  lines.push(`LARGE (401-555):        ${analysis.byCategory.LARGE}`);
+  lines.push(`XLARGE (>555):          ${analysis.byCategory.XLARGE} ⚠️  VIOLATIONS`);
+  lines.push('');
+
+  lines.push('REFACTORING PRIORITY');
+  lines.push('-'.repeat(80));
+  lines.push(`LOW (compliant):        ${analysis.byPriority.LOW}`);
+  lines.push(`MEDIUM (1-200 over):    ${analysis.byPriority.MEDIUM}`);
+  lines.push(`HIGH (201-500 over):    ${analysis.byPriority.HIGH}`);
+  lines.push(`CRITICAL (500+ over):   ${analysis.byPriority.CRITICAL}`);
+  lines.push('');
+
+  if (analysis.violations > 0) {
+    lines.push('VIOLATIONS (files exceeding 555-line limit)');
+    lines.push('-'.repeat(80));
+
+    analysis.violatingFiles.forEach((file, idx) => {
+      const priority = file.refactoringPriority;
+      const icon = priority === 'CRITICAL' ? '🔴' : priority === 'HIGH' ? '🟠' : '🟡';
+      lines.push(`${icon} [${priority}] ${file.filePath}`);
+      lines.push(`   ${file.lineCount} lines (${file.overLimit} over limit)`);
+    });
+    lines.push('');
+  }
+
+  lines.push('='.repeat(80));
+
+  return lines.join('\n');
+}
+
+module.exports = {
+  countLines,
+  getSizeCategory,
+  getRefactoringPriority,
+  analyzeFile,
+  analyzeDirectory,
+  generateReport,
+  SIZE_CATEGORIES,
+  REFACTORING_PRIORITIES,
+  DEFAULT_EXCLUSIONS
+};

package/src/utils/import-updater.js

@@ -0,0 +1,280 @@
+/**
+ * Import Statement Updater Utility
+ * 
+ * Handles updating import statements when files are refactored or moved.
+ * Supports ES6 imports, CommonJS requires, and dynamic imports.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { parse } = require('@babel/parser');
+const traverse = require('@babel/traverse').default;
+
+class ImportUpdater {
+  constructor(options = {}) {
+    this.options = {
+      dryRun: options.dryRun || false,
+      verbose: options.verbose || false,
+      backup: options.backup !== false,
+      ...options
+    };
+  }
+
+  /**
+   * Update import statements in a file based on a mapping of old to new paths
+   */
+  updateImports(filePath, importMappings) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const updatedContent = this._updateImportStatements(content, importMappings);
+
+    if (updatedContent !== content) {
+      if (this.options.backup) {
+        this._createBackup(filePath, content);
+      }
+
+      if (!this.options.dryRun) {
+        fs.writeFileSync(filePath, updatedContent);
+      }
+
+      if (this.options.verbose) {
+        console.log(`Updated imports in: ${filePath}`);
+      }
+    }
+
+    return updatedContent !== content;
+  }
+
+  /**
+   * Update imports across multiple files
+   */
+  updateImportsBatch(filePaths, importMappings) {
+    const results = {
+      updated: [],
+      failed: [],
+      skipped: []
+    };
+
+    for (const filePath of filePaths) {
+      try {
+        const updated = this.updateImports(filePath, importMappings);
+        if (updated) {
+          results.updated.push(filePath);
+        } else {
+          results.skipped.push(filePath);
+        }
+      } catch (error) {
+        results.failed.push({ filePath, error: error.message });
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Extract all import statements from a file
+   */
+  extractImports(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const imports = [];
+
+    try {
+      const ast = parse(content, {
+        sourceType: 'module',
+        plugins: ['jsx', 'typescript', 'decorators-legacy']
+      });
+
+      traverse(ast, {
+        ImportDeclaration: (path) => {
+          imports.push({
+            type: 'import',
+            source: path.node.source.value,
+            specifiers: path.node.specifiers.map(spec => ({
+              type: spec.type,
+              imported: spec.imported?.name,
+              local: spec.local.name,
+              default: spec.type === 'ImportDefaultSpecifier'
+            })),
+            line: path.node.loc?.start.line
+          });
+        },
+        CallExpression: (path) => {
+          if (path.node.callee.name === 'require') {
+            const arg = path.node.arguments[0];
+            if (arg && arg.type === 'StringLiteral') {
+              imports.push({
+                type: 'require',
+                source: arg.value,
+                line: path.node.loc?.start.line
+              });
+            }
+          }
+        },
+        Import: (path) => {
+          if (path.parent.type === 'CallExpression' && 
+              path.parent.callee.type === 'Import') {
+            const arg = path.parent.arguments[0];
+            if (arg && arg.type === 'StringLiteral') {
+              imports.push({
+                type: 'dynamic',
+                source: arg.value,
+                line: path.node.loc?.start.line
+              });
+            }
+          }
+        }
+      });
+    } catch (error) {
+      // Fallback to regex parsing if AST parsing fails
+      return this._extractImportsRegex(content);
+    }
+
+    return imports;
+  }
+
+  /**
+   * Generate import mappings based on file movements
+   */
+  generateImportMappings(fileMovements) {
+    const mappings = {};
+
+    for (const movement of fileMovements) {
+      const { oldPath, newPath } = movement;
+      const oldDir = path.dirname(oldPath);
+      const newDir = path.dirname(newPath);
+
+      // Generate relative path mappings
+      const relativeMappings = this._generateRelativeMappings(oldDir, newDir);
+      Object.assign(mappings, relativeMappings);
+    }
+
+    return mappings;
+  }
+
+  /**
+   * Update import statements in content
+   */
+  _updateImportStatements(content, importMappings) {
+    let updatedContent = content;
+
+    // Update ES6 imports
+    updatedContent = this._updateES6Imports(updatedContent, importMappings);
+    
+    // Update CommonJS requires
+    updatedContent = this._updateCommonJSRequires(updatedContent, importMappings);
+    
+    // Update dynamic imports
+    updatedContent = this._updateDynamicImports(updatedContent, importMappings);
+
+    return updatedContent;
+  }
+
+  /**
+   * Update ES6 import statements
+   */
+  _updateES6Imports(content, importMappings) {
+    const importRegex = /(import\s+(?:.*?\s+from\s+)?['"])([^'"]+)(['"])/g;
+    
+    return content.replace(importRegex, (match, prefix, importPath, suffix) => {
+      const updatedPath = this._resolveImportPath(importPath, importMappings);
+      return prefix + updatedPath + suffix;
+    });
+  }
+
+  /**
+   * Update CommonJS require statements
+   */
+  _updateCommonJSRequires(content, importMappings) {
+    const requireRegex = /(require\s*\(\s*['"])([^'"]+)(['"]\s*\))/g;
+    
+    return content.replace(requireRegex, (match, prefix, requirePath, suffix) => {
+      const updatedPath = this._resolveImportPath(requirePath, importMappings);
+      return prefix + updatedPath + suffix;
+    });
+  }
+
+  /**
+   * Update dynamic import statements
+   */
+  _updateDynamicImports(content, importMappings) {
+    const dynamicImportRegex = /(import\s*\(\s*['"])([^'"]+)(['"]\s*\))/g;
+    
+    return content.replace(dynamicImportRegex, (match, prefix, importPath, suffix) => {
+      const updatedPath = this._resolveImportPath(importPath, importMappings);
+      return prefix + updatedPath + suffix;
+    });
+  }
+
+  /**
+   * Resolve import path based on mappings
+   */
+  _resolveImportPath(importPath, mappings) {
+    // Direct mapping
+    if (mappings[importPath]) {
+      return mappings[importPath];
+    }
+
+    // Try to resolve relative paths
+    for (const [oldPath, newPath] of Object.entries(mappings)) {
+      if (importPath.startsWith(oldPath)) {
+        return importPath.replace(oldPath, newPath);
+      }
+    }
+
+    return importPath;
+  }
+
+  /**
+   * Generate relative path mappings
+   */
+  _generateRelativeMappings(oldDir, newDir) {
+    const mappings = {};
+    
+    // This is a simplified implementation
+    // In practice, you'd need to consider all possible relative paths
+    // that could reference the moved file
+    
+    return mappings;
+  }
+
+  /**
+   * Extract imports using regex (fallback method)
+   */
+  _extractImportsRegex(content) {
+    const imports = [];
+    
+    // ES6 imports
+    const importRegex = /import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      imports.push({
+        type: 'import',
+        source: match[1]
+      });
+    }
+
+    // CommonJS requires
+    const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+    while ((match = requireRegex.exec(content)) !== null) {
+      imports.push({
+        type: 'require',
+        source: match[1]
+      });
+    }
+
+    return imports;
+  }
+
+  /**
+   * Create backup of original file
+   */
+  _createBackup(filePath, content) {
+    const backupPath = `${filePath}.backup.${Date.now()}`;
+    fs.writeFileSync(backupPath, content);
+  }
+}
+
+module.exports = ImportUpdater;