vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/utils/rollback/rollback-handlers.js

@@ -0,0 +1,125 @@
+/**
+ * Rollback Handlers
+ * 
+ * Contains the actual rollback execution logic for different operation types.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { ROLLBACK_TYPES } = require('./rollback-types');
+const { RollbackUtils } = require('./rollback-utils');
+
+/**
+ * Rollback execution handlers
+ */
+class RollbackHandlers {
+  /**
+   * Rollback file update
+   */
+  static async rollbackFileUpdate(operation) {
+    if (!operation.backupPath || !fs.existsSync(operation.backupPath)) {
+      throw new Error(`Backup not found for file update: ${operation.targetPath}`);
+    }
+
+    // Restore original file
+    fs.copyFileSync(operation.backupPath, operation.targetPath);
+  }
+
+  /**
+   * Rollback file creation
+   */
+  static async rollbackFileCreate(operation) {
+    if (fs.existsSync(operation.targetPath)) {
+      fs.unlinkSync(operation.targetPath);
+    }
+  }
+
+  /**
+   * Rollback file deletion
+   */
+  static async rollbackFileDelete(operation) {
+    if (!operation.backupPath || !fs.existsSync(operation.backupPath)) {
+      throw new Error(`Backup not found for file deletion: ${operation.targetPath}`);
+    }
+
+    // Ensure target directory exists
+    const targetDir = path.dirname(operation.targetPath);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+
+    // Restore deleted file
+    fs.copyFileSync(operation.backupPath, operation.targetPath);
+  }
+
+  /**
+   * Rollback file move
+   */
+  static async rollbackFileMove(operation) {
+    const originalPath = operation.metadata.originalPath;
+    
+    if (fs.existsSync(operation.targetPath)) {
+      // Move file back to original location
+      fs.renameSync(operation.targetPath, originalPath);
+    }
+  }
+
+  /**
+   * Rollback directory creation
+   */
+  static async rollbackDirectoryCreate(operation) {
+    if (fs.existsSync(operation.targetPath)) {
+      fs.rmSync(operation.targetPath, { recursive: true, force: true });
+    }
+  }
+
+  /**
+   * Rollback directory deletion
+   */
+  static async rollbackDirectoryDelete(operation) {
+    if (!operation.backupPath || !fs.existsSync(operation.backupPath)) {
+      throw new Error(`Backup not found for directory deletion: ${operation.targetPath}`);
+    }
+
+    // Restore deleted directory
+    RollbackUtils.copyDirectory(operation.backupPath, operation.targetPath);
+  }
+
+  /**
+   * Rollback a single operation by type
+   */
+  static async rollbackOperation(operation) {
+    if (operation.rollbackExecuted) {
+      throw new Error(`Operation already rolled back: ${operation.id}`);
+    }
+
+    switch (operation.type) {
+      case ROLLBACK_TYPES.FILE_UPDATE:
+        await RollbackHandlers.rollbackFileUpdate(operation);
+        break;
+      case ROLLBACK_TYPES.FILE_CREATE:
+        await RollbackHandlers.rollbackFileCreate(operation);
+        break;
+      case ROLLBACK_TYPES.FILE_DELETE:
+        await RollbackHandlers.rollbackFileDelete(operation);
+        break;
+      case ROLLBACK_TYPES.FILE_MOVE:
+        await RollbackHandlers.rollbackFileMove(operation);
+        break;
+      case ROLLBACK_TYPES.DIRECTORY_CREATE:
+        await RollbackHandlers.rollbackDirectoryCreate(operation);
+        break;
+      case ROLLBACK_TYPES.DIRECTORY_DELETE:
+        await RollbackHandlers.rollbackDirectoryDelete(operation);
+        break;
+      default:
+        throw new Error(`Unknown rollback operation type: ${operation.type}`);
+    }
+
+    operation.rollback();
+  }
+}
+
+module.exports = {
+  RollbackHandlers
+};

package/src/utils/rollback/rollback-operation.js

@@ -0,0 +1,63 @@
+/**
+ * Rollback Operation
+ * 
+ * Represents a single rollback operation with metadata and state tracking.
+ */
+
+const crypto = require('crypto');
+
+/**
+ * Rollback operation class
+ */
+class RollbackOperation {
+  constructor(type, targetPath, backupPath = null, metadata = {}) {
+    this.id = this.generateId();
+    this.type = type;
+    this.targetPath = targetPath;
+    this.backupPath = backupPath;
+    this.metadata = metadata;
+    this.timestamp = new Date().toISOString();
+    this.executed = false;
+    this.rollbackExecuted = false;
+  }
+
+  generateId() {
+    return crypto.randomBytes(16).toString('hex');
+  }
+
+  execute() {
+    this.executed = true;
+    this.executionTime = new Date().toISOString();
+  }
+
+  rollback() {
+    this.rollbackExecuted = true;
+    this.rollbackTime = new Date().toISOString();
+  }
+
+  /**
+   * Check if operation can be rolled back
+   */
+  canRollback() {
+    return this.executed && !this.rollbackExecuted;
+  }
+
+  /**
+   * Get operation summary
+   */
+  getSummary() {
+    return {
+      id: this.id,
+      type: this.type,
+      targetPath: this.targetPath,
+      timestamp: this.timestamp,
+      executed: this.executed,
+      rollbackExecuted: this.rollbackExecuted,
+      hasBackup: !!this.backupPath
+    };
+  }
+}
+
+module.exports = {
+  RollbackOperation
+};

package/src/utils/rollback/rollback-recorder.js

@@ -0,0 +1,166 @@
+/**
+ * Rollback Recorder
+ * 
+ * Handles recording of operations for potential rollback.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { RollbackOperation } = require('./rollback-operation');
+const { ROLLBACK_TYPES } = require('./rollback-types');
+const { RollbackUtils } = require('./rollback-utils');
+
+/**
+ * Rollback recording functionality
+ */
+class RollbackRecorder {
+  constructor(backupDir, sessionId) {
+    this.backupDir = backupDir;
+    this.sessionId = sessionId;
+  }
+
+  /**
+   * Get session backup directory
+   */
+  getSessionBackupDir() {
+    return path.join(this.backupDir, this.sessionId);
+  }
+
+  /**
+   * Create backup of a file before modification
+   */
+  backupFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found for backup: ${filePath}`);
+    }
+
+    const backupPath = RollbackUtils.getBackupPath(this.getSessionBackupDir(), filePath);
+    RollbackUtils.safeCopyFile(filePath, backupPath);
+
+    const metadata = RollbackUtils.getFileMetadata(filePath);
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_UPDATE,
+      filePath,
+      backupPath,
+      {
+        originalSize: metadata.size,
+        originalModified: metadata.modified
+      }
+    );
+
+    return operation;
+  }
+
+  /**
+   * Record file creation
+   */
+  recordFileCreation(filePath) {
+    const metadata = RollbackUtils.getFileMetadata(filePath);
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_CREATE,
+      filePath,
+      null,
+      {
+        createdTime: metadata.modified
+      }
+    );
+
+    return operation;
+  }
+
+  /**
+   * Record file deletion (with backup)
+   */
+  recordFileDeletion(filePath) {
+    let backupPath = null;
+    
+    if (fs.existsSync(filePath)) {
+      backupPath = RollbackUtils.getBackupPath(this.getSessionBackupDir(), filePath);
+      RollbackUtils.safeCopyFile(filePath, backupPath);
+    }
+
+    const metadata = RollbackUtils.getFileMetadata(filePath);
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_DELETE,
+      filePath,
+      backupPath,
+      {
+        originalSize: metadata.size,
+        originalModified: metadata.modified
+      }
+    );
+
+    return operation;
+  }
+
+  /**
+   * Record file move/rename
+   */
+  recordFileMove(oldPath, newPath) {
+    const backupPath = RollbackUtils.getBackupPath(this.getSessionBackupDir(), oldPath);
+    
+    if (fs.existsSync(oldPath)) {
+      RollbackUtils.safeCopyFile(oldPath, backupPath);
+    }
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_MOVE,
+      newPath,
+      backupPath,
+      {
+        originalPath: oldPath,
+        newPath: newPath
+      }
+    );
+
+    return operation;
+  }
+
+  /**
+   * Record directory creation
+   */
+  recordDirectoryCreation(dirPath) {
+    const metadata = RollbackUtils.getFileMetadata(dirPath);
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.DIRECTORY_CREATE,
+      dirPath,
+      null,
+      {
+        createdTime: metadata.modified
+      }
+    );
+
+    return operation;
+  }
+
+  /**
+   * Record directory deletion (with backup)
+   */
+  recordDirectoryDeletion(dirPath) {
+    const backupPath = RollbackUtils.getBackupPath(this.getSessionBackupDir(), dirPath);
+    
+    if (fs.existsSync(dirPath)) {
+      RollbackUtils.copyDirectory(dirPath, backupPath);
+    }
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.DIRECTORY_DELETE,
+      dirPath,
+      backupPath,
+      {
+        originalPath: dirPath
+      }
+    );
+
+    return operation;
+  }
+}
+
+module.exports = {
+  RollbackRecorder
+};

package/src/utils/rollback/rollback-state-manager.js

@@ -0,0 +1,175 @@
+/**
+ * Rollback State Manager
+ * 
+ * Handles state persistence, session management, and cleanup operations.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { RollbackOperation } = require('./rollback-operation');
+const { DEFAULT_CLEANUP_AGE } = require('./rollback-types');
+const { RollbackUtils } = require('./rollback-utils');
+
+/**
+ * Rollback state management
+ */
+class RollbackStateManager {
+  constructor(backupDir) {
+    this.backupDir = backupDir;
+  }
+
+  /**
+   * Generate unique session ID
+   */
+  generateSessionId() {
+    return `session_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
+  }
+
+  /**
+   * Ensure backup directory exists
+   */
+  ensureBackupDirectory(sessionId) {
+    if (!fs.existsSync(this.backupDir)) {
+      fs.mkdirSync(this.backupDir, { recursive: true });
+    }
+    
+    const sessionDir = path.join(this.backupDir, sessionId);
+    RollbackUtils.ensureDirectory(sessionDir);
+    
+    return sessionDir;
+  }
+
+  /**
+   * Save rollback state to file
+   */
+  saveState(sessionId, operations, summary) {
+    const sessionDir = path.join(this.backupDir, sessionId);
+    const stateFile = path.join(sessionDir, 'rollback-state.json');
+    
+    const state = {
+      sessionId,
+      operations,
+      summary,
+      savedAt: new Date().toISOString()
+    };
+
+    fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+    return stateFile;
+  }
+
+  /**
+   * Load rollback state from file
+   */
+  loadState(sessionId) {
+    const sessionDir = path.join(this.backupDir, sessionId);
+    const stateFile = path.join(sessionDir, 'rollback-state.json');
+
+    if (!fs.existsSync(stateFile)) {
+      throw new Error(`Rollback state not found: ${sessionId}`);
+    }
+
+    const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+    const operations = state.operations.map(op => Object.assign(new RollbackOperation(), op));
+
+    return {
+      ...state,
+      operations
+    };
+  }
+
+  /**
+   * List available rollback sessions
+   */
+  listSessions() {
+    if (!fs.existsSync(this.backupDir)) {
+      return [];
+    }
+
+    const sessions = [];
+    const entries = fs.readdirSync(this.backupDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith('session_')) {
+        const sessionDir = path.join(this.backupDir, entry.name);
+        const stateFile = path.join(sessionDir, 'rollback-state.json');
+        
+        if (fs.existsSync(stateFile)) {
+          try {
+            const state = JSON.parse(fs.readFileSync(stateFile, 'utf8'));
+            sessions.push({
+              sessionId: state.sessionId,
+              operationCount: state.operations.length,
+              createdAt: entry.name.replace('session_', '').split('_')[0],
+              summary: state.summary
+            });
+          } catch (error) {
+            // Skip invalid sessions
+          }
+        }
+      }
+    }
+
+    return sessions.sort((a, b) => b.createdAt - a.createdAt);
+  }
+
+  /**
+   * Cleanup old backup sessions
+   */
+  cleanup(maxAge = DEFAULT_CLEANUP_AGE) {
+    const sessions = this.listSessions();
+    const now = Date.now();
+    let cleaned = 0;
+
+    for (const session of sessions) {
+      const sessionAge = now - parseInt(session.createdAt);
+      if (sessionAge > maxAge) {
+        const sessionDir = path.join(this.backupDir, session.sessionId);
+        fs.rmSync(sessionDir, { recursive: true, force: true });
+        cleaned++;
+      }
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Get backup size for a session
+   */
+  getBackupSize(sessionId) {
+    const sessionDir = path.join(this.backupDir, sessionId);
+    if (!fs.existsSync(sessionDir)) {
+      return 0;
+    }
+
+    return RollbackUtils.getDirectorySize(sessionDir);
+  }
+
+  /**
+   * Generate operation summary
+   */
+  generateSummary(sessionId, operations) {
+    const summary = {
+      sessionId,
+      totalOperations: operations.length,
+      executedOperations: operations.filter(op => op.executed).length,
+      rollbackOperations: operations.filter(op => op.rollbackExecuted).length,
+      byType: {},
+      backupDirectory: path.join(this.backupDir, sessionId)
+    };
+
+    // Count operations by type
+    for (const operation of operations) {
+      if (!summary.byType[operation.type]) {
+        summary.byType[operation.type] = 0;
+      }
+      summary.byType[operation.type]++;
+    }
+
+    return summary;
+  }
+}
+
+module.exports = {
+  RollbackStateManager
+};

package/src/utils/rollback/rollback-types.js

@@ -0,0 +1,33 @@
+/**
+ * Rollback Types and Constants
+ * 
+ * Defines operation types and shared constants for rollback functionality.
+ */
+
+/**
+ * Rollback operation types
+ */
+const ROLLBACK_TYPES = {
+  FILE_CREATE: 'file_create',
+  FILE_UPDATE: 'file_update',
+  FILE_DELETE: 'file_delete',
+  FILE_MOVE: 'file_move',
+  DIRECTORY_CREATE: 'directory_create',
+  DIRECTORY_DELETE: 'directory_delete'
+};
+
+/**
+ * Default backup directory name
+ */
+const DEFAULT_BACKUP_DIR = '.refactoring-backups';
+
+/**
+ * Default cleanup age (7 days in milliseconds)
+ */
+const DEFAULT_CLEANUP_AGE = 7 * 24 * 60 * 60 * 1000;
+
+module.exports = {
+  ROLLBACK_TYPES,
+  DEFAULT_BACKUP_DIR,
+  DEFAULT_CLEANUP_AGE
+};

package/src/utils/rollback/rollback-utils.js

@@ -0,0 +1,110 @@
+/**
+ * Rollback Utilities
+ * 
+ * Utility functions for backup operations, directory management, and file operations.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Rollback utility functions
+ */
+class RollbackUtils {
+  /**
+   * Copy directory recursively
+   */
+  static copyDirectory(src, dest) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+
+      if (entry.isDirectory()) {
+        RollbackUtils.copyDirectory(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Get directory size recursively
+   */
+  static getDirectorySize(dirPath) {
+    let totalSize = 0;
+
+    try {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        
+        if (entry.isDirectory()) {
+          totalSize += RollbackUtils.getDirectorySize(fullPath);
+        } else {
+          totalSize += fs.statSync(fullPath).size;
+        }
+      }
+    } catch (error) {
+      // Directory might not exist or be inaccessible
+    }
+
+    return totalSize;
+  }
+
+  /**
+   * Ensure directory exists
+   */
+  static ensureDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  /**
+   * Safe file copy with directory creation
+   */
+  static safeCopyFile(src, dest) {
+    const destDir = path.dirname(dest);
+    RollbackUtils.ensureDirectory(destDir);
+    fs.copyFileSync(src, dest);
+  }
+
+  /**
+   * Generate backup path for a file
+   */
+  static getBackupPath(baseDir, filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    return path.join(baseDir, relativePath);
+  }
+
+  /**
+   * Get file metadata
+   */
+  static getFileMetadata(filePath) {
+    if (!fs.existsSync(filePath)) {
+      return {
+        size: 0,
+        modified: null,
+        exists: false
+      };
+    }
+
+    const stats = fs.statSync(filePath);
+    return {
+      size: stats.size,
+      modified: stats.mtime.toISOString(),
+      exists: true
+    };
+  }
+}
+
+module.exports = {
+  RollbackUtils
+};