vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/analysis/categorizer.js

@@ -0,0 +1,340 @@
+/**
+ * File Categorizer
+ * 
+ * Categorizes files based on size, complexity, and refactoring priority.
+ * Provides consistent categorization across the analysis pipeline.
+ */
+
+const RefactoringConfig = require('../config/refactoring-config');
+
+/**
+ * File size categories
+ */
+const SIZE_CATEGORIES = {
+  SMALL: 'SMALL',
+  MEDIUM: 'MEDIUM', 
+  LARGE: 'LARGE',
+  XLARGE: 'XLARGE'
+};
+
+/**
+ * Priority categories
+ */
+const PRIORITY_CATEGORIES = {
+  LOW: 'LOW',
+  MEDIUM: 'MEDIUM',
+  HIGH: 'HIGH',
+  CRITICAL: 'CRITICAL'
+};
+
+/**
+ * Complexity categories
+ */
+const COMPLEXITY_CATEGORIES = {
+  SIMPLE: 'SIMPLE',
+  MODERATE: 'MODERATE',
+  COMPLEX: 'COMPLEX',
+  VERY_COMPLEX: 'VERY_COMPLEX'
+};
+
+/**
+ * File categorizer class
+ */
+class FileCategorizer {
+  constructor(config = RefactoringConfig) {
+    this.config = config;
+    this.limits = config.limits;
+  }
+
+  /**
+   * Categorize file by size
+   */
+  categorizeBySize(lineCount) {
+    if (lineCount <= this.limits.smallFileMax) {
+      return SIZE_CATEGORIES.SMALL;
+    } else if (lineCount <= this.limits.mediumFileMax) {
+      return SIZE_CATEGORIES.MEDIUM;
+    } else if (lineCount <= this.limits.largeFileMax) {
+      return SIZE_CATEGORIES.LARGE;
+    } else {
+      return SIZE_CATEGORIES.XLARGE;
+    }
+  }
+
+  /**
+   * Categorize file by priority
+   */
+  categorizeByPriority(fileAnalysis) {
+    const { lineCount, complexity, isTestFile, isConfigFile, package: packageName } = fileAnalysis;
+    
+    // Critical priority: files way over the limit
+    if (lineCount > this.limits.criticalThreshold) {
+      return PRIORITY_CATEGORIES.CRITICAL;
+    }
+
+    // High priority: files over the limit
+    if (lineCount > this.limits.maxFileSize) {
+      return PRIORITY_CATEGORIES.HIGH;
+    }
+
+    // Medium priority: files approaching the limit
+    if (lineCount > this.limits.warningThreshold) {
+      return PRIORITY_CATEGORIES.MEDIUM;
+    }
+
+    // Consider complexity for medium priority
+    if (complexity >= COMPLEXITY_CATEGORIES.COMPLEX && lineCount > this.limits.mediumFileMax) {
+      return PRIORITY_CATEGORIES.MEDIUM;
+    }
+
+    // Low priority for everything else
+    return PRIORITY_CATEGORIES.LOW;
+  }
+
+  /**
+   * Categorize file by complexity
+   */
+  categorizeByComplexity(fileAnalysis) {
+    const { cyclomaticComplexity, nestingDepth, functionCount, classCount } = fileAnalysis;
+    
+    // Use multiple factors for complexity assessment
+    const complexityScore = this._calculateComplexityScore({
+      cyclomaticComplexity,
+      nestingDepth,
+      functionCount,
+      classCount
+    });
+
+    if (complexityScore >= 80) {
+      return COMPLEXITY_CATEGORIES.VERY_COMPLEX;
+    } else if (complexityScore >= 60) {
+      return COMPLEXITY_CATEGORIES.COMPLEX;
+    } else if (complexityScore >= 30) {
+      return COMPLEXITY_CATEGORIES.MODERATE;
+    } else {
+      return COMPLEXITY_CATEGORIES.SIMPLE;
+    }
+  }
+
+  /**
+   * Categorize file by refactoring difficulty
+   */
+  categorizeByDifficulty(fileAnalysis) {
+    const { lineCount, complexity, hasImports, hasExports, dependencyCount } = fileAnalysis;
+    
+    let difficultyScore = 0;
+    
+    // Size contribution
+    if (lineCount > 1000) difficultyScore += 40;
+    else if (lineCount > 555) difficultyScore += 30;
+    else if (lineCount > 300) difficultyScore += 20;
+    else if (lineCount > 100) difficultyScore += 10;
+    
+    // Complexity contribution
+    if (complexity === COMPLEXITY_CATEGORIES.VERY_COMPLEX) difficultyScore += 30;
+    else if (complexity === COMPLEXITY_CATEGORIES.COMPLEX) difficultyScore += 20;
+    else if (complexity === COMPLEXITY_CATEGORIES.MODERATE) difficultyScore += 10;
+    
+    // Dependencies contribution
+    if (dependencyCount > 20) difficultyScore += 20;
+    else if (dependencyCount > 10) difficultyScore += 10;
+    else if (dependencyCount > 5) difficultyScore += 5;
+    
+    // Import/Export complexity
+    if (hasImports && hasExports) difficultyScore += 10;
+    else if (hasImports || hasExports) difficultyScore += 5;
+
+    if (difficultyScore >= 70) return 'VERY_DIFFICULT';
+    if (difficultyScore >= 50) return 'DIFFICULT';
+    if (difficultyScore >= 30) return 'MODERATE';
+    return 'EASY';
+  }
+
+  /**
+   * Get comprehensive categorization for a file
+   */
+  categorizeFile(fileAnalysis) {
+    const sizeCategory = this.categorizeBySize(fileAnalysis.lineCount);
+    const priorityCategory = this.categorizeByPriority(fileAnalysis);
+    const complexityCategory = this.categorizeByComplexity(fileAnalysis);
+    const difficultyCategory = this.categorizeByDifficulty(fileAnalysis);
+
+    return {
+      size: sizeCategory,
+      priority: priorityCategory,
+      complexity: complexityCategory,
+      difficulty: difficultyCategory,
+      needsRefactoring: sizeCategory === SIZE_CATEGORIES.LARGE || sizeCategory === SIZE_CATEGORIES.XLARGE,
+      urgentRefactoring: sizeCategory === SIZE_CATEGORIES.XLARGE || priorityCategory === PRIORITY_CATEGORIES.CRITICAL,
+      recommendedAction: this._getRecommendedAction(sizeCategory, priorityCategory, complexityCategory),
+      estimatedEffort: this._estimateEffort(sizeCategory, difficultyCategory)
+    };
+  }
+
+  /**
+   * Categorize multiple files
+   */
+  categorizeFiles(fileAnalyses) {
+    const categorizedFiles = [];
+    const summary = {
+      total: fileAnalyses.length,
+      bySize: {},
+      byPriority: {},
+      byComplexity: {},
+      byDifficulty: {},
+      needsRefactoring: 0,
+      urgentRefactoring: 0
+    };
+
+    // Initialize summary counters
+    Object.values(SIZE_CATEGORIES).forEach(cat => summary.bySize[cat] = 0);
+    Object.values(PRIORITY_CATEGORIES).forEach(cat => summary.byPriority[cat] = 0);
+    Object.values(COMPLEXITY_CATEGORIES).forEach(cat => summary.byComplexity[cat] = 0);
+    ['EASY', 'MODERATE', 'DIFFICULT', 'VERY_DIFFICULT'].forEach(cat => summary.byDifficulty[cat] = 0);
+
+    for (const fileAnalysis of fileAnalyses) {
+      const categorization = this.categorizeFile(fileAnalysis);
+      
+      categorizedFiles.push({
+        ...fileAnalysis,
+        categorization
+      });
+
+      // Update summary
+      summary.bySize[categorization.size]++;
+      summary.byPriority[categorization.priority]++;
+      summary.byComplexity[categorization.complexity]++;
+      summary.byDifficulty[categorization.difficulty]++;
+      
+      if (categorization.needsRefactoring) summary.needsRefactoring++;
+      if (categorization.urgentRefactoring) summary.urgentRefactoring++;
+    }
+
+    return {
+      files: categorizedFiles,
+      summary
+    };
+  }
+
+  /**
+   * Get category thresholds
+   */
+  getCategoryThresholds() {
+    return {
+      size: {
+        [SIZE_CATEGORIES.SMALL]: `≤ ${this.limits.smallFileMax} lines`,
+        [SIZE_CATEGORIES.MEDIUM]: `${this.limits.smallFileMax + 1}-${this.limits.mediumFileMax} lines`,
+        [SIZE_CATEGORIES.LARGE]: `${this.limits.mediumFileMax + 1}-${this.limits.largeFileMax} lines`,
+        [SIZE_CATEGORIES.XLARGE]: `> ${this.limits.largeFileMax} lines`
+      },
+      priority: {
+        [PRIORITY_CATEGORIES.LOW]: 'Well within limits',
+        [PRIORITY_CATEGORIES.MEDIUM]: 'Approaching limits',
+        [PRIORITY_CATEGORIES.HIGH]: 'Exceeds limits',
+        [PRIORITY_CATEGORIES.CRITICAL]: 'Far exceeds limits'
+      },
+      complexity: {
+        [COMPLEXITY_CATEGORIES.SIMPLE]: 'Low complexity',
+        [COMPLEXITY_CATEGORIES.MODERATE]: 'Moderate complexity',
+        [COMPLEXITY_CATEGORIES.COMPLEX]: 'High complexity',
+        [COMPLEXITY_CATEGORIES.VERY_COMPLEX]: 'Very high complexity'
+      }
+    };
+  }
+
+  /**
+   * Calculate complexity score
+   */
+  _calculateComplexityScore(metrics) {
+    let score = 0;
+    
+    // Cyclomatic complexity contribution (0-40 points)
+    if (metrics.cyclomaticComplexity >= 50) score += 40;
+    else if (metrics.cyclomaticComplexity >= 20) score += 30;
+    else if (metrics.cyclomaticComplexity >= 10) score += 20;
+    else if (metrics.cyclomaticComplexity >= 5) score += 10;
+    
+    // Nesting depth contribution (0-30 points)
+    if (metrics.nestingDepth >= 8) score += 30;
+    else if (metrics.nestingDepth >= 5) score += 20;
+    else if (metrics.nestingDepth >= 3) score += 10;
+    
+    // Function count contribution (0-20 points)
+    if (metrics.functionCount >= 20) score += 20;
+    else if (metrics.functionCount >= 10) score += 15;
+    else if (metrics.functionCount >= 5) score += 10;
+    else if (metrics.functionCount >= 2) score += 5;
+    
+    // Class count contribution (0-10 points)
+    if (metrics.classCount >= 5) score += 10;
+    else if (metrics.classCount >= 3) score += 7;
+    else if (metrics.classCount >= 2) score += 5;
+    else if (metrics.classCount >= 1) score += 3;
+    
+    return Math.min(score, 100);
+  }
+
+  /**
+   * Get recommended action based on categorization
+   */
+  _getRecommendedAction(sizeCategory, priorityCategory, complexityCategory) {
+    if (sizeCategory === SIZE_CATEGORIES.XLARGE || priorityCategory === PRIORITY_CATEGORIES.CRITICAL) {
+      return 'IMMEDIATE_REFACTORING';
+    }
+    
+    if (sizeCategory === SIZE_CATEGORIES.LARGE || priorityCategory === PRIORITY_CATEGORIES.HIGH) {
+      return 'SCHEDULE_REFACTORING';
+    }
+    
+    if (priorityCategory === PRIORITY_CATEGORIES.MEDIUM && complexityCategory === COMPLEXITY_CATEGORIES.COMPLEX) {
+      return 'PLAN_REFACTORING';
+    }
+    
+    if (complexityCategory === COMPLEXITY_CATEGORIES.VERY_COMPLEX) {
+      return 'CONSIDER_REFACTORING';
+    }
+    
+    return 'MONITOR';
+  }
+
+  /**
+   * Estimate refactoring effort
+   */
+  _estimateEffort(sizeCategory, difficultyCategory) {
+    const effortMatrix = {
+      [SIZE_CATEGORIES.SMALL]: {
+        'EASY': 'MINIMAL',
+        'MODERATE': 'LOW',
+        'DIFFICULT': 'MEDIUM',
+        'VERY_DIFFICULT': 'HIGH'
+      },
+      [SIZE_CATEGORIES.MEDIUM]: {
+        'EASY': 'LOW',
+        'MODERATE': 'MEDIUM',
+        'DIFFICULT': 'HIGH',
+        'VERY_DIFFICULT': 'VERY_HIGH'
+      },
+      [SIZE_CATEGORIES.LARGE]: {
+        'EASY': 'MEDIUM',
+        'MODERATE': 'HIGH',
+        'DIFFICULT': 'VERY_HIGH',
+        'VERY_DIFFICULT': 'EXTREME'
+      },
+      [SIZE_CATEGORIES.XLARGE]: {
+        'EASY': 'HIGH',
+        'MODERATE': 'VERY_HIGH',
+        'DIFFICULT': 'EXTREME',
+        'VERY_DIFFICULT': 'MAJOR'
+      }
+    };
+
+    return effortMatrix[sizeCategory]?.[difficultyCategory] || 'UNKNOWN';
+  }
+}
+
+module.exports = {
+  FileCategorizer,
+  SIZE_CATEGORIES,
+  PRIORITY_CATEGORIES,
+  COMPLEXITY_CATEGORIES
+};

package/src/analysis/codebase-scanner.js

@@ -0,0 +1,384 @@
+/**
+ * Codebase Scanner
+ * 
+ * Scans the entire codebase to identify files for analysis,
+ * excluding third-party libraries and generated files.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const RefactoringConfig = require('../config/refactoring-config');
+
+/**
+ * Scanner result class
+ */
+class ScanResult {
+  constructor(filePath, stats) {
+    this.path = filePath;
+    this.size = stats.size;
+    this.modified = stats.mtime;
+    this.created = stats.birthtime || stats.ctime;
+    this.isDirectory = stats.isDirectory();
+    this.extension = path.extname(filePath);
+    this.basename = path.basename(filePath);
+    this.relativePath = path.relative(process.cwd(), filePath);
+    this.package = this.extractPackage();
+    this.shouldAnalyze = this.shouldIncludeInAnalysis();
+  }
+
+  extractPackage() {
+    const match = this.relativePath.match(/packages\/([^\/]+)/);
+    return match ? match[1] : 'root';
+  }
+
+  shouldIncludeInAnalysis() {
+    // Skip directories
+    if (this.isDirectory) return false;
+
+    // Check exclusions
+    if (RefactoringConfig.isExcluded(this.path)) return false;
+
+    // Check file extensions
+    const ext = this.extension.toLowerCase();
+    const allowedExtensions = ['.js', '.jsx', '.ts', '.tsx', '.md', '.json', '.yml', '.yaml'];
+    
+    return allowedExtensions.includes(ext);
+  }
+}
+
+/**
+ * Codebase scanner class
+ */
+class CodebaseScanner {
+  constructor(config = RefactoringConfig) {
+    this.config = config;
+    this.results = [];
+    this.stats = {
+      totalFiles: 0,
+      analyzedFiles: 0,
+      excludedFiles: 0,
+      directories: 0,
+      errors: 0
+    };
+  }
+
+  /**
+   * Scan the entire codebase
+   */
+  async scan(rootPath = process.cwd()) {
+    console.log(`Scanning codebase from: ${rootPath}`);
+    
+    this.results = [];
+    this.resetStats();
+    
+    try {
+      await this.scanDirectory(rootPath);
+      console.log(`Scan completed: ${this.stats.analyzedFiles} files to analyze, ${this.stats.excludedFiles} excluded`);
+      return this.results;
+    } catch (error) {
+      console.error(`Scan failed: ${error.message}`);
+      throw error;
+    }
+  }
+
+  /**
+   * Scan a single directory recursively
+   */
+  async scanDirectory(dirPath) {
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        
+        try {
+          const stats = fs.statSync(fullPath);
+          const result = new ScanResult(fullPath, stats);
+          
+          if (entry.isDirectory()) {
+            this.stats.directories++;
+            
+            // Skip excluded directories
+            if (!this.shouldSkipDirectory(fullPath)) {
+              await this.scanDirectory(fullPath);
+            }
+          } else {
+            this.stats.totalFiles++;
+            
+            if (result.shouldAnalyze) {
+              this.results.push(result);
+              this.stats.analyzedFiles++;
+            } else {
+              this.stats.excludedFiles++;
+            }
+          }
+        } catch (error) {
+          this.stats.errors++;
+          console.warn(`Error scanning ${fullPath}: ${error.message}`);
+        }
+      }
+    } catch (error) {
+      this.stats.errors++;
+      throw new Error(`Failed to scan directory ${dirPath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check if directory should be skipped
+   */
+  shouldSkipDirectory(dirPath) {
+    const dirName = path.basename(dirPath);
+    const relativePath = path.relative(process.cwd(), dirPath);
+    
+    // Skip common excluded directories
+    const excludedDirs = [
+      'node_modules',
+      '.git',
+      'dist',
+      'build',
+      'coverage',
+      '.nyc_output',
+      '.vscode',
+      '.idea',
+      '.cursor',
+      '.windsurf',
+      'vendor',
+      'bower_components',
+      '.refactoring-backups'
+    ];
+
+    // Check if directory name is excluded
+    if (excludedDirs.includes(dirName)) {
+      return true;
+    }
+
+    // Check if relative path contains excluded directories
+    for (const excludedDir of excludedDirs) {
+      if (relativePath.includes(path.sep + excludedDir + path.sep) ||
+          relativePath.startsWith(excludedDir + path.sep)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get files by package
+   */
+  getFilesByPackage() {
+    const byPackage = {};
+    
+    for (const result of this.results) {
+      if (!byPackage[result.package]) {
+        byPackage[result.package] = [];
+      }
+      byPackage[result.package].push(result);
+    }
+
+    return byPackage;
+  }
+
+  /**
+   * Get files by extension
+   */
+  getFilesByExtension() {
+    const byExtension = {};
+    
+    for (const result of this.results) {
+      if (!byExtension[result.extension]) {
+        byExtension[result.extension] = [];
+      }
+      byExtension[result.extension].push(result);
+    }
+
+    return byExtension;
+  }
+
+  /**
+   * Get files by size range
+   */
+  getFilesBySizeRange() {
+    const ranges = {
+      small: [],      // 0-100 lines (estimated)
+      medium: [],     // 101-300 lines
+      large: [],      // 301-555 lines
+      xlarge: []      // 556+ lines
+    };
+
+    for (const result of this.results) {
+      // Estimate line count from file size (rough approximation)
+      const estimatedLines = Math.ceil(result.size / 50); // ~50 chars per line
+      
+      if (estimatedLines <= 100) ranges.small.push(result);
+      else if (estimatedLines <= 300) ranges.medium.push(result);
+      else if (estimatedLines <= 555) ranges.large.push(result);
+      else ranges.xlarge.push(result);
+    }
+
+    return ranges;
+  }
+
+  /**
+   * Filter results by criteria
+   */
+  filter(criteria = {}) {
+    let filtered = [...this.results];
+
+    if (criteria.package) {
+      filtered = filtered.filter(result => result.package === criteria.package);
+    }
+
+    if (criteria.extension) {
+      filtered = filtered.filter(result => result.extension === criteria.extension);
+    }
+
+    if (criteria.minSize) {
+      filtered = filtered.filter(result => result.size >= criteria.minSize);
+    }
+
+    if (criteria.maxSize) {
+      filtered = filtered.filter(result => result.size <= criteria.maxSize);
+    }
+
+    if (criteria.pattern) {
+      const regex = new RegExp(criteria.pattern, 'i');
+      filtered = filtered.filter(result => 
+        regex.test(result.basename) || regex.test(result.relativePath)
+      );
+    }
+
+    return filtered;
+  }
+
+  /**
+   * Find recently modified files
+   */
+  getRecentlyModified(days = 7) {
+    const cutoff = new Date(Date.now() - (days * 24 * 60 * 60 * 1000));
+    
+    return this.results.filter(result => result.modified > cutoff);
+  }
+
+  /**
+   * Find large files (by size estimation)
+   */
+  getLargeFiles(minLines = 556) {
+    return this.results.filter(result => {
+      const estimatedLines = Math.ceil(result.size / 50);
+      return estimatedLines >= minLines;
+    });
+  }
+
+  /**
+   * Get scan statistics
+   */
+  getStatistics() {
+    const stats = { ...this.stats };
+    
+    // Calculate additional statistics
+    stats.totalSize = this.results.reduce((sum, result) => sum + result.size, 0);
+    stats.averageFileSize = stats.analyzedFiles > 0 ? Math.round(stats.totalSize / stats.analyzedFiles) : 0;
+    stats.largestFile = this.results.reduce((largest, result) => 
+      result.size > (largest?.size || 0) ? result : largest, null
+    );
+    stats.smallestFile = this.results.reduce((smallest, result) => 
+      result.size < (smallest?.size || Infinity) ? result : smallest, null
+    );
+
+    // Package distribution
+    stats.packageDistribution = {};
+    for (const result of this.results) {
+      if (!stats.packageDistribution[result.package]) {
+        stats.packageDistribution[result.package] = 0;
+      }
+      stats.packageDistribution[result.package]++;
+    }
+
+    // Extension distribution
+    stats.extensionDistribution = {};
+    for (const result of this.results) {
+      if (!stats.extensionDistribution[result.extension]) {
+        stats.extensionDistribution[result.extension] = 0;
+      }
+      stats.extensionDistribution[result.extension]++;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Export results to JSON
+   */
+  exportToJson(filePath) {
+    const exportData = {
+      metadata: {
+        scannedAt: new Date().toISOString(),
+        rootPath: process.cwd(),
+        config: this.config.reporting || {}
+      },
+      statistics: this.getStatistics(),
+      results: this.results.map(result => ({
+        path: result.path,
+        relativePath: result.relativePath,
+        package: result.package,
+        size: result.size,
+        extension: result.extension,
+        modified: result.modified.toISOString(),
+        shouldAnalyze: result.shouldAnalyze
+      }))
+    };
+
+    fs.writeFileSync(filePath, JSON.stringify(exportData, null, 2));
+    return filePath;
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      totalFiles: 0,
+      analyzedFiles: 0,
+      excludedFiles: 0,
+      directories: 0,
+      errors: 0
+    };
+  }
+
+  /**
+   * Validate scan results
+   */
+  validate() {
+    const issues = [];
+    
+    // Check if we have any results
+    if (this.results.length === 0) {
+      issues.push('No files found for analysis');
+    }
+
+    // Check for errors during scanning
+    if (this.stats.errors > 0) {
+      issues.push(`${this.stats.errors} errors occurred during scanning`);
+    }
+
+    // Check for excluded files ratio
+    const exclusionRatio = this.stats.totalFiles > 0 ? 
+      (this.stats.excludedFiles / this.stats.totalFiles) : 0;
+    
+    if (exclusionRatio > 0.9) {
+      issues.push('Very high exclusion ratio - check configuration');
+    }
+
+    return {
+      isValid: issues.length === 0,
+      issues,
+      stats: this.stats
+    };
+  }
+}
+
+module.exports = {
+  CodebaseScanner,
+  ScanResult
+};