vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1642

package/src/refactoring/code-mover.js

@@ -0,0 +1,761 @@
+/**
+ * Code Segment Mover
+ * 
+ * Moves code segments between files while preserving functionality.
+ * Handles import updates and dependency management during moves.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { RollbackManager } = require('../utils/rollback-manager');
+
+/**
+ * Move operation types
+ */
+const MOVE_TYPES = {
+  EXTRACT: 'extract',
+  RELOCATE: 'relocate',
+  CONSOLIDATE: 'consolidate',
+  REORGANIZE: 'reorganize'
+};
+
+/**
+ * Move result class
+ */
+class MoveResult {
+  constructor(operation) {
+    this.operation = operation;
+    this.success = false;
+    this.sourceModified = false;
+    this.targetCreated = false;
+    this.importsUpdated = false;
+    this.errors = [];
+    this.warnings = [];
+    this.metadata = {
+      executedAt: new Date().toISOString(),
+      linesMoved: 0,
+      filesAffected: 0
+    };
+  }
+
+  addError(error) {
+    this.errors.push({
+      message: error.message,
+      timestamp: new Date().toISOString(),
+      stack: error.stack
+    });
+  }
+
+  addWarning(warning) {
+    this.warnings.push({
+      message: warning,
+      timestamp: new Date().toISOString()
+    });
+  }
+
+  setSuccess(success) {
+    this.success = success;
+  }
+
+  setSourceModified(modified) {
+    this.sourceModified = modified;
+  }
+
+  setTargetCreated(created) {
+    this.targetCreated = created;
+  }
+
+  setImportsUpdated(updated) {
+    this.importsUpdated = updated;
+  }
+
+  getSummary() {
+    return {
+      operation: this.operation,
+      success: this.success,
+      sourceModified: this.sourceModified,
+      targetCreated: this.targetCreated,
+      importsUpdated: this.importsUpdated,
+      linesMoved: this.metadata.linesMoved,
+      filesAffected: this.metadata.filesAffected,
+      errorCount: this.errors.length,
+      warningCount: this.warnings.length
+    };
+  }
+}
+
+/**
+ * Move operation class
+ */
+class MoveOperation {
+  constructor(type, sourcePath, targetPath, options = {}) {
+    this.id = this.generateId();
+    this.type = type;
+    this.sourcePath = sourcePath;
+    this.targetPath = targetPath;
+    this.startLine = options.startLine;
+    this.endLine = options.endLine;
+    this.segmentName = options.segmentName;
+    this.updateImports = options.updateImports !== false;
+    this.preserveOriginal = options.preserveOriginal || false;
+    this.createBackup = options.createBackup !== false;
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      description: options.description || ''
+    };
+  }
+
+  generateId() {
+    return `move_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  validate() {
+    const errors = [];
+    
+    if (!this.sourcePath) {
+      errors.push('Source path is required');
+    }
+    
+    if (!this.targetPath) {
+      errors.push('Target path is required');
+    }
+    
+    if (this.startLine && this.endLine && this.startLine > this.endLine) {
+      errors.push('Start line cannot be greater than end line');
+    }
+    
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+}
+
+/**
+ * Code mover class
+ */
+class CodeMover {
+  constructor(options = {}) {
+    this.options = {
+      backupBeforeMove: true,
+      validateAfterMove: true,
+      updateImportsAutomatically: true,
+      preserveFormatting: true,
+      ...options
+    };
+    
+    this.rollbackManager = new RollbackManager();
+  }
+
+  /**
+   * Execute a move operation
+   */
+  async executeMove(operation) {
+    const result = new MoveResult(operation);
+    
+    try {
+      // Validate operation
+      const validation = operation.validate();
+      if (!validation.isValid) {
+        throw new Error(`Invalid operation: ${validation.errors.join(', ')}`);
+      }
+
+      // Create backup if enabled
+      if (this.options.backupBeforeMove) {
+        this.rollbackManager.backupFile(operation.sourcePath);
+      }
+
+      // Read source file
+      const sourceContent = fs.readFileSync(operation.sourcePath, 'utf8');
+      const sourceLines = sourceContent.split('\n');
+
+      // Extract code segment
+      const segment = this.extractSegment(sourceLines, operation);
+      result.metadata.linesMoved = segment.lines.length;
+
+      // Analyze dependencies
+      const dependencies = this.analyzeDependencies(segment.content);
+      
+      // Write to target file
+      await this.writeTargetFile(operation, segment, dependencies);
+      result.setTargetCreated(true);
+
+      // Update source file
+      if (!operation.preserveOriginal) {
+        await this.updateSourceFile(operation.sourcePath, sourceLines, operation);
+        result.setSourceModified(true);
+      }
+
+      // Update imports
+      if (operation.updateImports && this.options.updateImportsAutomatically) {
+        await this.updateImports(operation, dependencies);
+        result.setImportsUpdated(true);
+      }
+
+      // Validate result
+      if (this.options.validateAfterMove) {
+        await this.validateMove(operation, result);
+      }
+
+      result.metadata.filesAffected = 1 + (result.importsUpdated ? this.countAffectedFiles(dependencies) : 0);
+      result.setSuccess(true);
+
+    } catch (error) {
+      result.addError(error);
+      result.setSuccess(false);
+      
+      // Rollback on error
+      await this.rollbackManager.rollback();
+    }
+
+    return result;
+  }
+
+  /**
+   * Extract code segment from source
+   */
+  extractSegment(sourceLines, operation) {
+    let startIdx = 0;
+    let endIdx = sourceLines.length;
+
+    if (operation.startLine && operation.endLine) {
+      // Extract specific line range
+      startIdx = Math.max(0, operation.startLine - 1);
+      endIdx = Math.min(sourceLines.length, operation.endLine);
+    } else if (operation.segmentName) {
+      // Find segment by name (function, class, etc.)
+      const segmentRange = this.findSegmentRange(sourceLines, operation.segmentName);
+      if (segmentRange) {
+        startIdx = segmentRange.start;
+        endIdx = segmentRange.end;
+      }
+    }
+
+    const lines = sourceLines.slice(startIdx, endIdx);
+    const content = lines.join('\n');
+
+    return {
+      lines,
+      content,
+      startLine: startIdx + 1,
+      endLine: endIdx
+    };
+  }
+
+  /**
+   * Find segment range by name
+   */
+  findSegmentRange(lines, name) {
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i].trim();
+      
+      // Function declaration
+      const funcMatch = line.match(new RegExp(`^function\\s+${name}\\s*\\(`));
+      if (funcMatch) {
+        return this.findBlockRange(lines, i);
+      }
+      
+      // Function expression
+      const exprMatch = line.match(new RegExp(`^(?:const|let|var)\\s+${name}\\s*=\\s*function`));
+      if (exprMatch) {
+        return this.findBlockRange(lines, i);
+      }
+      
+      // Arrow function
+      const arrowMatch = line.match(new RegExp(`^(?:const|let|var)\\s+${name}\\s*=\\s*\\(`));
+      if (arrowMatch) {
+        return this.findBlockRange(lines, i);
+      }
+      
+      // Class
+      const classMatch = line.match(new RegExp(`^class\\s+${name}\\b`));
+      if (classMatch) {
+        return this.findBlockRange(lines, i);
+      }
+      
+      // Object assignment
+      const objMatch = line.match(new RegExp(`^(?:const|let|var)\\s+${name}\\s*=\\s*\\{`));
+      if (objMatch) {
+        return this.findBlockRange(lines, i);
+      }
+    }
+    
+    return null;
+  }
+
+  /**
+   * Find block range (between braces)
+   */
+  findBlockRange(lines, startLine) {
+    let braceCount = 0;
+    let foundBrace = false;
+    
+    for (let i = startLine; i < lines.length; i++) {
+      const line = lines[i];
+      
+      for (let j = 0; j < line.length; j++) {
+        if (line[j] === '{') {
+          braceCount++;
+          foundBrace = true;
+        } else if (line[j] === '}') {
+          braceCount--;
+          if (foundBrace && braceCount === 0) {
+            return {
+              start: startLine,
+              end: i + 1
+            };
+          }
+        }
+      }
+    }
+    
+    return {
+      start: startLine,
+      end: lines.length
+    };
+  }
+
+  /**
+   * Analyze dependencies in code segment
+   */
+  analyzeDependencies(content) {
+    const dependencies = {
+      imports: [],
+      requires: [],
+      internalRefs: [],
+      externalRefs: []
+    };
+
+    const lines = content.split('\n');
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      // Import statements
+      if (trimmed.startsWith('import ')) {
+        const match = trimmed.match(/import\s+(?:.*?\s+from\s+)?['"]([^'"]+)['"]/);
+        if (match) {
+          dependencies.imports.push({
+            statement: trimmed,
+            module: match[1],
+            isRelative: match[1].startsWith('./') || match[1].startsWith('../')
+          });
+        }
+      }
+      
+      // Require statements
+      if (trimmed.includes('require(')) {
+        const match = trimmed.match(/require\s*\(\s*['"]([^'"]+)['"]\s*\)/);
+        if (match) {
+          dependencies.requires.push({
+            statement: trimmed,
+            module: match[1],
+            isRelative: match[1].startsWith('./') || match[1].startsWith('../')
+          });
+        }
+      }
+      
+      // Variable references (simplified)
+      const varMatches = trimmed.match(/\b[a-zA-Z_]\w*\b/g);
+      if (varMatches) {
+        for (const varName of varMatches) {
+          if (!this.isKeyword(varName)) {
+            dependencies.internalRefs.push(varName);
+          }
+        }
+      }
+    }
+    
+    return dependencies;
+  }
+
+  /**
+   * Check if word is JavaScript keyword
+   */
+  isKeyword(word) {
+    const keywords = [
+      'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default',
+      'delete', 'do', 'else', 'export', 'extends', 'finally', 'for', 'function',
+      'if', 'import', 'in', 'instanceof', 'let', 'new', 'return', 'super', 'switch',
+      'this', 'throw', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield'
+    ];
+    return keywords.includes(word);
+  }
+
+  /**
+   * Write target file
+   */
+  async writeTargetFile(operation, segment, dependencies) {
+    // Ensure target directory exists
+    const targetDir = path.dirname(operation.targetPath);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    // Generate target file content
+    const content = this.generateTargetContent(segment, dependencies);
+    
+    fs.writeFileSync(operation.targetPath, content, 'utf8');
+  }
+
+  /**
+   * Generate content for target file
+   */
+  generateTargetContent(segment, dependencies) {
+    let content = '';
+    
+    // Add dependencies
+    for (const imp of dependencies.imports) {
+      content += imp.statement + '\n';
+    }
+    
+    for (const req of dependencies.requires) {
+      content += req.statement + '\n';
+    }
+    
+    if (dependencies.imports.length > 0 || dependencies.requires.length > 0) {
+      content += '\n';
+    }
+    
+    // Add the moved code
+    content += segment.content;
+    
+    // Add exports if needed
+    if (operation.segmentName) {
+      content += '\n\n';
+      content += `export default ${operation.segmentName};\n`;
+    }
+    
+    return content;
+  }
+
+  /**
+   * Update source file
+   */
+  async updateSourceFile(sourcePath, sourceLines, operation) {
+    let newLines;
+    
+    if (operation.startLine && operation.endLine) {
+      // Remove specific line range
+      const startIdx = Math.max(0, operation.startLine - 1);
+      const endIdx = Math.min(sourceLines.length, operation.endLine);
+      
+      newLines = [
+        ...sourceLines.slice(0, startIdx),
+        ...sourceLines.slice(endIdx)
+      ];
+    } else {
+      // Remove entire segment (if found)
+      const segmentRange = this.findSegmentRange(sourceLines, operation.segmentName);
+      if (segmentRange) {
+        newLines = [
+          ...sourceLines.slice(0, segmentRange.start),
+          ...sourceLines.slice(segmentRange.end)
+        ];
+      } else {
+        newLines = sourceLines; // No changes if segment not found
+      }
+    }
+    
+    // Add import statement for moved code
+    if (operation.segmentName) {
+      const relativePath = path.relative(
+        path.dirname(sourcePath),
+        path.dirname(operation.targetPath)
+      ).replace(/\\/g, '/');
+      
+      const importStatement = `import ${operation.segmentName} from './${relativePath}/${path.basename(operation.targetPath, '.js')}';`;
+      newLines.unshift(importStatement);
+    }
+    
+    const newContent = newLines.join('\n');
+    fs.writeFileSync(sourcePath, newContent, 'utf8');
+  }
+
+  /**
+   * Update imports in dependent files
+   */
+  async updateImports(operation, dependencies) {
+    // Find files that import from source
+    const dependentFiles = this.findDependentFiles(operation.sourcePath);
+    
+    for (const depFile of dependentFiles) {
+      await this.updateFileImports(depFile, operation, dependencies);
+    }
+  }
+
+  /**
+   * Find files that depend on source file
+   */
+  findDependentFiles(sourcePath) {
+    // This would search the codebase for files that import from sourcePath
+    // For now, return empty array as placeholder
+    return [];
+  }
+
+  /**
+   * Update imports in a specific file
+   */
+  async updateFileFiles(filePath, operation, dependencies) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      const lines = content.split('\n');
+      
+      // Update import statements to point to new location
+      const updatedLines = lines.map(line => {
+        if (line.includes(operation.sourcePath)) {
+          // Update import path
+          const relativePath = path.relative(
+            path.dirname(filePath),
+            path.dirname(operation.targetPath)
+          ).replace(/\\/g, '/');
+          
+          return line.replace(operation.sourcePath, relativePath);
+        }
+        return line;
+      });
+      
+      const newContent = updatedLines.join('\n');
+      fs.writeFileSync(filePath, newContent, 'utf8');
+      
+    } catch (error) {
+      // Log warning but don't fail the operation
+      console.warn(`Failed to update imports in ${filePath}:`, error.message);
+    }
+  }
+
+  /**
+   * Count affected files
+   */
+  countAffectedFiles(dependencies) {
+    // Count unique files that might need import updates
+    const affectedFiles = new Set();
+    
+    for (const dep of dependencies.imports) {
+      if (dep.isRelative) {
+        affectedFiles.add(dep.module);
+      }
+    }
+    
+    for (const dep of dependencies.requires) {
+      if (dep.isRelative) {
+        affectedFiles.add(dep.module);
+      }
+    }
+    
+    return affectedFiles.size;
+  }
+
+  /**
+   * Validate move operation
+   */
+  async validateMove(operation, result) {
+    try {
+      // Check if target file was created
+      if (!fs.existsSync(operation.targetPath)) {
+        throw new Error('Target file was not created');
+      }
+      
+      // Check if target file has content
+      const targetStats = fs.statSync(operation.targetPath);
+      if (targetStats.size === 0) {
+        result.addWarning('Target file is empty');
+      }
+      
+      // Validate syntax if JavaScript
+      if (operation.targetPath.endsWith('.js')) {
+        const targetContent = fs.readFileSync(operation.targetPath, 'utf8');
+        this.validateJavaScriptSyntax(targetContent);
+      }
+      
+      // Check source file if modified
+      if (result.sourceModified && fs.existsSync(operation.sourcePath)) {
+        const sourceContent = fs.readFileSync(operation.sourcePath, 'utf8');
+        if (operation.sourcePath.endsWith('.js')) {
+          this.validateJavaScriptSyntax(sourceContent);
+        }
+      }
+      
+    } catch (error) {
+      result.addError(error);
+    }
+  }
+
+  /**
+   * Validate JavaScript syntax
+   */
+  validateJavaScriptSyntax(content) {
+    try {
+      const vm = require('vm');
+      new vm.Script(content, { filename: 'validation' });
+    } catch (error) {
+      throw new Error(`Syntax validation failed: ${error.message}`);
+    }
+  }
+
+  /**
+   * Extract multiple segments
+   */
+  async extractSegments(sourcePath, segments) {
+    const results = [];
+    
+    for (const segmentConfig of segments) {
+      const operation = new MoveOperation(
+        MOVE_TYPES.EXTRACT,
+        sourcePath,
+        segmentConfig.targetPath,
+        segmentConfig
+      );
+      
+      const result = await this.executeMove(operation);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Consolidate multiple segments into one file
+   */
+  async consolidateSegments(segments, targetPath) {
+    const operation = new MoveOperation(
+      MOVE_TYPES.CONSOLIDATE,
+      segments[0].sourcePath,
+      targetPath,
+      {
+        segmentName: 'consolidated',
+        description: `Consolidate ${segments.length} segments`
+      }
+    );
+    
+    // Read all segments
+    const consolidatedContent = [];
+    
+    for (const segment of segments) {
+      const sourceContent = fs.readFileSync(segment.sourcePath, 'utf8');
+      const sourceLines = sourceContent.split('\n');
+      
+      const segmentData = this.extractSegment(sourceLines, {
+        startLine: segment.startLine,
+        endLine: segment.endLine
+      });
+      
+      consolidatedContent.push(segmentData.content);
+    }
+    
+    // Write consolidated file
+    const targetDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    
+    fs.writeFileSync(targetPath, consolidatedContent.join('\n\n'), 'utf8');
+    
+    return {
+      success: true,
+      segmentsConsolidated: segments.length,
+      targetPath,
+      linesWritten: consolidatedContent.join('\n\n').split('\n').length
+    };
+  }
+
+  /**
+   * Preview move operation without executing
+   */
+  previewMove(operation) {
+    try {
+      const sourceContent = fs.readFileSync(operation.sourcePath, 'utf8');
+      const sourceLines = sourceContent.split('\n');
+      
+      const segment = this.extractSegment(sourceLines, operation);
+      const dependencies = this.analyzeDependencies(segment.content);
+      
+      return {
+        operation,
+        segment: {
+          lines: segment.lines.length,
+          preview: segment.lines.slice(0, 10).join('\n') + (segment.lines.length > 10 ? '\n...' : '')
+        },
+        dependencies,
+        estimatedImpact: this.estimateImpact(operation, dependencies)
+      };
+      
+    } catch (error) {
+      return {
+        operation,
+        error: error.message,
+        success: false
+      };
+    }
+  }
+
+  /**
+   * Estimate impact of move operation
+   */
+  estimateImpact(operation, dependencies) {
+    const impact = {
+      filesAffected: 1,
+      importsToUpdate: 0,
+      riskLevel: 'low'
+    };
+    
+    // Count dependent files
+    const dependentFiles = this.findDependentFiles(operation.sourcePath);
+    impact.filesAffected += dependentFiles.length;
+    impact.importsToUpdate = dependentFiles.length;
+    
+    // Assess risk level
+    if (impact.filesAffected > 10) {
+      impact.riskLevel = 'high';
+    } else if (impact.filesAffected > 3) {
+      impact.riskLevel = 'medium';
+    }
+    
+    return impact;
+  }
+
+  /**
+   * Get move statistics
+   */
+  getStatistics(results) {
+    const stats = {
+      totalOperations: results.length,
+      successful: 0,
+      failed: 0,
+      totalLinesMoved: 0,
+      totalFilesAffected: 0,
+      byType: {},
+      errors: [],
+      warnings: []
+    };
+    
+    for (const result of results) {
+      if (result.success) {
+        stats.successful++;
+      } else {
+        stats.failed++;
+      }
+      
+      stats.totalLinesMoved += result.metadata.linesMoved;
+      stats.totalFilesAffected += result.metadata.filesAffected;
+      
+      const type = result.operation.type;
+      if (!stats.byType[type]) {
+        stats.byType[type] = 0;
+      }
+      stats.byType[type]++;
+      
+      stats.errors.push(...result.errors);
+      stats.warnings.push(...result.warnings);
+    }
+    
+    return stats;
+  }
+}
+
+module.exports = {
+  CodeMover,
+  MoveOperation,
+  MoveResult,
+  MOVE_TYPES
+};