vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/move-executor.js

@@ -0,0 +1,431 @@
+/**
+ * Code Move Executor
+ * 
+ * Executes code movement operations safely.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { RollbackManager } = require('../utils/rollback-manager');
+const { 
+  MOVE_TYPES,
+  createMoveOperation,
+  validateMoveOperation,
+  extractCodeSegment,
+  updateImportStatements,
+  createFileBackup,
+  validateCodeSyntax,
+  generateMoveReport,
+  calculateImportDependencies
+} = require('./move-utils');
+
+/**
+ * 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()
+    });
+  }
+
+  markSuccess() {
+    this.success = true;
+  }
+
+  getSummary() {
+    return {
+      success: this.success,
+      operation: this.operation.type,
+      filesAffected: this.metadata.filesAffected,
+      linesMoved: this.metadata.linesMoved,
+      errors: this.errors.length,
+      warnings: this.warnings.length
+    };
+  }
+}
+
+/**
+ * Move Executor class
+ */
+class MoveExecutor {
+  constructor(options = {}) {
+    this.options = {
+      autoBackup: options.autoBackup !== false,
+      validateSyntax: options.validateSyntax !== false,
+      updateImports: options.updateImports !== false,
+      preserveFormatting: options.preserveFormatting !== false,
+      ...options
+    };
+    
+    this.rollbackManager = new RollbackManager();
+    this.history = [];
+  }
+
+  async executeMove(operation) {
+    const startTime = Date.now();
+    const result = new MoveResult(operation);
+    
+    try {
+      // Validate operation
+      const validation = validateMoveOperation(operation);
+      if (!validation.isValid) {
+        validation.errors.forEach(error => result.addError(new Error(error)));
+        return result;
+      }
+      
+      validation.warnings.forEach(warning => result.addWarning(warning));
+      
+      // Create backup if enabled
+      let backupPath = null;
+      if (this.options.autoBackup) {
+        backupPath = await createFileBackup(operation.source.filePath);
+        result.addWarning(`Created backup: ${backupPath}`);
+      }
+      
+      // Execute the move
+      await this.performMove(operation, result);
+      
+      // Update rollback history
+      if (result.success) {
+        this.rollbackManager.recordOperation({
+          type: 'move',
+          operation,
+          backupPath,
+          timestamp: new Date().toISOString()
+        });
+      }
+      
+      result.metadata.duration = Date.now() - startTime;
+      result.markSuccess();
+      
+      return result;
+
+    } catch (error) {
+      result.addError(error);
+      result.metadata.duration = Date.now() - startTime;
+      
+      // Attempt rollback if move failed
+      if (backupPath) {
+        await this.attemptRollback(operation, backupPath, result);
+      }
+      
+      return result;
+    }
+  }
+
+  async performMove(operation, result) {
+    // Read source file
+    const sourceContent = await fs.promises.readFile(operation.source.filePath, 'utf8');
+    const sourceLines = sourceContent.split('\n');
+    
+    // Extract code segment
+    const codeSegment = extractCodeSegment(sourceLines, operation.source.startLine, operation.source.endLine);
+    
+    // Validate syntax if enabled
+    if (this.options.validateSyntax) {
+      const syntaxValidation = validateCodeSyntax(codeSegment);
+      if (!syntaxValidation.isValid) {
+        result.addError(new Error(`Syntax validation failed: ${syntaxValidation.errors[0].message}`));
+        return;
+      }
+    }
+    
+    // Remove code from source
+    const updatedSourceContent = this.removeCodeSegment(sourceContent, operation.source.startLine, operation.source.endLine);
+    await fs.promises.writeFile(operation.source.filePath, updatedSourceContent, 'utf8');
+    result.sourceModified = true;
+    
+    // Add code to target
+    await this.addCodeToTarget(operation, codeSegment, result);
+    
+    // Update imports if enabled
+    if (this.options.updateImports) {
+      await this.updateImports(operation, result);
+    }
+    
+    result.metadata.linesMoved = operation.source.endLine - operation.source.startLine + 1;
+    result.metadata.filesAffected = 2; // source and target
+  }
+
+  async addCodeToTarget(operation, codeSegment, result) {
+    const targetExists = fs.existsSync(operation.target.filePath);
+    
+    if (targetExists) {
+      // Insert into existing file
+      const targetContent = await fs.promises.readFile(operation.target.filePath, 'utf8');
+      const targetLines = targetContent.split('\n');
+      
+      const insertPosition = this.calculateInsertPosition(targetLines, operation.target.insertPosition);
+      const updatedTargetContent = this.insertCodeSegment(targetContent, codeSegment, insertPosition);
+      
+      await fs.promises.writeFile(operation.target.filePath, updatedTargetContent, 'utf8');
+    } else {
+      // Create new file
+      await fs.promises.writeFile(operation.target.filePath, codeSegment, 'utf8');
+    }
+    
+    result.targetCreated = true;
+  }
+
+  async updateImports(operation, result) {
+    try {
+      // Update source file imports
+      const sourceContent = await fs.promises.readFile(operation.source.filePath, 'utf8');
+      const sourceDependencies = calculateImportDependencies(sourceContent);
+      
+      // Update target file imports
+      const targetContent = await fs.promises.readFile(operation.target.filePath, 'utf8');
+      const targetDependencies = calculateImportDependencies(targetContent);
+      
+      // Calculate import changes
+      const importChanges = this.calculateImportChanges(sourceDependencies, targetDependencies, operation);
+      
+      // Apply import changes
+      if (importChanges.source.length > 0) {
+        const updatedSourceContent = updateImportStatements(sourceContent, importChanges.source);
+        await fs.promises.writeFile(operation.source.filePath, updatedSourceContent, 'utf8');
+      }
+      
+      if (importChanges.target.length > 0) {
+        const updatedTargetContent = updateImportStatements(targetContent, importChanges.target);
+        await fs.promises.writeFile(operation.target.filePath, updatedTargetContent, 'utf8');
+      }
+      
+      result.importsUpdated = true;
+      
+    } catch (error) {
+      result.addWarning(`Failed to update imports: ${error.message}`);
+    }
+  }
+
+  removeCodeSegment(content, startLine, endLine) {
+    const lines = content.split('\n');
+    
+    // Remove the specified segment
+    const beforeSegment = lines.slice(0, startLine - 1);
+    const afterSegment = lines.slice(endLine);
+    
+    return [...beforeSegment, ...afterSegment].join('\n');
+  }
+
+  insertCodeSegment(content, codeSegment, insertPosition) {
+    const lines = content.split('\n');
+    const codeLines = codeSegment.split('\n');
+    
+    // Insert code at specified position
+    const beforeInsert = lines.slice(0, insertPosition);
+    const afterInsert = lines.slice(insertPosition);
+    
+    return [...beforeInsert, ...codeLines, ...afterInsert].join('\n');
+  }
+
+  calculateInsertPosition(lines, insertPosition) {
+    switch (insertPosition) {
+      case 'start':
+        return 0;
+      case 'end':
+        return lines.length;
+      case 'middle':
+        return Math.floor(lines.length / 2);
+      default:
+        if (typeof insertPosition === 'number') {
+          return Math.max(0, Math.min(insertPosition, lines.length));
+        }
+        return lines.length;
+    }
+  }
+
+  calculateImportChanges(sourceDependencies, targetDependencies, operation) {
+    const changes = {
+      source: [],
+      target: []
+    };
+    
+    // Calculate relative path between files
+    const relativePath = path.relative(
+      path.dirname(operation.source.filePath),
+      path.dirname(operation.target.filePath)
+    );
+    
+    // Source file changes (remove moved dependencies)
+    sourceDependencies.forEach(dep => {
+      const movedModule = path.basename(operation.source.filePath, '.js');
+      if (dep.module.includes(movedModule)) {
+        changes.source.push({
+          oldPath: dep.module,
+          newPath: null,
+          type: dep.type
+        });
+      }
+    });
+    
+    // Target file changes (add new dependencies)
+    targetDependencies.forEach(dep => {
+      const needsUpdate = this.shouldUpdateImport(dep, operation);
+      if (needsUpdate) {
+        changes.target.push({
+          oldPath: dep.module,
+          newPath: this.calculateNewImportPath(dep.module, relativePath),
+          type: dep.type
+        });
+      }
+    });
+    
+    return changes;
+  }
+
+  shouldUpdateImport(dependency, operation) {
+    // Check if dependency needs to be updated based on move operation
+    const sourceBase = path.basename(operation.source.filePath, '.js');
+    const targetBase = path.basename(operation.target.filePath, '.js');
+    
+    return dependency.module.includes(sourceBase) || dependency.module === './' + sourceBase;
+  }
+
+  calculateNewImportPath(oldPath, relativePath) {
+    if (oldPath.startsWith('./')) {
+      return path.join(relativePath, oldPath.substring(2));
+    } else if (oldPath.startsWith('../')) {
+      return path.join('..', relativePath, oldPath.substring(3));
+    } else {
+      return path.join(relativePath, oldPath);
+    }
+  }
+
+  async attemptRollback(operation, backupPath, result) {
+    try {
+      result.addWarning('Attempting rollback due to move failure');
+      
+      // Restore source file from backup
+      if (backupPath && fs.existsSync(backupPath)) {
+        const backupContent = await fs.promises.readFile(backupPath, 'utf8');
+        await fs.promises.writeFile(operation.source.filePath, backupContent, 'utf8');
+        result.addWarning('Source file restored from backup');
+      }
+      
+      // Remove target file if it was created
+      if (result.targetCreated && fs.existsSync(operation.target.filePath)) {
+        await fs.promises.unlink(operation.target.filePath);
+        result.addWarning('Target file removed during rollback');
+      }
+      
+    } catch (rollbackError) {
+      result.addError(new Error(`Rollback failed: ${rollbackError.message}`));
+    }
+  }
+
+  async executeBatchMove(operations) {
+    const results = [];
+    const batchStartTime = Date.now();
+    
+    for (const operation of operations) {
+      const result = await this.executeMove(operation);
+      results.push(result);
+      
+      // Stop on first failure if not in continue mode
+      if (!result.success && !this.options.continueOnError) {
+        break;
+      }
+    }
+    
+    // Record batch operation
+    this.rollbackManager.recordOperation({
+      type: 'batch_move',
+      operations,
+      results,
+      timestamp: new Date().toISOString(),
+      duration: Date.now() - batchStartTime
+    });
+    
+    return {
+      results,
+      summary: {
+        total: operations.length,
+        successful: results.filter(r => r.success).length,
+        failed: results.filter(r => !r.success).length,
+        duration: Date.now() - batchStartTime
+      }
+    };
+  }
+
+  getExecutionHistory() {
+    return this.history;
+  }
+
+  async rollbackLastMove() {
+    const lastOperation = this.rollbackManager.getLastOperation();
+    if (!lastOperation) {
+      throw new Error('No operations to rollback');
+    }
+    
+    return await this.rollbackManager.rollback(lastOperation.id);
+  }
+
+  generateReport(operation, result) {
+    return generateMoveReport(operation, result);
+  }
+
+  getExecutorInfo() {
+    return {
+      supportedTypes: Object.values(MOVE_TYPES),
+      defaultOptions: this.options,
+      features: [
+        'code extraction',
+        'import management',
+        'backup creation',
+        'syntax validation',
+        'rollback support',
+        'batch operations'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new MoveExecutor({
+      autoBackup: true,
+      validateSyntax: true,
+      updateImports: true,
+      preserveFormatting: true,
+      ...config
+    });
+  }
+
+  static createForRefactoring(config = {}) {
+    return new MoveExecutor({
+      autoBackup: true,
+      validateSyntax: true,
+      updateImports: true,
+      preserveFormatting: false,
+      continueOnError: false,
+      ...config
+    });
+  }
+}
+
+module.exports = MoveExecutor;