vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/models/refactoring-plan.js

@@ -5,669 +5,8 @@
  * Provides structure for storing and managing refactoring operations.
  */
 
-const path = require('path');
-
-/**
- * Refactoring operation class
- */
-class RefactoringOperation {
-  constructor(type, targetPath, options = {}) {
-    this.id = this.generateId();
-    this.type = type;
-    this.targetPath = targetPath;
-    this.options = options;
-    this.status = 'pending';
-    this.priority = 'medium';
-    this.estimatedEffort = 0;
-    this.riskLevel = 'medium';
-    this.dependencies = [];
-    this.outputs = [];
-    this.steps = [];
-    this.metadata = {
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      version: '1.0.0'
-    };
-    this.results = null;
-    this.errors = [];
-    this.warnings = [];
-  }
-
-  generateId() {
-    return `op_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Add step to operation
-   */
-  addStep(step) {
-    this.steps.push({
-      ...step,
-      id: this.generateStepId(),
-      status: 'pending',
-      createdAt: new Date().toISOString()
-    });
-    this.metadata.updatedAt = new Date().toISOString();
-  }
-
-  generateStepId() {
-    return `step_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
-  }
-
-  /**
-   * Add dependency
-   */
-  addDependency(operationId) {
-    if (!this.dependencies.includes(operationId)) {
-      this.dependencies.push(operationId);
-    }
-  }
-
-  /**
-   * Add output
-   */
-  addOutput(outputPath) {
-    if (!this.outputs.includes(outputPath)) {
-      this.outputs.push(outputPath);
-    }
-  }
-
-  /**
-   * Set status
-   */
-  setStatus(status) {
-    this.status = status;
-    this.metadata.updatedAt = new Date().toISOString();
-  }
-
-  /**
-   * Set results
-   */
-  setResults(results) {
-    this.results = results;
-    this.metadata.updatedAt = new Date().toISOString();
-  }
-
-  /**
-   * Add error
-   */
-  addError(message, details = null) {
-    this.errors.push({
-      message,
-      details,
-      timestamp: new Date().toISOString()
-    });
-  }
-
-  /**
-   * Add warning
-   */
-  addWarning(message, details = null) {
-    this.warnings.push({
-      message,
-      details,
-      timestamp: new Date().toISOString()
-    });
-  }
-
-  /**
-   * Check if operation is ready to execute
-   */
-  isReady(dependencies) {
-    if (this.status !== 'pending') return false;
-    
-    for (const depId of this.dependencies) {
-      const dep = dependencies.get(depId);
-      if (!dep || dep.status !== 'completed') {
-        return false;
-      }
-    }
-    
-    return true;
-  }
-
-  /**
-   * Get execution summary
-   */
-  getSummary() {
-    return {
-      id: this.id,
-      type: this.type,
-      targetPath: this.targetPath,
-      status: this.status,
-      priority: this.priority,
-      estimatedEffort: this.estimatedEffort,
-      riskLevel: this.riskLevel,
-      stepCount: this.steps.length,
-      dependencyCount: this.dependencies.length,
-      outputCount: this.outputs.length,
-      errorCount: this.errors.length,
-      warningCount: this.warnings.length
-    };
-  }
-}
-
-/**
- * Refactoring phase class
- */
-class RefactoringPhase {
-  constructor(name, priority = 'medium') {
-    this.id = this.generateId();
-    this.name = name;
-    this.priority = priority;
-    this.operations = [];
-    this.status = 'pending';
-    this.metadata = {
-      createdAt: new Date().toISOString(),
-      startedAt: null,
-      completedAt: null,
-      version: '1.0.0'
-    };
-    this.results = null;
-  }
-
-  generateId() {
-    return `phase_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Add operation to phase
-   */
-  addOperation(operation) {
-    if (!(operation instanceof RefactoringOperation)) {
-      throw new Error('Operation must be a RefactoringOperation instance');
-    }
-    
-    this.operations.push(operation);
-  }
-
-  /**
-   * Get operations by status
-   */
-  getOperationsByStatus(status) {
-    return this.operations.filter(op => op.status === status);
-  }
-
-  /**
-   * Get completed operations
-   */
-  getCompletedOperations() {
-    return this.getOperationsByStatus('completed');
-  }
-
-  /**
-   * Get failed operations
-   */
-  getFailedOperations() {
-    return this.getOperationsByStatus('failed');
-  }
-
-  /**
-   * Get pending operations
-   */
-  getPendingOperations() {
-    return this.getOperationsByStatus('pending');
-  }
-
-  /**
-   * Start phase
-   */
-  start() {
-    this.status = 'in_progress';
-    this.metadata.startedAt = new Date().toISOString();
-  }
-
-  /**
-   * Complete phase
-   */
-  complete(results = null) {
-    this.status = 'completed';
-    this.metadata.completedAt = new Date().toISOString();
-    this.results = results;
-  }
-
-  /**
-   * Fail phase
-   */
-  fail(error) {
-    this.status = 'failed';
-    this.metadata.completedAt = new Date().toISOString();
-    this.results = { error };
-  }
-
-  /**
-   * Get progress percentage
-   */
-  getProgress() {
-    if (this.operations.length === 0) return 0;
-    
-    const completed = this.getCompletedOperations().length;
-    return Math.round((completed / this.operations.length) * 100);
-  }
-
-  /**
-   * Get summary
-   */
-  getSummary() {
-    const completed = this.getCompletedOperations().length;
-    const failed = this.getFailedOperations().length;
-    const pending = this.getPendingOperations().length;
-    
-    return {
-      id: this.id,
-      name: this.name,
-      priority: this.priority,
-      status: this.status,
-      operationCount: this.operations.length,
-      completedOperations: completed,
-      failedOperations: failed,
-      pendingOperations: pending,
-      progress: this.getProgress(),
-      estimatedEffort: this.operations.reduce((sum, op) => sum + op.estimatedEffort, 0)
-    };
-  }
-}
-
-/**
- * Refactoring plan class
- */
-class RefactoringPlan {
-  constructor(name, description = '') {
-    this.id = this.generateId();
-    this.name = name;
-    this.description = description;
-    this.phases = [];
-    this.status = 'draft';
-    this.metadata = {
-      createdAt: new Date().toISOString(),
-      updatedAt: new Date().toISOString(),
-      version: '1.0.0',
-      createdBy: 'system',
-      targetFiles: [],
-      analysisResults: null
-    };
-    this.results = null;
-    this.rollbackPlan = null;
-  }
-
-  generateId() {
-    return `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-  }
-
-  /**
-   * Add phase to plan
-   */
-  addPhase(phase) {
-    if (!(phase instanceof RefactoringPhase)) {
-      throw new Error('Phase must be a RefactoringPhase instance');
-    }
-    
-    this.phases.push(phase);
-    this.metadata.updatedAt = new Date().toISOString();
-  }
-
-  /**
-   * Get phase by ID
-   */
-  getPhase(phaseId) {
-    return this.phases.find(phase => phase.id === phaseId);
-  }
-
-  /**
-   * Get phases by status
-   */
-  getPhasesByStatus(status) {
-    return this.phases.filter(phase => phase.status === status);
-  }
-
-  /**
-   * Get current phase
-   */
-  getCurrentPhase() {
-    return this.phases.find(phase => phase.status === 'in_progress');
-  }
-
-  /**
-   * Get next phase
-   */
-  getNextPhase() {
-    const currentIndex = this.phases.findIndex(phase => phase.status === 'in_progress');
-    if (currentIndex >= 0 && currentIndex < this.phases.length - 1) {
-      return this.phases[currentIndex + 1];
-    }
-    
-    // If no current phase, return first pending phase
-    return this.phases.find(phase => phase.status === 'pending');
-  }
-
-  /**
-   * Start plan execution
-   */
-  start() {
-    if (this.phases.length === 0) {
-      throw new Error('Cannot start plan with no phases');
-    }
-    
-    this.status = 'in_progress';
-    this.metadata.updatedAt = new Date().toISOString();
-    
-    // Start first phase
-    const firstPhase = this.phases[0];
-    firstPhase.start();
-  }
-
-  /**
-   * Complete plan
-   */
-  complete(results = null) {
-    this.status = 'completed';
-    this.metadata.updatedAt = new Date().toISOString();
-    this.results = results;
-  }
-
-  /**
-   * Fail plan
-   */
-  fail(error) {
-    this.status = 'failed';
-    this.metadata.updatedAt = new Date().toISOString();
-    this.results = { error };
-  }
-
-  /**
-   * Pause plan
-   */
-  pause() {
-    this.status = 'paused';
-    this.metadata.updatedAt = new Date().toISOString();
-  }
-
-  /**
-   * Resume plan
-   */
-  resume() {
-    this.status = 'in_progress';
-    this.metadata.updatedAt = new Date().toISOString();
-  }
-
-  /**
-   * Get overall progress
-   */
-  getProgress() {
-    if (this.phases.length === 0) return 0;
-    
-    const totalOperations = this.phases.reduce((sum, phase) => sum + phase.operations.length, 0);
-    if (totalOperations === 0) return 0;
-    
-    const completedOperations = this.phases.reduce(
-      (sum, phase) => sum + phase.getCompletedOperations().length, 
-      0
-    );
-    
-    return Math.round((completedOperations / totalOperations) * 100);
-  }
-
-  /**
-   * Get total estimated effort
-   */
-  getTotalEffort() {
-    return this.phases.reduce((sum, phase) => 
-      sum + phase.operations.reduce((phaseSum, op) => phaseSum + op.estimatedEffort, 0), 
-      0
-    );
-  }
-
-  /**
-   * Get all operations
-   */
-  getAllOperations() {
-    return this.phases.flatMap(phase => phase.operations);
-  }
-
-  /**
-   * Get operations by status
-   */
-  getOperationsByStatus(status) {
-    return this.getAllOperations().filter(op => op.status === status);
-  }
-
-  /**
-   * Get operations by type
-   */
-  getOperationsByType(type) {
-    return this.getAllOperations().filter(op => op.type === type);
-  }
-
-  /**
-   * Get operations by priority
-   */
-  getOperationsByPriority(priority) {
-    return this.getAllOperations().filter(op => op.priority === priority);
-  }
-
-  /**
-   * Get high risk operations
-   */
-  getHighRiskOperations() {
-    return this.getAllOperations().filter(op => op.riskLevel === 'high' || op.riskLevel === 'critical');
-  }
-
-  /**
-   * Validate plan
-   */
-  validate() {
-    const issues = [];
-    
-    // Check if plan has phases
-    if (this.phases.length === 0) {
-      issues.push('Plan must have at least one phase');
-    }
-    
-    // Check if phases have operations
-    for (const phase of this.phases) {
-      if (phase.operations.length === 0) {
-        issues.push(`Phase "${phase.name}" has no operations`);
-      }
-    }
-    
-    // Check operation dependencies
-    const allOperations = this.getAllOperations();
-    for (const operation of allOperations) {
-      for (const depId of operation.dependencies) {
-        const dep = allOperations.find(op => op.id === depId);
-        if (!dep) {
-          issues.push(`Operation "${operation.id}" has invalid dependency: ${depId}`);
-        }
-      }
-    }
-    
-    // Check for circular dependencies
-    const circularDeps = this.detectCircularDependencies();
-    if (circularDeps.length > 0) {
-      issues.push(`Circular dependencies detected: ${circularDeps.join(', ')}`);
-    }
-    
-    return {
-      isValid: issues.length === 0,
-      issues
-    };
-  }
-
-  /**
-   * Detect circular dependencies
-   */
-  detectCircularDependencies() {
-    const operations = this.getAllOperations();
-    const visited = new Set();
-    const recursionStack = new Set();
-    const cycles = [];
-    
-    function dfs(operationId, path) {
-      if (recursionStack.has(operationId)) {
-        const cycleStart = path.indexOf(operationId);
-        cycles.push(path.slice(cycleStart).concat(operationId).join(' -> '));
-        return;
-      }
-      
-      if (visited.has(operationId)) return;
-      
-      visited.add(operationId);
-      recursionStack.add(operationId);
-      
-      const operation = operations.find(op => op.id === operationId);
-      if (operation) {
-        for (const depId of operation.dependencies) {
-          dfs(depId, path.concat(operationId));
-        }
-      }
-      
-      recursionStack.delete(operationId);
-    }
-    
-    for (const operation of operations) {
-      if (!visited.has(operation.id)) {
-        dfs(operation.id, []);
-      }
-    }
-    
-    return cycles;
-  }
-
-  /**
-   * Get execution order
-   */
-  getExecutionOrder() {
-    const operations = this.getAllOperations();
-    const visited = new Set();
-    const order = [];
-    
-    function visit(operation) {
-      if (visited.has(operation.id)) return;
-      
-      // Visit dependencies first
-      for (const depId of operation.dependencies) {
-        const dep = operations.find(op => op.id === depId);
-        if (dep) {
-          visit(dep);
-        }
-      }
-      
-      visited.add(operation.id);
-      order.push(operation);
-    }
-    
-    for (const operation of operations) {
-      if (!visited.has(operation.id)) {
-        visit(operation);
-      }
-    }
-    
-    return order;
-  }
-
-  /**
-   * Get summary
-   */
-  getSummary() {
-    const allOperations = this.getAllOperations();
-    const completed = this.getOperationsByStatus('completed').length;
-    const failed = this.getOperationsByStatus('failed').length;
-    const pending = this.getOperationsByStatus('pending').length;
-    const inProgress = this.getOperationsByStatus('in_progress').length;
-    
-    return {
-      id: this.id,
-      name: this.name,
-      description: this.description,
-      status: this.status,
-      phaseCount: this.phases.length,
-      operationCount: allOperations.length,
-      completedOperations: completed,
-      failedOperations: failed,
-      pendingOperations: pending,
-      inProgressOperations: inProgress,
-      progress: this.getProgress(),
-      totalEffort: this.getTotalEffort(),
-      highRiskOperations: this.getHighRiskOperations().length,
-      targetFiles: this.metadata.targetFiles.length,
-      createdAt: this.metadata.createdAt,
-      updatedAt: this.metadata.updatedAt
-    };
-  }
-
-  /**
-   * Convert to JSON
-   */
-  toJSON() {
-    return {
-      id: this.id,
-      name: this.name,
-      description: this.description,
-      status: this.status,
-      phases: this.phases.map(phase => ({
-        ...phase,
-        operations: phase.operations.map(op => op.getSummary())
-      })),
-      metadata: this.metadata,
-      results: this.results,
-      rollbackPlan: this.rollbackPlan
-    };
-  }
-
-  /**
-   * Create from JSON
-   */
-  static fromJSON(data) {
-    const plan = new RefactoringPlan(data.name, data.description);
-    
-    plan.id = data.id;
-    plan.status = data.status;
-    plan.metadata = { ...plan.metadata, ...data.metadata };
-    plan.results = data.results;
-    plan.rollbackPlan = data.rollbackPlan;
-    
-    // Recreate phases and operations
-    for (const phaseData of data.phases) {
-      const phase = new RefactoringPhase(phaseData.name, phaseData.priority);
-      phase.id = phaseData.id;
-      phase.status = phaseData.status;
-      phase.metadata = { ...phase.metadata, ...phaseData.metadata };
-      phase.results = phaseData.results;
-      
-      for (const opData of phaseData.operations) {
-        const operation = new RefactoringOperation(opData.type, opData.targetPath, opData.options);
-        operation.id = opData.id;
-        operation.status = opData.status;
-        operation.priority = opData.priority;
-        operation.estimatedEffort = opData.estimatedEffort;
-        operation.riskLevel = opData.riskLevel;
-        operation.dependencies = opData.dependencies;
-        operation.outputs = opData.outputs;
-        operation.results = opData.results;
-        operation.errors = opData.errors;
-        operation.warnings = opData.warnings;
-        operation.metadata = { ...operation.metadata, ...opData.metadata };
-        
-        phase.addOperation(operation);
-      }
-      
-      plan.addPhase(phase);
-    }
-    
-    return plan;
-  }
-}
-
-/**
- * Refactoring plan collection class
- */
-class RefactoringPlanCollection {
-  constructor() {
-    this.plans = new Map();
-    this.metadata = {
-      createdAt: new Date().toISOString(),
-      version: '1.0.0',
-      totalPlans: 0
+const { PlanManager } = require('./plan-manager');
+const { 
     };
   }