vibecodingmachine-core 2026.2.26-1739 → 2026.3.9-850

package/src/refactoring/refactoring-operation.js

@@ -0,0 +1,94 @@
+/**
+ * Refactoring Operation
+ * 
+ * Represents a single refactoring operation within a plan.
+ */
+
+const { EXECUTION_STATUS } = require('./execution-status');
+
+/**
+ * Refactoring operation class
+ */
+class RefactoringOperation {
+  constructor(type, targetPath, options = {}) {
+    this.id = this.generateId();
+    this.type = type;
+    this.targetPath = targetPath;
+    this.options = options;
+    this.status = EXECUTION_STATUS.PENDING;
+    this.progress = 0;
+    this.result = null;
+    this.error = null;
+    this.startTime = null;
+    this.endTime = null;
+    this.dependencies = [];
+    this.dependents = [];
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      estimatedDuration: options.estimatedDuration || 0,
+      priority: options.priority || 'medium'
+    };
+  }
+
+  generateId() {
+    return `op_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  setStatus(status) {
+    this.status = status;
+    if (status === EXECUTION_STATUS.RUNNING && !this.startTime) {
+      this.startTime = new Date().toISOString();
+    }
+    if ([EXECUTION_STATUS.COMPLETED, EXECUTION_STATUS.FAILED, EXECUTION_STATUS.CANCELLED].includes(status)) {
+      this.endTime = new Date().toISOString();
+    }
+  }
+
+  setProgress(progress) {
+    this.progress = Math.max(0, Math.min(100, progress));
+  }
+
+  setResult(result) {
+    this.result = result;
+  }
+
+  setError(error) {
+    this.error = error;
+  }
+
+  addDependency(operationId) {
+    if (!this.dependencies.includes(operationId)) {
+      this.dependencies.push(operationId);
+    }
+  }
+
+  addDependent(operationId) {
+    if (!this.dependents.includes(operationId)) {
+      this.dependents.push(operationId);
+    }
+  }
+
+  getDuration() {
+    if (!this.startTime) return 0;
+    const end = this.endTime ? new Date(this.endTime) : new Date();
+    const start = new Date(this.startTime);
+    return (end - start) / 1000; // seconds
+  }
+
+  isReady(dependencies) {
+    if (this.status !== EXECUTION_STATUS.PENDING) return false;
+    
+    for (const depId of this.dependencies) {
+      const dep = dependencies.get(depId);
+      if (!dep || dep.status !== EXECUTION_STATUS.COMPLETED) {
+        return false;
+      }
+    }
+    
+    return true;
+  }
+}
+
+module.exports = {
+  RefactoringOperation
+};

package/src/refactoring/refactoring-plan.js

@@ -0,0 +1,69 @@
+/**
+ * Refactoring Plan
+ * 
+ * Manages a collection of refactoring operations with dependency tracking.
+ */
+
+const { EXECUTION_STATUS } = require('./execution-status');
+
+/**
+ * Refactoring execution plan class
+ */
+class RefactoringPlan {
+  constructor(name) {
+    this.id = this.generateId();
+    this.name = name;
+    this.operations = new Map();
+    this.status = EXECUTION_STATUS.PENDING;
+    this.metadata = {
+      createdAt: new Date().toISOString(),
+      estimatedDuration: 0,
+      totalOperations: 0
+    };
+  }
+
+  generateId() {
+    return `plan_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  addOperation(operation) {
+    this.operations.set(operation.id, operation);
+    this.metadata.totalOperations = this.operations.size;
+    this.updateEstimatedDuration();
+  }
+
+  updateEstimatedDuration() {
+    this.metadata.estimatedDuration = Array.from(this.operations.values())
+      .reduce((total, op) => total + (op.metadata.estimatedDuration || 0), 0);
+  }
+
+  getReadyOperations() {
+    return Array.from(this.operations.values())
+      .filter(op => op.isReady(this.operations));
+  }
+
+  getCompletedOperations() {
+    return Array.from(this.operations.values())
+      .filter(op => op.status === EXECUTION_STATUS.COMPLETED);
+  }
+
+  getFailedOperations() {
+    return Array.from(this.operations.values())
+      .filter(op => op.status === EXECUTION_STATUS.FAILED);
+  }
+
+  getProgress() {
+    if (this.operations.size === 0) return 0;
+    
+    const completed = this.getCompletedOperations().length;
+    return Math.round((completed / this.operations.size) * 100);
+  }
+
+  setStatus(status) {
+    this.status = status;
+  }
+}
+
+module.exports = {
+  RefactoringPlan
+};