vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/move-utils.js

@@ -0,0 +1,368 @@
+/**
+ * Code Movement Utilities
+ * 
+ * Utility functions for moving code segments between files.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Move operation types
+ */
+const MOVE_TYPES = {
+  EXTRACT: 'extract',
+  RELOCATE: 'relocate',
+  CONSOLIDATE: 'consolidate',
+  REORGANIZE: 'reorganize'
+};
+
+/**
+ * Create move operation
+ * @param {string} type - Move type
+ * @param {Object} source - Source information
+ * @param {Object} target - Target information
+ * @param {Object} options - Move options
+ * @returns {Object} - Move operation
+ */
+function createMoveOperation(type, source, target, options = {}) {
+  return {
+    type,
+    source: {
+      filePath: source.filePath,
+      startLine: source.startLine,
+      endLine: source.endLine,
+      content: source.content || null
+    },
+    target: {
+      filePath: target.filePath,
+      insertPosition: target.insertPosition || 'end',
+      content: target.content || null
+    },
+    options: {
+      updateImports: options.updateImports !== false,
+      createBackup: options.createBackup !== false,
+      validateSyntax: options.validateSyntax !== false,
+      preserveComments: options.preserveComments !== false,
+      ...options
+    },
+    metadata: {
+      createdAt: new Date().toISOString(),
+      id: generateMoveId()
+    }
+  };
+}
+
+/**
+ * Generate unique move ID
+ * @returns {string} - Move ID
+ */
+function generateMoveId() {
+  return `move_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+
+/**
+ * Extract code segment
+ * @param {Array} lines - File lines
+ * @param {number} start - Start line
+ * @param {number} end - End line
+ * @returns {string} - Extracted code
+ */
+function extractCodeSegment(lines, start, end) {
+  return lines.slice(start - 1, end).join('\n');
+}
+
+/**
+ * Validate move operation
+ * @param {Object} operation - Move operation
+ * @returns {Object} - Validation result
+ */
+function validateMoveOperation(operation) {
+  const validation = {
+    isValid: true,
+    errors: [],
+    warnings: []
+  };
+  
+  // Check source file exists
+  if (!fs.existsSync(operation.source.filePath)) {
+    validation.isValid = false;
+    validation.errors.push('Source file does not exist');
+  }
+  
+  // Check target directory exists
+  const targetDir = path.dirname(operation.target.filePath);
+  if (!fs.existsSync(targetDir)) {
+    validation.isValid = false;
+    validation.errors.push('Target directory does not exist');
+  }
+  
+  // Check line numbers
+  if (operation.source.startLine >= operation.source.endLine) {
+    validation.isValid = false;
+    validation.errors.push('Start line must be less than end line');
+  }
+  
+  // Check move type
+  if (!Object.values(MOVE_TYPES).includes(operation.type)) {
+    validation.isValid = false;
+    validation.errors.push('Invalid move type');
+  }
+  
+  // Warnings
+  if (operation.source.endLine - operation.source.startLine > 100) {
+    validation.warnings.push('Large code segment (>100 lines)');
+  }
+  
+  return validation;
+}
+
+/**
+ * Calculate import dependencies
+ * @param {string} content - Code content
+ * @returns {Array} - Array of dependencies
+ */
+function calculateImportDependencies(content) {
+  const dependencies = [];
+  const lines = content.split('\n');
+  
+  // Find require statements
+  lines.forEach(line => {
+    const requireMatch = line.match(/require\(['"]([^'"]+)['"]\)/);
+    if (requireMatch) {
+      dependencies.push({
+        type: 'require',
+        module: requireMatch[1],
+        line: line
+      });
+    }
+    
+    // Find import statements
+    const importMatch = line.match(/import\s+.*\s+from\s+['"]([^'"]+)['"]/);
+    if (importMatch) {
+      dependencies.push({
+        type: 'import',
+        module: importMatch[1],
+        line: line
+      });
+    }
+  });
+  
+  return dependencies;
+}
+
+/**
+ * Update import statements
+ * @param {string} content - File content
+ * @param {Object} changes - Import changes
+ * @returns {string} - Updated content
+ */
+function updateImportStatements(content, changes) {
+  let updatedContent = content;
+  
+  changes.forEach(change => {
+    const { oldPath, newPath, type } = change;
+    
+    if (type === 'require') {
+      const regex = new RegExp(`require\\(['"]${oldPath}['"]\\)`, 'g');
+      updatedContent = updatedContent.replace(regex, `require('${newPath}')`);
+    } else if (type === 'import') {
+      const regex = new RegExp(`from\\s+['"]${oldPath}['"]`, 'g');
+      updatedContent = updatedContent.replace(regex, `from '${newPath}'`);
+    }
+  });
+  
+  return updatedContent;
+}
+
+/**
+ * Create backup of file
+ * @param {string} filePath - File path
+ * @returns {Promise<string>} - Backup file path
+ */
+async function createFileBackup(filePath) {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.backup.${timestamp}`;
+  
+  try {
+    const content = await fs.promises.readFile(filePath, 'utf8');
+    await fs.promises.writeFile(backupPath, content, 'utf8');
+    return backupPath;
+  } catch (error) {
+    throw new Error(`Failed to create backup: ${error.message}`);
+  }
+}
+
+/**
+ * Validate syntax of code
+ * @param {string} content - Code content
+ * @returns {Object} - Syntax validation result
+ */
+function validateCodeSyntax(content) {
+  try {
+    // Basic syntax check using Function constructor
+    new Function(content);
+    return {
+      isValid: true,
+      errors: []
+    };
+  } catch (error) {
+    return {
+      isValid: false,
+      errors: [{
+        message: error.message,
+        line: extractErrorLine(error.message)
+      }]
+    };
+  }
+}
+
+/**
+ * Extract error line from error message
+ * @param {string} errorMessage - Error message
+ * @returns {number} - Line number
+ */
+function extractErrorLine(errorMessage) {
+  const match = errorMessage.match(/at line (\d+)/);
+  return match ? parseInt(match[1]) : 0;
+}
+
+/**
+ * Calculate move impact
+ * @param {Object} operation - Move operation
+ * @returns {Object} - Impact analysis
+ */
+function calculateMoveImpact(operation) {
+  const impact = {
+    filesAffected: 1,
+    linesMoved: operation.source.endLine - operation.source.startLine + 1,
+    dependenciesAffected: 0,
+    riskLevel: 'low'
+  };
+  
+  // Calculate dependencies if source content is available
+  if (operation.source.content) {
+    const dependencies = calculateImportDependencies(operation.source.content);
+    impact.dependenciesAffected = dependencies.length;
+    
+    // Risk assessment
+    if (impact.linesMoved > 50) {
+      impact.riskLevel = 'high';
+    } else if (impact.linesMoved > 20) {
+      impact.riskLevel = 'medium';
+    }
+  }
+  
+  return impact;
+}
+
+/**
+ * Generate move report
+ * @param {Object} operation - Move operation
+ * @param {Object} result - Move result
+ * @returns {Object} - Move report
+ */
+function generateMoveReport(operation, result) {
+  return {
+    operation: {
+      id: operation.metadata.id,
+      type: operation.type,
+      executedAt: operation.metadata.createdAt
+    },
+    result: {
+      success: result.success,
+      errors: result.errors,
+      warnings: result.warnings
+    },
+    impact: calculateMoveImpact(operation),
+    files: {
+      source: operation.source.filePath,
+      target: operation.target.filePath
+    },
+    summary: {
+      linesMoved: operation.source.endLine - operation.source.startLine + 1,
+      duration: result.duration || 0
+    }
+  };
+}
+
+/**
+ * Check for circular dependencies
+ * @param {Array} dependencies - Array of dependencies
+ * @param {string} currentModule - Current module path
+ * @returns {boolean} - Has circular dependencies
+ */
+function hasCircularDependencies(dependencies, currentModule) {
+  const visited = new Set();
+  const recursionStack = new Set();
+  
+  function checkDependency(module) {
+    if (recursionStack.has(module)) {
+      return true; // Circular dependency detected
+    }
+    
+    if (visited.has(module)) {
+      return false; // Already processed
+    }
+    
+    visited.add(module);
+    recursionStack.add(module);
+    
+    // Find dependencies of this module
+    const moduleDeps = dependencies.filter(dep => dep.module === module);
+    
+    for (const dep of moduleDeps) {
+      if (checkDependency(dep.module)) {
+        return true;
+      }
+    }
+    
+    recursionStack.delete(module);
+    return false;
+  }
+  
+  return checkDependency(currentModule);
+}
+
+/**
+ * Optimize import statements
+ * @param {string} content - File content
+ * @returns {string} - Optimized content
+ */
+function optimizeImportStatements(content) {
+  const lines = content.split('\n');
+  const imports = [];
+  const nonImportLines = [];
+  
+  // Separate imports from other code
+  lines.forEach(line => {
+    if (line.includes('require(') || line.includes('import ')) {
+      imports.push(line);
+    } else {
+      nonImportLines.push(line);
+    }
+  });
+  
+  // Sort and deduplicate imports
+  const sortedImports = [...new Set(imports)].sort();
+  
+  // Reconstruct file
+  return [...sortedImports, ...nonImportLines].join('\n');
+}
+
+module.exports = {
+  MOVE_TYPES,
+  createMoveOperation,
+  generateMoveId,
+  extractCodeSegment,
+  validateMoveOperation,
+  calculateImportDependencies,
+  updateImportStatements,
+  createFileBackup,
+  validateCodeSyntax,
+  extractErrorLine,
+  calculateMoveImpact,
+  generateMoveReport,
+  hasCircularDependencies,
+  optimizeImportStatements
+};

package/src/refactoring/operation-executor.js

@@ -0,0 +1,76 @@
+/**
+ * Operation Executor
+ * 
+ * Handles execution of individual refactoring operations.
+ */
+
+const { EXECUTION_STATUS } = require('./execution-status');
+const { ExecutionStrategies } = require('./execution-strategies');
+
+/**
+ * Operation executor class
+ */
+class OperationExecutor {
+  constructor(executionStrategies) {
+    this.executionStrategies = executionStrategies;
+  }
+
+  /**
+   * Execute a single operation
+   */
+  async executeOperation(operation, result) {
+    return this.executionStrategies.executeOperation(operation, result);
+  }
+
+  /**
+   * Execute operations in dependency order
+   */
+  async executeOperations(plan, result, options = {}) {
+    const executedOperations = new Set();
+    let pendingOperations = new Set(plan.operations.keys());
+    
+    while (pendingOperations.size > 0) {
+      // Find ready operations
+      const readyOperations = Array.from(pendingOperations)
+        .map(id => plan.operations.get(id))
+        .filter(op => op.isReady(plan.operations) && !executedOperations.has(op.id));
+      
+      if (readyOperations.length === 0) {
+        // Check for circular dependencies or blocked operations
+        const blockedOps = Array.from(pendingOperations)
+          .map(id => plan.operations.get(id))
+          .filter(op => !executedOperations.has(op.id));
+        
+        if (blockedOps.length > 0) {
+          throw new Error(`Circular dependency detected or operations blocked: ${blockedOps.map(op => op.id).join(', ')}`);
+        }
+        break;
+      }
+      
+      // Execute ready operations (with concurrency limit)
+      const batchSize = Math.min(readyOperations.length, options.maxConcurrentOperations || 3);
+      const batch = readyOperations.slice(0, batchSize);
+      
+      await Promise.all(batch.map(async operation => {
+        try {
+          await this.executeOperation(operation, result);
+          executedOperations.add(operation.id);
+          pendingOperations.delete(operation.id);
+          result.executedOperations++;
+        } catch (error) {
+          result.addError(error);
+          result.failedOperations++;
+          executedOperations.add(operation.id);
+          pendingOperations.delete(operation.id);
+          
+          // Don't continue on error if pauseOnError is enabled
+          if (options.pauseOnError) {
+            throw error;
+          }
+        }
+      }));
+    }
+  }
+}
+
+module.exports = { OperationExecutor };

package/src/refactoring/plan-creator.js

@@ -0,0 +1,36 @@
+/**
+ * Plan Creator
+ * 
+ * Creates refactoring plans from analysis results.
+ */
+
+const { RefactoringPlan } = require('./refactoring-plan');
+const { RefactoringOperation } = require('./refactoring-operation');
+
+/**
+ * Plan creator class
+ */
+class PlanCreator {
+  /**
+   * Create refactoring plan from analysis results
+   */
+  createPlan(analysisResults, options = {}) {
+    const plan = new RefactoringPlan(options.name || 'Auto-generated Plan');
+    
+    // Create operations based on analysis
+    for (const analysis of analysisResults.files || []) {
+      if (analysis.needsRefactoring) {
+        // Add split operation
+        const splitOp = new RefactoringOperation('split_file', analysis.filePath, {
+          estimatedDuration: 5,
+          priority: analysis.urgentRefactoring ? 'high' : 'medium'
+        });
+        plan.addOperation(splitOp);
+      }
+    }
+    
+    return plan;
+  }
+}
+
+module.exports = { PlanCreator };

package/src/refactoring/plan-executor.js

@@ -0,0 +1,143 @@
+/**
+ * Plan Executor
+ * 
+ * Handles execution of refactoring plans.
+ */
+
+const { EXECUTION_STATUS } = require('./execution-status');
+const { RefactoringExecutorResult } = require('./refactoring-executor-result');
+
+/**
+ * Plan executor class
+ */
+class PlanExecutor {
+  constructor(operationExecutor, testRunner, rollbackManager, options = {}) {
+    this.operationExecutor = operationExecutor;
+    this.testRunner = testRunner;
+    this.rollbackManager = rollbackManager;
+    this.options = options;
+    
+    this.currentPlan = null;
+    this.isExecuting = false;
+  }
+
+  /**
+   * Execute a refactoring plan
+   */
+  async executePlan(plan) {
+    if (this.isExecuting) {
+      throw new Error('Executor is already running a plan');
+    }
+    
+    this.currentPlan = plan;
+    this.isExecuting = true;
+    plan.setStatus(EXECUTION_STATUS.RUNNING);
+    
+    const result = new RefactoringExecutorResult(plan);
+    const startTime = Date.now();
+    
+    try {
+      console.log(`Executing refactoring plan: ${plan.name}`);
+      console.log(`Operations: ${plan.operations.size}`);
+      
+      // Run baseline tests if enabled
+      if (this.options.runTests) {
+        console.log('Running baseline tests...');
+        await this.testRunner.runBaseline();
+      }
+      
+      // Execute operations in dependency order
+      await this.operationExecutor.executeOperations(plan, result, this.options);
+      
+      // Run validation tests if enabled
+      if (this.options.runTests) {
+        console.log('Running validation tests...');
+        const testResult = await this.testRunner.runValidation();
+        
+        if (testResult.hasRegressions) {
+          throw new Error('Tests detected regressions after refactoring');
+        }
+      }
+      
+      result.setSuccess(true);
+      plan.setStatus(EXECUTION_STATUS.COMPLETED);
+      
+      console.log(`Plan execution completed successfully`);
+      
+    } catch (error) {
+      result.addError(error);
+      result.setSuccess(false);
+      plan.setStatus(EXECUTION_STATUS.FAILED);
+      
+      console.error(`Plan execution failed: ${error.message}`);
+      
+      // Rollback if enabled and there were failures
+      if (this.options.enableRollback && result.failedOperations > 0) {
+        console.log('Performing rollback...');
+        await this.rollbackManager.rollback();
+        result.setRollbackPerformed(true);
+      }
+      
+      if (this.options.pauseOnError) {
+        console.log('Execution paused due to error');
+        plan.setStatus(EXECUTION_STATUS.PAUSED);
+      }
+      
+    } finally {
+      result.duration = (Date.now() - startTime) / 1000;
+      this.isExecuting = false;
+      this.currentPlan = null;
+    }
+    
+    return result;
+  }
+
+  /**
+   * Cancel current execution
+   */
+  async cancelExecution() {
+    if (!this.isExecuting || !this.currentPlan) {
+      return false;
+    }
+    
+    this.currentPlan.setStatus(EXECUTION_STATUS.CANCELLED);
+    this.isExecuting = false;
+    
+    // Cancel running operations
+    for (const operation of this.currentPlan.operations.values()) {
+      if (operation.status === EXECUTION_STATUS.RUNNING) {
+        operation.setStatus(EXECUTION_STATUS.CANCELLED);
+      }
+    }
+    
+    return true;
+  }
+
+  /**
+   * Get execution status
+   */
+  getExecutionStatus() {
+    if (!this.currentPlan) {
+      return {
+        isExecuting: false,
+        plan: null,
+        progress: 0
+      };
+    }
+    
+    return {
+      isExecuting: this.isExecuting,
+      plan: {
+        id: this.currentPlan.id,
+        name: this.currentPlan.name,
+        status: this.currentPlan.status,
+        progress: this.currentPlan.getProgress(),
+        totalOperations: this.currentPlan.operations.size,
+        completedOperations: this.currentPlan.getCompletedOperations().length,
+        failedOperations: this.currentPlan.getFailedOperations().length
+      }
+    };
+  }
+}
+
+module.exports = { PlanExecutor };

package/src/refactoring/plan-validator.js

@@ -0,0 +1,68 @@
+/**
+ * Plan Validator
+ * 
+ * Validates refactoring plans before execution.
+ */
+
+/**
+ * Validates refactoring plans
+ */
+class PlanValidator {
+  /**
+   * Validate plan before execution
+   */
+  validatePlan(plan) {
+    const issues = [];
+    
+    // Check for circular dependencies
+    const visited = new Set();
+    const recursionStack = new Set();
+    
+    function hasCircularDeps(operationId) {
+      if (recursionStack.has(operationId)) {
+        return true;
+      }
+      
+      if (visited.has(operationId)) {
+        return false;
+      }
+      
+      visited.add(operationId);
+      recursionStack.add(operationId);
+      
+      const operation = plan.operations.get(operationId);
+      if (operation) {
+        for (const depId of operation.dependencies) {
+          if (hasCircularDeps(depId)) {
+            return true;
+          }
+        }
+      }
+      
+      recursionStack.delete(operationId);
+      return false;
+    }
+    
+    for (const operationId of plan.operations.keys()) {
+      if (hasCircularDeps(operationId)) {
+        issues.push(`Circular dependency detected for operation: ${operationId}`);
+      }
+    }
+    
+    // Check for missing dependencies
+    for (const operation of plan.operations.values()) {
+      for (const depId of operation.dependencies) {
+        if (!plan.operations.has(depId)) {
+          issues.push(`Missing dependency: ${depId} for operation: ${operation.id}`);
+        }
+      }
+    }
+    
+    return {
+      isValid: issues.length === 0,
+      issues
+    };
+  }
+}
+
+module.exports = { PlanValidator };