vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/refactoring-tools.js

@@ -0,0 +1,512 @@
+/**
+ * Refactoring Tools Utility
+ * Core utilities for safe code refactoring operations
+ * Part of specs/010-555-max-file-size implementation (Task T004)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Safely split a file into multiple modules
+ * @param {string} filePath - Path to file to split
+ * @param {Object} splitPlan - Plan for how to split the file
+ * @returns {Object} Split results
+ */
+function splitFile(filePath, splitPlan) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    const results = {
+      originalFile: filePath,
+      totalLines: lines.length,
+      modules: [],
+      errors: [],
+      warnings: []
+    };
+
+    // Validate split plan
+    const validation = validateSplitPlan(splitPlan, lines.length);
+    if (!validation.isValid) {
+      results.errors.push(...validation.errors);
+      return results;
+    }
+
+    // Create each module
+    splitPlan.modules.forEach((modulePlan, index) => {
+      const moduleResult = createModule(filePath, modulePlan, lines, index);
+      results.modules.push(moduleResult);
+      
+      if (moduleResult.error) {
+        results.errors.push(moduleResult.error);
+      }
+      if (moduleResult.warnings) {
+        results.warnings.push(...moduleResult.warnings);
+      }
+    });
+
+    return results;
+  } catch (error) {
+    return {
+      originalFile: filePath,
+      error: error.message,
+      modules: []
+    };
+  }
+}
+
+/**
+ * Validate a split plan
+ * @param {Object} splitPlan - Split plan to validate
+ * @param {number} totalLines - Total lines in source file
+ * @returns {Object} Validation results
+ */
+function validateSplitPlan(splitPlan, totalLines) {
+  const errors = [];
+  const warnings = [];
+
+  if (!splitPlan.modules || !Array.isArray(splitPlan.modules)) {
+    errors.push('Split plan must contain modules array');
+    return { isValid: false, errors, warnings };
+  }
+
+  if (splitPlan.modules.length === 0) {
+    errors.push('Split plan must contain at least one module');
+    return { isValid: false, errors, warnings };
+  }
+
+  let coveredLines = 0;
+  const lineRanges = [];
+
+  splitPlan.modules.forEach((module, index) => {
+    if (!module.startLine || !module.endLine) {
+      errors.push(`Module ${index} missing startLine or endLine`);
+      return;
+    }
+
+    if (module.startLine < 1 || module.endLine > totalLines) {
+      errors.push(`Module ${index} line range out of bounds`);
+      return;
+    }
+
+    if (module.startLine > module.endLine) {
+      errors.push(`Module ${index} startLine > endLine`);
+      return;
+    }
+
+    // Check for overlaps
+    const range = [module.startLine, module.endLine];
+    for (const existingRange of lineRanges) {
+      if (rangesOverlap(range, existingRange)) {
+        errors.push(`Module ${index} line range overlaps with another module`);
+        break;
+      }
+    }
+    lineRanges.push(range);
+
+    coveredLines += (module.endLine - module.startLine + 1);
+
+    // Check module size
+    const moduleSize = module.endLine - module.startLine + 1;
+    if (moduleSize > 555) {
+      warnings.push(`Module ${index} exceeds 555 lines (${moduleSize} lines)`);
+    }
+  });
+
+  // Check if all lines are covered
+  if (coveredLines < totalLines) {
+    warnings.push(`${totalLines - coveredLines} lines are not included in any module`);
+  } else if (coveredLines > totalLines) {
+    errors.push('Split plan covers more lines than exist in file');
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+
+/**
+ * Check if two ranges overlap
+ * @param {Array} range1 - First range [start, end]
+ * @param {Array} range2 - Second range [start, end]
+ * @returns {boolean}
+ */
+function rangesOverlap(range1, range2) {
+  const [start1, end1] = range1;
+  const [start2, end2] = range2;
+  return !(end1 < start2 || end2 < start1);
+}
+
+/**
+ * Create a module file
+ * @param {string} sourceFile - Source file path
+ * @param {Object} modulePlan - Module plan
+ * @param {Array} lines - All lines from source file
+ * @param {number} index - Module index
+ * @returns {Object} Module creation result
+ */
+function createModule(sourceFile, modulePlan, lines, index) {
+  const result = {
+    moduleName: modulePlan.name || `module-${index + 1}`,
+    filePath: null,
+    content: null,
+    lines: [],
+    imports: [],
+    exports: [],
+    error: null,
+    warnings: []
+  };
+
+  try {
+    // Extract lines for this module
+    const startIdx = modulePlan.startLine - 1; // Convert to 0-based
+    const endIdx = modulePlan.endLine; // endLine is 1-based, slice is exclusive
+    result.lines = lines.slice(startIdx, endIdx);
+    result.content = result.lines.join('\n');
+
+    // Determine output file path
+    const sourceDir = path.dirname(sourceFile);
+    const sourceExt = path.extname(sourceFile);
+    const moduleFileName = `${result.moduleName}${sourceExt}`;
+    result.filePath = path.join(sourceDir, moduleFileName);
+
+    // Analyze imports and exports
+    result.imports = extractImports(result.lines);
+    result.exports = extractExports(result.lines);
+
+    // Add warnings for potential issues
+    if (result.imports.length === 0 && result.exports.length === 0) {
+      result.warnings.push('Module has no imports or exports - may be isolated');
+    }
+
+    if (result.lines.length > 555) {
+      result.warnings.push(`Module exceeds 555 lines (${result.lines.length} lines)`);
+    }
+
+  } catch (error) {
+    result.error = error.message;
+  }
+
+  return result;
+}
+
+/**
+ * Extract imports from lines
+ * @param {Array} lines - Array of code lines
+ * @returns {Array} Array of import objects
+ */
+function extractImports(lines) {
+  const imports = [];
+
+  lines.forEach((line, index) => {
+    const trimmed = line.trim();
+    
+    // ES6 imports
+    const es6Match = trimmed.match(/^import\s+.+from\s+['"]([^'"]+)['"]/);
+    if (es6Match) {
+      imports.push({
+        type: 'es6',
+        module: es6Match[1],
+        line: index + 1,
+        statement: trimmed
+      });
+      return;
+    }
+
+    // CommonJS requires
+    const cjsMatch = trimmed.match(/require\(['"]([^'"]+)['"]\)/);
+    if (cjsMatch) {
+      imports.push({
+        type: 'commonjs',
+        module: cjsMatch[1],
+        line: index + 1,
+        statement: trimmed
+      });
+    }
+  });
+
+  return imports;
+}
+
+/**
+ * Extract exports from lines
+ * @param {Array} lines - Array of code lines
+ * @returns {Array} Array of export objects
+ */
+function extractExports(lines) {
+  const exports = [];
+
+  lines.forEach((line, index) => {
+    const trimmed = line.trim();
+    
+    // ES6 exports
+    if (trimmed.startsWith('export ')) {
+      exports.push({
+        type: 'es6',
+        line: index + 1,
+        statement: trimmed
+      });
+      return;
+    }
+
+    // CommonJS exports
+    if (trimmed.startsWith('module.exports')) {
+      exports.push({
+        type: 'commonjs',
+        line: index + 1,
+        statement: trimmed
+      });
+    }
+  });
+
+  return exports;
+}
+
+/**
+ * Move code segment to new file
+ * @param {string} sourceFile - Source file path
+ * @param {Object} segment - Code segment to move
+ * @param {string} targetFile - Target file path
+ * @returns {Object} Move result
+ */
+function moveCodeSegment(sourceFile, segment, targetFile) {
+  try {
+    const sourceContent = fs.readFileSync(sourceFile, 'utf8');
+    const lines = sourceContent.split('\n');
+
+    const result = {
+      sourceFile,
+      targetFile,
+      segment,
+      linesMoved: 0,
+      sourceUpdated: false,
+      targetCreated: false,
+      error: null
+    };
+
+    // Validate segment
+    if (segment.startLine < 1 || segment.endLine > lines.length) {
+      result.error = 'Segment line range out of bounds';
+      return result;
+    }
+
+    if (segment.startLine > segment.endLine) {
+      result.error = 'Invalid segment line range';
+      return result;
+    }
+
+    // Extract segment
+    const startIdx = segment.startLine - 1;
+    const endIdx = segment.endLine;
+    const segmentLines = lines.slice(startIdx, endIdx);
+    result.linesMoved = segmentLines.length;
+
+    // Create target file
+    const targetDir = path.dirname(targetFile);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    fs.writeFileSync(targetFile, segmentLines.join('\n'));
+    result.targetCreated = true;
+
+    // Remove segment from source
+    const remainingLines = [
+      ...lines.slice(0, startIdx),
+      ...lines.slice(endIdx)
+    ];
+
+    fs.writeFileSync(sourceFile, remainingLines.join('\n'));
+    result.sourceUpdated = true;
+
+    return result;
+  } catch (error) {
+    return {
+      sourceFile,
+      targetFile,
+      segment,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Update import statements after refactoring
+ * @param {string} filePath - File to update
+ * @param {Array} importUpdates - Array of import updates
+ * @returns {Object} Update result
+ */
+function updateImportStatements(filePath, importUpdates) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    const result = {
+      filePath,
+      updates: importUpdates,
+      appliedUpdates: [],
+      failedUpdates: [],
+      error: null
+    };
+
+    // Apply updates in reverse order to maintain line numbers
+    const sortedUpdates = importUpdates
+      .filter(update => update.line && update.newStatement)
+      .sort((a, b) => b.line - a.line);
+
+    sortedUpdates.forEach(update => {
+      try {
+        const lineIdx = update.line - 1;
+        if (lineIdx >= 0 && lineIdx < lines.length) {
+          lines[lineIdx] = update.newStatement;
+          result.appliedUpdates.push(update);
+        } else {
+          result.failedUpdates.push({
+            ...update,
+            reason: 'Line number out of range'
+          });
+        }
+      } catch (error) {
+        result.failedUpdates.push({
+          ...update,
+          reason: error.message
+        });
+      }
+    });
+
+    // Write updated content
+    if (result.appliedUpdates.length > 0) {
+      fs.writeFileSync(filePath, lines.join('\n'));
+    }
+
+    return result;
+  } catch (error) {
+    return {
+      filePath,
+      error: error.message,
+      appliedUpdates: [],
+      failedUpdates: importUpdates
+    };
+  }
+}
+
+/**
+ * Validate refactoring preserves functionality
+ * @param {string} originalFile - Original file path
+ * @param {Array} refactoredFiles - Array of refactored file paths
+ * @returns {Object} Validation result
+ */
+function validateFunctionality(originalFile, refactoredFiles) {
+  const result = {
+    originalFile,
+    refactoredFiles,
+    isValid: true,
+    errors: [],
+    warnings: [],
+    missingExports: [],
+    orphanedImports: []
+  };
+
+  try {
+    // Analyze original file
+    const originalContent = fs.readFileSync(originalFile, 'utf8');
+    const originalLines = originalContent.split('\n');
+    const originalExports = extractExports(originalLines);
+
+    // Check each refactored file
+    let allExports = [];
+    let allImports = [];
+
+    refactoredFiles.forEach(filePath => {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        
+        const fileExports = extractExports(lines);
+        const fileImports = extractImports(lines);
+        
+        allExports.push(...fileExports.map(e => ({ ...e, file: filePath })));
+        allImports.push(...fileImports.map(i => ({ ...i, file: filePath })));
+      } catch (error) {
+        result.errors.push(`Failed to read ${filePath}: ${error.message}`);
+      }
+    });
+
+    // Check for missing exports
+    originalExports.forEach(originalExport => {
+      const found = allExports.some(refactoredExport => 
+        originalExport.statement === refactoredExport.statement
+      );
+      
+      if (!found) {
+        result.missingExports.push(originalExport);
+        result.isValid = false;
+      }
+    });
+
+    // Check for orphaned imports (imports that don't have corresponding exports)
+    allImports.forEach(importObj => {
+      if (importObj.module.startsWith('./') || importObj.module.startsWith('../')) {
+        // This is a relative import - check if target file exists and has exports
+        const targetPath = path.resolve(path.dirname(importObj.file), importObj.module);
+        if (!fs.existsSync(targetPath)) {
+          result.orphanedImports.push(importObj);
+          result.warnings.push(`Orphaned import: ${importObj.module} in ${importObj.file}`);
+        }
+      }
+    });
+
+  } catch (error) {
+    result.error = error.message;
+    result.isValid = false;
+  }
+
+  return result;
+}
+
+/**
+ * Generate refactoring summary
+ * @param {Object} refactoringResult - Result from splitFile or other refactoring operation
+ * @returns {Object} Summary report
+ */
+function generateRefactoringSummary(refactoringResult) {
+  const summary = {
+    operation: refactoringResult.originalFile ? 'file-split' : 'unknown',
+    originalFile: refactoringResult.originalFile,
+    success: !refactoringResult.error,
+    totalLines: refactoringResult.totalLines || 0,
+    modulesCreated: refactoringResult.modules ? refactoringResult.modules.length : 0,
+    errors: refactoringResult.errors || [],
+    warnings: refactoringResult.warnings || [],
+    moduleDetails: []
+  };
+
+  if (refactoringResult.modules) {
+    refactoringResult.modules.forEach(module => {
+      summary.moduleDetails.push({
+        name: module.moduleName,
+        path: module.filePath,
+        lines: module.lines ? module.lines.length : 0,
+        imports: module.imports ? module.imports.length : 0,
+        exports: module.exports ? module.exports.length : 0,
+        hasError: !!module.error
+      });
+    });
+  }
+
+  return summary;
+}
+
+module.exports = {
+  splitFile,
+  moveCodeSegment,
+  updateImportStatements,
+  validateFunctionality,
+  generateRefactoringSummary,
+  validateSplitPlan,
+  extractImports,
+  extractExports
+};