vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/models/plan-manager.js

@@ -0,0 +1,410 @@
+/**
+ * Refactoring Plan Manager
+ * 
+ * Manages refactoring plans and operations.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { 
+  RefactoringOperation,
+  RefactoringStep,
+  RefactoringPlan,
+  RefactoringResult
+} = require('./refactoring-models');
+
+/**
+ * Plan Manager class
+ */
+class PlanManager {
+  constructor(options = {}) {
+    this.options = {
+      autoSave: options.autoSave !== false,
+      backupPlans: options.backupPlans !== false,
+      planDirectory: options.planDirectory || './refactoring-plans',
+      ...options
+    };
+    
+    this.plans = new Map();
+    this.currentPlan = null;
+    this.history = [];
+  }
+
+  createPlan(name, description = '') {
+    const plan = new RefactoringPlan(name, description);
+    this.plans.set(plan.id, plan);
+    
+    if (this.options.autoSave) {
+      this.savePlan(plan);
+    }
+    
+    return plan;
+  }
+
+  loadPlan(planId) {
+    const plan = this.plans.get(planId);
+    if (!plan) {
+      throw new Error(`Plan not found: ${planId}`);
+    }
+    
+    this.currentPlan = plan;
+    return plan;
+  }
+
+  savePlan(plan) {
+    if (!this.plans.has(plan.id)) {
+      this.plans.set(plan.id, plan);
+    }
+    
+    if (this.options.autoSave) {
+      const planPath = path.join(this.options.planDirectory, `${plan.id}.json`);
+      
+      // Ensure directory exists
+      fs.mkdirSync(this.options.planDirectory, { recursive: true });
+      
+      // Save plan
+      fs.writeFileSync(planPath, JSON.stringify(plan.toJSON(), null, 2), 'utf8');
+    }
+  }
+
+  deletePlan(planId) {
+    const plan = this.plans.get(planId);
+    if (!plan) {
+      throw new Error(`Plan not found: ${planId}`);
+    }
+    
+    this.plans.delete(planId);
+    
+    if (this.currentPlan?.id === planId) {
+      this.currentPlan = null;
+    }
+    
+    // Delete plan file
+    const planPath = path.join(this.options.planDirectory, `${planId}.json`);
+    if (fs.existsSync(planPath)) {
+      fs.unlinkSync(planPath);
+    }
+  }
+
+  listPlans() {
+    return Array.from(this.plans.values()).map(plan => plan.getSummary());
+  }
+
+  getPlan(planId) {
+    return this.plans.get(planId);
+  }
+
+  getCurrentPlan() {
+    return this.currentPlan;
+  }
+
+  setCurrentPlan(planId) {
+    return this.loadPlan(planId);
+  }
+
+  addOperationToCurrentPlan(operationData) {
+    if (!this.currentPlan) {
+      throw new Error('No current plan set');
+    }
+    
+    const operation = new RefactoringOperation(
+      operationData.type,
+      operationData.targetPath,
+      operationData.options
+    );
+    
+    this.currentPlan.addOperation(operation);
+    
+    if (this.options.autoSave) {
+      this.savePlan(this.currentPlan);
+    }
+    
+    return operation;
+  }
+
+  addStepToOperation(operationId, stepData) {
+    const operation = this.getOperation(operationId);
+    if (!operation) {
+      throw new Error(`Operation not found: ${operationId}`);
+    }
+    
+    const step = new RefactoringStep(
+      stepData.name,
+      stepData.type,
+      stepData.options
+    );
+    
+    operation.addStep(step);
+    
+    if (this.options.autoSave) {
+      this.savePlan(this.currentPlan);
+    }
+    
+    return step;
+  }
+
+  getOperation(operationId) {
+    for (const plan of this.plans.values()) {
+      const operation = plan.operations.find(op => op.id === operationId);
+      if (operation) return operation;
+    }
+    return null;
+  }
+
+  executePlan(planId, options = {}) {
+    const plan = this.getPlan(planId);
+    if (!plan) {
+      throw new Error(`Plan not found: ${planId}`);
+    }
+    
+    const executionOptions = {
+      continueOnError: options.continueOnError || false,
+      parallel: options.parallel || false,
+      timeout: options.timeout || 300000, // 5 minutes
+      ...options
+    };
+    
+    return this.executePlanOperations(plan, executionOptions);
+  }
+
+  async executePlanOperations(plan, options) {
+    const results = [];
+    const startTime = Date.now();
+    
+    if (options.parallel) {
+      // Execute operations in parallel
+      const promises = plan.operations.map(op => this.executeOperation(op, options));
+      const operationResults = await Promise.allSettled(promises);
+      
+      operationResults.forEach((result, index) => {
+        if (result.status === 'fulfilled') {
+          results.push(result.value);
+        } else {
+          results.push({
+            success: false,
+            error: result.reason,
+            operationId: plan.operations[index].id
+          });
+        }
+      });
+    } else {
+      // Execute operations sequentially
+      for (const operation of plan.operations) {
+        const result = await this.executeOperation(operation, options);
+        results.push(result);
+        
+        // Stop on first failure if not continuing on error
+        if (!result.success && !options.continueOnError) {
+          break;
+        }
+      }
+    }
+    
+    const planResult = {
+      planId: plan.id,
+      success: results.every(r => r.success),
+      duration: Date.now() - startTime,
+      results,
+      summary: {
+        total: plan.operations.length,
+        successful: results.filter(r => r.success).length,
+        failed: results.filter(r => !r.success).length
+      }
+    };
+    
+    // Record in history
+    this.history.push(planResult);
+    
+    return planResult;
+  }
+
+  async executeOperation(operation, options) {
+    const result = new RefactoringResult(operation.id);
+    
+    try {
+      // Update operation status
+      operation.updateStatus('in_progress');
+      
+      // Execute steps
+      for (const step of operation.steps) {
+        const stepResult = await this.executeStep(step, options);
+        
+        if (!stepResult.success && !options.continueOnError) {
+          operation.updateStatus('failed');
+          result.fail(new Error(`Step ${step.name} failed`));
+          return result;
+        }
+      }
+      
+      // Mark operation as completed
+      operation.updateStatus('completed');
+      operation.setResults(result.outputs);
+      
+      result.complete(result.outputs, {
+        filesModified: operation.steps.length,
+        linesChanged: operation.steps.reduce((sum, step) => sum + (step.options.linesChanged || 0), 0)
+      });
+      
+      return result;
+      
+    } catch (error) {
+      operation.updateStatus('failed');
+      operation.addError(error);
+      result.fail(error);
+      return result;
+    }
+  }
+
+  async executeStep(step, options) {
+    step.start();
+    
+    try {
+      // Simulate step execution (in real scenario, this would call actual refactoring logic)
+      await this.simulateStepExecution(step);
+      
+      step.complete({
+        success: true,
+        message: `Step ${step.name} completed successfully`
+      });
+      
+      return {
+        success: true,
+        stepId: step.id,
+        duration: step.duration
+      };
+      
+    } catch (error) {
+      step.fail(error);
+      return {
+        success: false,
+        stepId: step.id,
+        error: error.message
+      };
+    }
+  }
+
+  async simulateStepExecution(step) {
+    // Simulate different step types
+    switch (step.type) {
+      case 'extract':
+        await this.simulateExtract(step);
+        break;
+      case 'move':
+        await this.simulateMove(step);
+        break;
+      case 'refactor':
+        await this.simulateRefactor(step);
+        break;
+      default:
+        await this.simulateGeneric(step);
+        break;
+    }
+  }
+
+  async simulateExtract(step) {
+    // Simulate extraction delay
+    await new Promise(resolve => setTimeout(resolve, 100));
+    step.updateProgress(50);
+    await new Promise(resolve => setTimeout(resolve, 100));
+    step.updateProgress(100);
+  }
+
+  async simulateMove(step) {
+    // Simulate move delay
+    await new Promise(resolve => setTimeout(resolve, 150));
+    step.updateProgress(33);
+    await new Promise(resolve => setTimeout(resolve, 150));
+    step.updateProgress(66);
+    await new Promise(resolve => setTimeout(resolve, 150));
+    step.updateProgress(100);
+  }
+
+  async simulateRefactor(step) {
+    // Simulate refactor delay
+    await new Promise(resolve => setTimeout(resolve, 200));
+    step.updateProgress(25);
+    await new Promise(resolve => setTimeout(resolve, 200));
+    step.updateProgress(50);
+    await new Promise(resolve => setTimeout(resolve, 200));
+    step.updateProgress(75);
+    await new Promise(resolve => setTimeout(resolve, 200));
+    step.updateProgress(100);
+  }
+
+  async simulateGeneric(step) {
+    // Simulate generic step delay
+    const delay = step.options.estimatedDuration || 100;
+    await new Promise(resolve => setTimeout(resolve, delay / 2));
+    step.updateProgress(50);
+    await new Promise(resolve => setTimeout(resolve, delay / 2));
+    step.updateProgress(100);
+  }
+
+  getExecutionHistory() {
+    return this.history;
+  }
+
+  exportPlan(planId, outputPath) {
+    const plan = this.getPlan(planId);
+    if (!plan) {
+      throw new Error(`Plan not found: ${planId}`);
+    }
+    
+    const exportData = {
+      plan: plan.toJSON(),
+      exportedAt: new Date().toISOString(),
+      version: '1.0.0'
+    };
+    
+    fs.writeFileSync(outputPath, JSON.stringify(exportData, null, 2), 'utf8');
+  }
+
+  importPlan(planPath) {
+    const planData = JSON.parse(fs.readFileSync(planPath, 'utf8'));
+    
+    const plan = new RefactoringPlan(planData.name, planData.description);
+    plan.id = planData.id;
+    plan.status = planData.status;
+    plan.priority = planData.priority;
+    plan.tags = planData.tags || [];
+    plan.metadata = planData.metadata;
+    
+    // Restore operations
+    planData.operations.forEach(opData => {
+      const operation = new RefactoringOperation(opData.type, opData.targetPath, opData.options);
+      Object.assign(operation, opData);
+      plan.addOperation(operation);
+    });
+    
+    this.plans.set(plan.id, plan);
+    return plan;
+  }
+
+  getManagerInfo() {
+    return {
+      supportedOperations: ['extract', 'move', 'refactor', 'consolidate'],
+      supportedStepTypes: ['extract', 'move', 'refactor', 'validate', 'test'],
+      defaultOptions: this.options,
+      features: [
+        'plan management',
+        'operation execution',
+        'step tracking',
+        'history recording',
+        'import/export',
+        'parallel execution'
+      ],
+      version: '1.0.0'
+    };
+  }
+
+  static createDefault(config = {}) {
+    return new PlanManager({
+      autoSave: true,
+      backupPlans: true,
+      planDirectory: './refactoring-plans',
+      ...config
+    });
+  }
+}
+
+module.exports = PlanManager;