vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/code-mover.js

@@ -5,382 +5,75 @@
  * Handles import updates and dependency management during moves.
  */
 
-const fs = require('fs');
-const path = require('path');
 const { RollbackManager } = require('../utils/rollback-manager');
+const MoveExecutor = require('./move-executor');
 
 /**
- * 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
+ * Code Mover class
  */
 class CodeMover {
   constructor(options = {}) {
     this.options = {
-      backupBeforeMove: true,
-      validateAfterMove: true,
-      updateImportsAutomatically: true,
-      preserveFormatting: true,
+      autoBackup: options.autoBackup !== false,
+      validateSyntax: options.validateSyntax !== false,
+      updateImports: options.updateImports !== false,
+      preserveFormatting: options.preserveFormatting !== false,
+      continueOnError: options.continueOnError || false,
       ...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
+    this.executor = new MoveExecutor(this.options);
+    this.moveHistory = [];
+  }
+
+  async moveCodeSegment(moveRequest) {
+    const operation = {
+      type: 'extract',
+      source: {
+        filePath: moveRequest.sourceFile,
+        startLine: moveRequest.startLine,
+        endLine: moveRequest.endLine
+      },
+      target: {
+        filePath: moveRequest.targetFile,
+        insertPosition: moveRequest.insertPosition || 'end'
+      },
+      options: this.options
     };
-  }
-
-  /**
-   * 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;
+    const result = await this.executor.executeMove(operation);
     
-    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
-            };
-          }
-        }
-      }
-    }
+    this.moveHistory.push({
+      operation,
+      result: result.getSummary(),
+      timestamp: new Date().toISOString()
+    });
     
-    return {
-      start: startLine,
-      end: lines.length
-    };
+    return result;
   }
 
-  /**
-   * Analyze dependencies in code segment
-   */
-  analyzeDependencies(content) {
-    const dependencies = {
-      imports: [],
-      requires: [],
-      internalRefs: [],
-      externalRefs: []
-    };
-
-    const lines = content.split('\n');
+  async extractFunction(functionName, sourceFile, targetFile) {
+    const sourceContent = await fs.promises.readFile(sourceFile, 'utf8');
+    const functionMatch = this.findFunctionDefinition(sourceContent, functionName);
     
-    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);
-          }
-        }
-      }
+    if (!functionMatch) {
+      throw new Error(`Function '${functionName}' not found in ${sourceFile}`);
     }
     
-    return dependencies;
+    const moveRequest = {
+      sourceFile,
+      targetFile,
+      startLine: functionMatch.startLine,
+      endLine: functionMatch.endLine,
+      insertPosition: 'end'
+    };
+    
+    return await this.moveCodeSegment(moveRequest);
   }
 
-  /**
-   * 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);
-  }
+  async extractClass(className, sourceFile, targetFile) {
+    const sourceContent = await fs.promises.readFile(sourceFile, 'utf8');
+    const classMatch = this.findClassDefinition(sourceContent, className);
 
   /**
    * Write target file

package/src/refactoring/execution-status.js

@@ -0,0 +1,18 @@
+/**
+ * Execution Status Constants
+ * 
+ * Defines the possible execution states for refactoring operations and plans.
+ */
+
+const EXECUTION_STATUS = {
+  PENDING: 'pending',
+  RUNNING: 'running',
+  COMPLETED: 'completed',
+  FAILED: 'failed',
+  PAUSED: 'paused',
+  CANCELLED: 'cancelled'
+};
+
+module.exports = {
+  EXECUTION_STATUS
+};

package/src/refactoring/execution-strategies.js

@@ -0,0 +1,172 @@
+/**
+ * Execution Strategies
+ * 
+ * Handles the execution of different types of refactoring operations.
+ */
+
+const { EXECUTION_STATUS } = require('./execution-status');
+
+/**
+ * Operation execution strategies
+ */
+class ExecutionStrategies {
+  constructor(components) {
+    this.fileSplitter = components.fileSplitter;
+    this.boundaryExtractor = components.boundaryExtractor;
+    this.codeMover = components.codeMover;
+    this.importManager = components.importManager;
+    this.circularDependencyResolver = components.circularDependencyResolver;
+  }
+
+  /**
+   * Execute file split operation
+   */
+  async executeSplitFile(operation) {
+    const { targetPath, splitPoints } = operation.options;
+    
+    // Read file analysis (would come from operation context)
+    const fileAnalysis = await this.analyzeFile(targetPath);
+    
+    const splitResult = await this.fileSplitter.splitFile(fileAnalysis, splitPoints);
+    
+    if (!splitResult.success) {
+      throw new Error(`File split failed: ${splitResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return splitResult;
+  }
+
+  /**
+   * Execute boundary extraction operation
+   */
+  async executeExtractBoundaries(operation) {
+    const { targetPath, boundaries } = operation.options;
+    
+    const extractionResult = await this.boundaryExtractor.extractBoundaries(targetPath);
+    
+    if (extractionResult.errors.length > 0) {
+      throw new Error(`Boundary extraction failed: ${extractionResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return extractionResult;
+  }
+
+  /**
+   * Execute code move operation
+   */
+  async executeMoveCode(operation) {
+    const { sourcePath, targetPath, segment } = operation.options;
+    
+    const moveOperation = {
+      type: 'extract',
+      sourcePath,
+      targetPath,
+      segmentName: segment.name,
+      startLine: segment.startLine,
+      endLine: segment.endLine
+    };
+    
+    const moveResult = await this.codeMover.executeMove(moveOperation);
+    
+    if (!moveResult.success) {
+      throw new Error(`Code move failed: ${moveResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return moveResult;
+  }
+
+  /**
+   * Execute import update operation
+   */
+  async executeUpdateImports(operation) {
+    const { targetPath, changes } = operation.options;
+    
+    const updateResult = await this.importManager.updateImports(targetPath, changes);
+    
+    if (!updateResult.success) {
+      throw new Error(`Import update failed: ${updateResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return updateResult;
+  }
+
+  /**
+   * Execute circular dependency resolution
+   */
+  async executeResolveCircularDeps(operation) {
+    const { rootPath, strategies } = operation.options;
+    
+    const analysisResult = await this.circularDependencyResolver.analyze(rootPath);
+    
+    if (analysisResult.errors.length > 0) {
+      throw new Error(`Circular dependency analysis failed: ${analysisResult.errors.map(e => e.message).join(', ')}`);
+    }
+    
+    return analysisResult;
+  }
+
+  /**
+   * Execute a single operation
+   */
+  async executeOperation(operation, result) {
+    console.log(`Executing operation: ${operation.type} on ${operation.targetPath}`);
+    operation.setStatus(EXECUTION_STATUS.RUNNING);
+    operation.setProgress(0);
+    
+    try {
+      let operationResult = null;
+      
+      switch (operation.type) {
+        case 'split_file':
+          operationResult = await this.executeSplitFile(operation);
+          break;
+          
+        case 'extract_boundaries':
+          operationResult = await this.executeExtractBoundaries(operation);
+          break;
+          
+        case 'move_code':
+          operationResult = await this.executeMoveCode(operation);
+          break;
+          
+        case 'update_imports':
+          operationResult = await this.executeUpdateImports(operation);
+          break;
+          
+        case 'resolve_circular_deps':
+          operationResult = await this.executeResolveCircularDeps(operation);
+          break;
+          
+        default:
+          throw new Error(`Unknown operation type: ${operation.type}`);
+      }
+      
+      operation.setResult(operationResult);
+      operation.setStatus(EXECUTION_STATUS.COMPLETED);
+      operation.setProgress(100);
+      
+      console.log(`Operation completed: ${operation.id}`);
+      
+    } catch (error) {
+      operation.setError(error);
+      operation.setStatus(EXECUTION_STATUS.FAILED);
+      throw error;
+    }
+  }
+
+  /**
+   * Analyze file for refactoring
+   */
+  async analyzeFile(filePath) {
+    // This would create a FileAnalysis object
+    // For now, return a placeholder
+    return {
+      filePath,
+      lineCount: 100,
+      needsRefactoring: true,
+      boundaries: null
+    };
+  }
+}
+
+module.exports = { ExecutionStrategies };