vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/commands/analyze-file-sizes.js

@@ -0,0 +1,428 @@
+/**
+ * CLI Command: Analyze File Sizes
+ * 
+ * Command-line interface for analyzing file sizes across the codebase.
+ * Provides comprehensive analysis and refactoring recommendations.
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+// Import analysis components
+const { CodebaseScanner } = require('@vibecodingmachine/core/src/analysis/codebase-scanner');
+const { LineCounter } = require('@vibecodingmachine/core/src/analysis/line-counter');
+const { FileCategorizer } = require('@vibecodingmachine/core/src/analysis/categorizer');
+const { BoundaryDetector } = require('@vibecodingmachine/core/src/analysis/boundary-detector');
+const { StrategyGenerator } = require('@vibecodingmachine/core/src/analysis/strategy-generator');
+const { PriorityCalculator } = require('@vibecodingmachine/core/src/analysis/priority-calculator');
+const { AnalysisReporter } = require('@vibecodingmachine/core/src/analysis/analysis-reporter');
+const { FileAnalysis } = require('@vibecodingmachine/core/src/models/file-analysis');
+const { FileAnalysisCollection } = require('@vibecodingmachine/core/src/models/file-analysis');
+
+/**
+ * Analyze file sizes command
+ */
+class AnalyzeFileSizesCommand {
+  constructor() {
+    this.command = new Command('analyze-file-sizes');
+    this.setupCommand();
+  }
+
+  setupCommand() {
+    this.command
+      .description('Analyze file sizes across the codebase and generate refactoring recommendations')
+      .option('-p, --path <path>', 'Path to analyze (default: current directory)', process.cwd())
+      .option('-o, --output <path>', 'Output file for the report')
+      .option('-f, --format <format>', 'Report format (json, markdown, html)', 'json')
+      .option('--include-tests', 'Include test files in analysis', false)
+      .option('--include-vendor', 'Include vendor/third-party files', false)
+      .option('--max-depth <depth>', 'Maximum directory depth to scan', '10')
+      .option('--min-lines <lines>', 'Minimum lines to include in detailed analysis', '10')
+      .option('--limit <lines>', 'File size limit to check against', '555')
+      .option('--verbose', 'Verbose output', false)
+      .option('--quiet', 'Minimal output', false)
+      .action(async (options) => {
+        try {
+          await this.execute(options);
+        } catch (error) {
+          console.error(chalk.red('Error:'), error.message);
+          if (options.verbose) {
+            console.error(error.stack);
+          }
+          process.exit(1);
+        }
+      });
+  }
+
+  async execute(options) {
+    const startTime = Date.now();
+    
+    if (!options.quiet) {
+      console.log(chalk.blue('🔍 Starting file size analysis...'));
+      console.log(chalk.gray(`Path: ${options.path}`));
+      console.log(chalk.gray(`Format: ${options.format}`));
+      if (options.output) {
+        console.log(chalk.gray(`Output: ${options.output}`));
+      }
+      console.log();
+    }
+
+    // Step 1: Scan codebase
+    const scanResults = await this.scanCodebase(options);
+    
+    // Step 2: Count lines
+    const lineResults = await this.countLines(scanResults, options);
+    
+    // Step 3: Categorize files
+    const categorizationResults = await this.categorizeFiles(lineResults, options);
+    
+    // Step 4: Detect boundaries
+    const boundaryResults = await this.detectBoundaries(lineResults, options);
+    
+    // Step 5: Calculate priorities
+    const priorityResults = await this.calculatePriorities(lineResults, boundaryResults, options);
+    
+    // Step 6: Generate strategies
+    const strategyResults = await this.generateStrategies(lineResults, priorityResults, options);
+    
+    // Step 7: Generate report
+    const reportResults = await this.generateReport(
+      lineResults, 
+      categorizationResults, 
+      priorityResults, 
+      strategyResults, 
+      options
+    );
+
+    const duration = Date.now() - startTime;
+    
+    if (!options.quiet) {
+      this.printSummary(reportResults, duration);
+    }
+
+    if (options.output) {
+      await this.saveReport(reportResults, options);
+    }
+
+    return reportResults;
+  }
+
+  async scanCodebase(options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('📁 Scanning codebase...'));
+    }
+
+    const scanner = new CodebaseScanner();
+    const results = await scanner.scan(options.path);
+
+    if (options.verbose) {
+      console.log(chalk.gray(`Found ${results.length} files to analyze`));
+    }
+
+    return results;
+  }
+
+  async countLines(scanResults, options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('📏 Counting lines...'));
+    }
+
+    const lineCounter = new LineCounter();
+    const filePaths = scanResults.map(result => result.path);
+    const lineResults = lineCounter.countFiles(filePaths);
+
+    // Create file analysis objects
+    const fileAnalyses = [];
+    for (let i = 0; i < scanResults.length; i++) {
+      const scanResult = scanResults[i];
+      const lineResult = lineResults[i];
+
+      const analysis = new FileAnalysis(scanResult.path);
+      analysis.setLineCountMetrics(
+        lineResult.totalLines,
+        lineResult.codeLines,
+        lineResult.commentLines,
+        lineResult.blankLines
+      );
+      analysis.setFileTypeFlags(
+        lineResult.extension.includes('test') || scanResult.relativePath.includes('test'),
+        scanResult.basename.includes('config') || scanResult.basename.includes('package'),
+        scanResult.basename.includes('generated') || scanResult.basename.includes('auto')
+      );
+      analysis.setTimestamps(
+        scanResult.modified,
+        scanResult.created
+      );
+
+      fileAnalyses.push(analysis);
+    }
+
+    if (options.verbose) {
+      const totalLines = fileAnalyses.reduce((sum, f) => sum + f.lineCount, 0);
+      console.log(chalk.gray(`Analyzed ${fileAnalyses.length} files with ${totalLines} total lines`));
+    }
+
+    return fileAnalyses;
+  }
+
+  async categorizeFiles(lineResults, options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('📂 Categorizing files...'));
+    }
+
+    const categorizer = new FileCategorizer();
+    const fileData = lineResults.map(analysis => ({
+      filePath: analysis.filePath,
+      lineCount: analysis.lineCount,
+      fileType: analysis.extension,
+      package: analysis.package
+    }));
+
+    const categorizationResults = categorizer.categorizeFiles(fileData);
+
+    // Update file analyses with categorization
+    for (let i = 0; i < lineResults.length; i++) {
+      const analysis = lineResults[i];
+      const categorization = categorizationResults.files[i];
+      
+      if (categorization && categorization.categorization) {
+        analysis.setClassification(
+          categorization.categorization.size,
+          categorization.categorization.priority,
+          categorization.categorization.difficulty,
+          categorization.categorization.needsRefactoring,
+          categorization.categorization.urgentRefactoring
+        );
+      }
+    }
+
+    return categorizationResults;
+  }
+
+  async detectBoundaries(lineResults, options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('🔍 Detecting code boundaries...'));
+    }
+
+    const boundaryDetector = new BoundaryDetector();
+    const boundaryResults = new Map();
+
+    // Only analyze JavaScript/TypeScript files for boundaries
+    const jsFiles = lineResults.filter(analysis => 
+      ['.js', '.jsx', '.ts', '.tsx'].includes(analysis.extension)
+    );
+
+    for (let i = 0; i < jsFiles.length; i++) {
+      const analysis = jsFiles[i];
+      
+      try {
+        const boundaryResult = await boundaryDetector.detectBoundaries(analysis.filePath);
+        boundaryResults.set(analysis.filePath, boundaryResult);
+        
+        // Update analysis with boundary data
+        analysis.setBoundaries(boundaryResult);
+        
+        if (options.verbose && i % 10 === 0) {
+          console.log(chalk.gray(`Analyzed boundaries for ${i + 1}/${jsFiles.length} files`));
+        }
+      } catch (error) {
+        analysis.addError(`Boundary detection failed: ${error.message}`);
+      }
+    }
+
+    if (options.verbose) {
+      console.log(chalk.gray(`Detected boundaries in ${boundaryResults.size} files`));
+    }
+
+    return boundaryResults;
+  }
+
+  async calculatePriorities(lineResults, boundaryResults, options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('🎯 Calculating priorities...'));
+    }
+
+    const priorityCalculator = new PriorityCalculator();
+    const priorityResults = priorityCalculator.calculatePriorities(lineResults);
+
+    // Update file analyses with priority data
+    for (let i = 0; i < lineResults.length; i++) {
+      const analysis = lineResults[i];
+      const priorityResult = priorityResults[i];
+      
+      if (priorityResult) {
+        analysis.priority = priorityResult.priority;
+        // Add priority reasons as warnings
+        for (const reason of priorityResult.reasons) {
+          analysis.addWarning(reason);
+        }
+      }
+    }
+
+    return priorityResults;
+  }
+
+  async generateStrategies(lineResults, priorityResults, options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('📋 Generating refactoring strategies...'));
+    }
+
+    // Create analysis collection
+    const collection = new FileAnalysisCollection();
+    for (const analysis of lineResults) {
+      collection.add(analysis);
+    }
+
+    const strategyGenerator = new StrategyGenerator();
+    const analysisData = {
+      files: lineResults,
+      summary: collection.getSummary()
+    };
+
+    const strategies = strategyGenerator.generateStrategies(analysisData);
+
+    if (options.verbose) {
+      console.log(chalk.gray(`Generated ${strategies.length} refactoring strategies`));
+    }
+
+    return strategies;
+  }
+
+  async generateReport(lineResults, categorizationResults, priorityResults, strategies, options) {
+    if (!options.quiet) {
+      console.log(chalk.yellow('📊 Generating analysis report...'));
+    }
+
+    const reporter = new AnalysisReporter();
+    
+    // Create analysis data for reporter
+    const analysisData = {
+      files: lineResults,
+      summary: {
+        totalFiles: lineResults.length,
+        filesNeedingRefactoring: lineResults.filter(f => f.needsRefactoring).length,
+        urgentRefactoring: lineResults.filter(f => f.urgentRefactoring).length,
+        totalLines: lineResults.reduce((sum, f) => sum + f.lineCount, 0)
+      }
+    };
+
+    const reportOptions = {
+      format: options.format,
+      outputPath: options.output,
+      scope: 'full_codebase',
+      packages: [...new Set(lineResults.map(f => f.package))]
+    };
+
+    const reportResult = await reporter.generateReport(analysisData, reportOptions);
+
+    return {
+      reportData: reporter.report,
+      exportResult: reportResult,
+      strategies,
+      summary: analysisData.summary
+    };
+  }
+
+  printSummary(results, duration) {
+    const { reportData, summary } = results;
+    
+    console.log();
+    console.log(chalk.blue('📈 Analysis Summary'));
+    console.log(chalk.gray('─'.repeat(50)));
+    console.log(`📁 Total Files: ${chalk.bold(summary.totalFiles)}`);
+    console.log(`📏 Total Lines: ${chalk.bold(summary.totalLines.toLocaleString())}`);
+    console.log(`🔧 Files Needing Refactoring: ${chalk.bold(summary.filesNeedingRefactoring)}`);
+    console.log(`🚨 Urgent Refactoring: ${chalk.bold(summary.urgentRefactoring)}`);
+    console.log(`✅ Compliance Rate: ${chalk.bold(reportData.summary.complianceRate + '%')}`);
+    console.log(`🎯 Average Complexity: ${chalk.bold(reportData.summary.averageComplexity)}`);
+    console.log(`⏱️  Duration: ${chalk.bold((duration / 1000).toFixed(2) + 's')}`);
+    
+    // Show violations
+    if (reportData.violations.length > 0) {
+      console.log();
+      console.log(chalk.red('⚠️  Violations Found'));
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      const criticalViolations = reportData.violations.filter(v => v.severity === 'critical');
+      const majorViolations = reportData.violations.filter(v => v.severity === 'major');
+      
+      if (criticalViolations.length > 0) {
+        console.log(`${chalk.red('🚨 Critical:')} ${criticalViolations.length} files`);
+      }
+      if (majorViolations.length > 0) {
+        console.log(`${chalk.yellow('⚠️  Major:')} ${majorViolations.length} files`);
+      }
+    }
+    
+    // Show top recommendations
+    if (reportData.recommendations.length > 0) {
+      console.log();
+      console.log(chalk.blue('💡 Top Recommendations'));
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      for (const rec of reportData.recommendations.slice(0, 3)) {
+        const priorityColor = rec.priority === 'critical' ? 'red' : 
+                           rec.priority === 'high' ? 'yellow' : 
+                           rec.priority === 'medium' ? 'blue' : 'gray';
+        
+        console.log(`${chalk[priorityColor]('●')} ${rec.title}`);
+        console.log(`   ${rec.description}`);
+        console.log(`   Priority: ${rec.priority} | Effort: ${rec.estimatedEffort} units`);
+        console.log();
+      }
+    }
+    
+    // Package summary
+    if (Object.keys(reportData.packageAnalysis).length > 1) {
+      console.log(chalk.blue('📦 Package Summary'));
+      console.log(chalk.gray('─'.repeat(50)));
+      
+      for (const [packageName, packageData] of Object.entries(reportData.packageAnalysis)) {
+        const complianceColor = packageData.complianceRate >= 90 ? 'green' :
+                              packageData.complianceRate >= 70 ? 'yellow' : 'red';
+        
+        console.log(`${packageName}: ${chalk[complianceColor](packageData.complianceRate + '%')} compliant (${packageData.files.length} files)`);
+      }
+    }
+  }
+
+  async saveReport(results, options) {
+    try {
+      const { exportResult } = results;
+      
+      if (exportResult.success) {
+        console.log();
+        console.log(chalk.green('✅ Report saved successfully'));
+        console.log(chalk.gray(`📄 ${exportResult.path}`));
+        
+        // Show file size
+        const stats = fs.statSync(exportResult.path);
+        const fileSize = (stats.size / 1024).toFixed(2);
+        console.log(chalk.gray(`📊 Size: ${fileSize} KB`));
+      } else {
+        console.log(chalk.red('❌ Failed to save report'));
+      }
+    } catch (error) {
+      console.error(chalk.red('Error saving report:'), error.message);
+    }
+  }
+}
+
+/**
+ * Register command with CLI
+ */
+function registerCommand(program) {
+  const command = new AnalyzeFileSizesCommand();
+  program.addCommand(command.command);
+  return command;
+}
+
+/**
+ * Export for direct use
+ */
+module.exports = {
+  AnalyzeFileSizesCommand,
+  registerCommand
+};

package/src/commands/auto-direct/code-processor.js

@@ -0,0 +1,282 @@
+/**
+ * Code processing functions for auto-direct command
+ * Extracted from auto-direct.js to reduce file size
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * Parse search/replace blocks from LLM response
+ */
+function parseSearchReplaceBlocks(response) {
+  const changes = [];
+
+  // Match FILE: path SEARCH: ``` old ``` REPLACE: ``` new ``` format
+  const fileBlockRegex = /FILE:\s*(.+?)\s*SEARCH:\s*```[\s\S]*?```[\s\S]*?REPLACE:\s*```[\s\S]*?```/g;
+  
+  let match;
+  while ((match = fileBlockRegex.exec(response)) !== null) {
+    const fileBlock = match[0];
+    const filePath = match[1].trim();
+
+    // Extract search block
+    const searchMatch = fileBlock.match(/SEARCH:\s*```([\s\S]*?)```/);
+    // Extract replace block
+    const replaceMatch = fileBlock.match(/REPLACE:\s*```([\s\S]*?)```/);
+
+    if (searchMatch && replaceMatch) {
+      changes.push({
+        file: filePath,
+        search: searchMatch[1].trim(),
+        replace: replaceMatch[1].trim()
+      });
+    }
+  }
+
+  return changes;
+}
+
+/**
+ * Normalize whitespace for comparison (convert all whitespace to single spaces)
+ */
+function normalizeWhitespace(str) {
+  return str.replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Extract key identifiers from code (variable names, function names, strings)
+ */
+function extractIdentifiers(code) {
+  const identifiers = new Set();
+
+  // Extract quoted strings
+  const stringMatches = code.match(/'([^']+)'/g);
+  if (stringMatches) {
+    stringMatches.forEach(match => {
+      identifiers.add(match.slice(1, -1)); // Remove quotes
+    });
+  }
+
+  const doubleStringMatches = code.match(/"([^"]+)"/g);
+  if (doubleStringMatches) {
+    doubleStringMatches.forEach(match => {
+      identifiers.add(match.slice(1, -1)); // Remove quotes
+    });
+  }
+
+  // Extract variable/function names (words followed by : or =)
+  const nameMatches = code.match(/\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[:=]/g);
+  if (nameMatches) {
+    nameMatches.forEach(match => {
+      const name = match.replace(/\s*[:=]/, '');
+      identifiers.add(name);
+    });
+  }
+
+  // Extract common patterns like 'type:', 'name:', 'value:'
+  const patternMatches = code.match(/(type|name|value|file|path|function|const|let|var)\s*:/gi);
+  if (patternMatches) {
+    patternMatches.forEach(match => {
+      identifiers.add(match.toLowerCase().replace(/\s*:/, ''));
+    });
+  }
+
+  return Array.from(identifiers);
+}
+
+/**
+ * Extract structural pattern from code (ignoring values)
+ */
+function extractPattern(code) {
+  // Replace strings with placeholders
+  let pattern = code.replace(/'[^']+'|"[^"]+"/g, '"..."');
+  // Replace numbers with placeholders
+  pattern = pattern.replace(/\b\d+\.?\d*\b/g, '...');
+  // Replace whitespace with single spaces
+  pattern = normalizeWhitespace(pattern);
+  return pattern;
+}
+
+/**
+ * Apply a search/replace change to a file with fuzzy matching fallback
+ */
+async function applyFileChange(change, repoPath) {
+  try {
+    const fullPath = path.join(repoPath, change.file);
+
+    if (!await fs.pathExists(fullPath)) {
+      console.log(chalk.yellow(`⚠️  File not found: ${change.file}`));
+      return { success: false, error: 'File not found' };
+    }
+
+    const content = await fs.readFile(fullPath, 'utf8');
+    const lines = content.split('\n');
+    const searchLines = change.search.split('\n');
+
+    console.log(chalk.gray(`  - Search block: ${searchLines.length} lines`));
+    console.log(chalk.gray(`  - File total: ${lines.length} lines`));
+
+    // Extract key identifiers from search text (function names, variable names, strings)
+    const searchIdentifiers = extractIdentifiers(change.search);
+
+    // Try multiple window sizes (±5 lines) to account for LLM not including enough context
+    const windowSizes = [0, 2, 5, 10, 15];
+    
+    for (const windowSize of windowSizes) {
+      // Try to find the search block with fuzzy matching
+      let foundIndex = -1;
+      
+      // First try exact match
+      const exactMatch = content.indexOf(change.search);
+      if (exactMatch !== -1) {
+        foundIndex = exactMatch;
+      } else {
+        // Try fuzzy matching by looking for patterns
+        const searchPattern = extractPattern(change.search);
+        
+        for (let i = 0; i <= lines.length - searchLines.length; i++) {
+          const window = lines.slice(Math.max(0, i - windowSize), 
+                                     Math.min(lines.length, i + searchLines.length + windowSize));
+          const windowContent = window.join('\n');
+          const windowPattern = extractPattern(windowContent);
+          
+          // Check if patterns match and key identifiers are present
+          if (windowPattern.includes(searchPattern) || searchPattern.includes(windowPattern)) {
+            const windowIdentifiers = extractIdentifiers(windowContent);
+            const commonIdentifiers = searchIdentifiers.filter(id => windowIdentifiers.includes(id));
+            
+            // If we have enough common identifiers, consider it a match
+            if (commonIdentifiers.length >= Math.min(3, searchIdentifiers.length)) {
+              // Find the actual search block within this window
+              const windowStart = Math.max(0, i - windowSize);
+              const windowText = lines.slice(windowStart, 
+                                            Math.min(lines.length, i + searchLines.length + windowSize)).join('\n');
+              
+              // Try to find the best match within the window
+              const bestMatch = findBestMatch(change.search, windowText);
+              if (bestMatch.similarity > 0.7) { // 70% similarity threshold
+                foundIndex = windowStart + bestMatch.offset;
+                break;
+              }
+            }
+          }
+        }
+      }
+
+      if (foundIndex !== -1) {
+        // Calculate line boundaries
+        const beforeContent = content.substring(0, foundIndex);
+        const afterContent = content.substring(foundIndex);
+        const afterLines = afterContent.split('\n');
+        
+        // Find the end of the block to replace
+        let endLineIndex = 0;
+        let currentLineContent = '';
+        
+        for (let i = 0; i < afterLines.length; i++) {
+          currentLineContent += (i > 0 ? '\n' : '') + afterLines[i];
+          
+          // Check if we've found a block that matches our search
+          const testContent = afterLines.slice(0, i + 1).join('\n');
+          const similarity = calculateSimilarity(change.search, testContent);
+          
+          if (similarity > 0.8 || i >= searchLines.length + 5) { // Allow some extra lines
+            endLineIndex = i + 1;
+            break;
+          }
+        }
+
+        // Replace the content
+        const newContent = beforeContent + change.replace + 
+                          afterLines.slice(endLineIndex).join('\n');
+        
+        await fs.writeFile(fullPath, newContent);
+        
+        console.log(chalk.green(`  ✅ Applied change to ${change.file}`));
+        return { success: true };
+      }
+    }
+
+    console.log(chalk.yellow(`  ⚠️  Could not find matching block in ${change.file}`));
+    return { success: false, error: 'Could not find matching block' };
+    
+  } catch (error) {
+    console.error(chalk.red(`  ❌ Error applying change to ${change.file}:`), error.message);
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Find best match within a text block
+ */
+function findBestMatch(searchText, textBlock) {
+  const searchLines = searchText.split('\n');
+  const textLines = textBlock.split('\n');
+  
+  let bestMatch = { similarity: 0, offset: 0 };
+  
+  for (let offset = 0; offset <= textLines.length - searchLines.length; offset++) {
+    const testBlock = textLines.slice(offset, offset + searchLines.length).join('\n');
+    const similarity = calculateSimilarity(searchText, testBlock);
+    
+    if (similarity > bestMatch.similarity) {
+      bestMatch = { similarity, offset };
+    }
+  }
+  
+  return bestMatch;
+}
+
+/**
+ * Calculate similarity between two strings
+ */
+function calculateSimilarity(str1, str2) {
+  const longer = str1.length > str2.length ? str1 : str2;
+  const shorter = str1.length > str2.length ? str2 : str1;
+  
+  if (longer.length === 0) return 1.0;
+  
+  const editDistance = levenshteinDistance(longer, shorter);
+  return (longer.length - editDistance) / longer.length;
+}
+
+/**
+ * Calculate Levenshtein distance between two strings
+ */
+function levenshteinDistance(str1, str2) {
+  const matrix = [];
+  
+  for (let i = 0; i <= str2.length; i++) {
+    matrix[i] = [i];
+  }
+  
+  for (let j = 0; j <= str1.length; j++) {
+    matrix[0][j] = j;
+  }
+  
+  for (let i = 1; i <= str2.length; i++) {
+    for (let j = 1; j <= str1.length; j++) {
+      if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+        matrix[i][j] = matrix[i - 1][j - 1];
+      } else {
+        matrix[i][j] = Math.min(
+          matrix[i - 1][j - 1] + 1,
+          matrix[i][j - 1] + 1,
+          matrix[i - 1][j] + 1
+        );
+      }
+    }
+  }
+  
+  return matrix[str2.length][str1.length];
+}
+
+module.exports = {
+  parseSearchReplaceBlocks,
+  normalizeWhitespace,
+  extractIdentifiers,
+  extractPattern,
+  applyFileChange
+};