vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/models/refactoring-plan.js

@@ -0,0 +1,770 @@
+/**
+ * Refactoring Plan Data Model
+ * 
+ * Comprehensive data model for refactoring plans and strategies.
+ * 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
+    };
+  }
+
+  /**
+   * Add plan
+   */
+  add(plan) {
+    if (!(plan instanceof RefactoringPlan)) {
+      throw new Error('Plan must be a RefactoringPlan instance');
+    }
+    
+    this.plans.set(plan.id, plan);
+    this.updateMetadata();
+  }
+
+  /**
+   * Get plan by ID
+   */
+  get(planId) {
+    return this.plans.get(planId);
+  }
+
+  /**
+   * Remove plan
+   */
+  remove(planId) {
+    const removed = this.plans.delete(planId);
+    if (removed) {
+      this.updateMetadata();
+    }
+    return removed;
+  }
+
+  /**
+   * Get all plans
+   */
+  getAll() {
+    return Array.from(this.plans.values());
+  }
+
+  /**
+   * Get plans by status
+   */
+  getByStatus(status) {
+    return this.getAll().filter(plan => plan.status === status);
+  }
+
+  /**
+   * Get active plans
+   */
+  getActive() {
+    return this.getAll().filter(plan => 
+      plan.status === 'in_progress' || plan.status === 'paused'
+    );
+  }
+
+  /**
+   * Get completed plans
+   */
+  getCompleted() {
+    return this.getByStatus('completed');
+  }
+
+  /**
+   * Get failed plans
+   */
+  getFailed() {
+    return this.getByStatus('failed');
+  }
+
+  /**
+   * Update metadata
+   */
+  updateMetadata() {
+    this.metadata.totalPlans = this.plans.size;
+  }
+
+  /**
+   * Get summary statistics
+   */
+  getSummary() {
+    const plans = this.getAll();
+    
+    return {
+      totalPlans: plans.length,
+      activePlans: this.getActive().length,
+      completedPlans: this.getCompleted().length,
+      failedPlans: this.getFailed().length,
+      totalOperations: plans.reduce((sum, plan) => sum + plan.getAllOperations().length, 0),
+      totalEffort: plans.reduce((sum, plan) => sum + plan.getTotalEffort(), 0)
+    };
+  }
+}
+
+module.exports = {
+  RefactoringPlan,
+  RefactoringPhase,
+  RefactoringOperation,
+  RefactoringPlanCollection
+};