vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

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

@@ -0,0 +1,569 @@
+/**
+ * Rollback Manager
+ * 
+ * Manages rollback capabilities for refactoring operations.
+ * Provides safe backup and restore functionality.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+/**
+ * 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'
+};
+
+/**
+ * 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();
+  }
+}
+
+/**
+ * Rollback manager class
+ */
+class RollbackManager {
+  constructor(backupDir = '.refactoring-backups') {
+    this.backupDir = path.resolve(backupDir);
+    this.operations = [];
+    this.sessionId = this.generateSessionId();
+    this.ensureBackupDirectory();
+  }
+
+  /**
+   * Generate unique session ID
+   */
+  generateSessionId() {
+    return `session_${Date.now()}_${crypto.randomBytes(8).toString('hex')}`;
+  }
+
+  /**
+   * Ensure backup directory exists
+   */
+  ensureBackupDirectory() {
+    if (!fs.existsSync(this.backupDir)) {
+      fs.mkdirSync(this.backupDir, { recursive: true });
+    }
+    
+    const sessionDir = path.join(this.backupDir, this.sessionId);
+    if (!fs.existsSync(sessionDir)) {
+      fs.mkdirSync(sessionDir, { recursive: true });
+    }
+  }
+
+  /**
+   * 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 = this.getBackupPath(filePath);
+    const backupDir = path.dirname(backupPath);
+    
+    // Ensure backup directory exists
+    if (!fs.existsSync(backupDir)) {
+      fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    // Copy file to backup location
+    fs.copyFileSync(filePath, backupPath);
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_UPDATE,
+      filePath,
+      backupPath,
+      {
+        originalSize: fs.statSync(filePath).size,
+        originalModified: fs.statSync(filePath).mtime.toISOString()
+      }
+    );
+
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record file creation
+   */
+  recordFileCreation(filePath) {
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_CREATE,
+      filePath,
+      null,
+      {
+        createdTime: fs.existsSync(filePath) ? fs.statSync(filePath).mtime.toISOString() : null
+      }
+    );
+
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record file deletion (with backup)
+   */
+  recordFileDeletion(filePath) {
+    let backupPath = null;
+    
+    if (fs.existsSync(filePath)) {
+      backupPath = this.getBackupPath(filePath);
+      const backupDir = path.dirname(backupPath);
+      
+      if (!fs.existsSync(backupDir)) {
+        fs.mkdirSync(backupDir, { recursive: true });
+      }
+      
+      fs.copyFileSync(filePath, backupPath);
+    }
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_DELETE,
+      filePath,
+      backupPath,
+      {
+        originalSize: fs.existsSync(filePath) ? fs.statSync(filePath).size : 0,
+        originalModified: fs.existsSync(filePath) ? fs.statSync(filePath).mtime.toISOString() : null
+      }
+    );
+
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record file move/rename
+   */
+  recordFileMove(oldPath, newPath) {
+    const backupPath = this.getBackupPath(oldPath);
+    const backupDir = path.dirname(backupPath);
+    
+    if (!fs.existsSync(backupDir)) {
+      fs.mkdirSync(backupDir, { recursive: true });
+    }
+
+    if (fs.existsSync(oldPath)) {
+      fs.copyFileSync(oldPath, backupPath);
+    }
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.FILE_MOVE,
+      newPath,
+      backupPath,
+      {
+        originalPath: oldPath,
+        newPath: newPath
+      }
+    );
+
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record directory creation
+   */
+  recordDirectoryCreation(dirPath) {
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.DIRECTORY_CREATE,
+      dirPath,
+      null,
+      {
+        createdTime: fs.existsSync(dirPath) ? fs.statSync(dirPath).mtime.toISOString() : null
+      }
+    );
+
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Record directory deletion (with backup)
+   */
+  recordDirectoryDeletion(dirPath) {
+    const backupPath = this.getBackupPath(dirPath);
+    
+    if (fs.existsSync(dirPath)) {
+      this.copyDirectory(dirPath, backupPath);
+    }
+
+    const operation = new RollbackOperation(
+      ROLLBACK_TYPES.DIRECTORY_DELETE,
+      dirPath,
+      backupPath,
+      {
+        originalPath: dirPath
+      }
+    );
+
+    this.operations.push(operation);
+    return operation;
+  }
+
+  /**
+   * Execute rollback for all operations
+   */
+  async rollback() {
+    const results = {
+      success: [],
+      failed: [],
+      skipped: []
+    };
+
+    // Execute rollbacks in reverse order
+    for (let i = this.operations.length - 1; i >= 0; i--) {
+      const operation = this.operations[i];
+      
+      try {
+        await this.rollbackOperation(operation);
+        results.success.push(operation);
+      } catch (error) {
+        operation.error = error.message;
+        results.failed.push(operation);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Rollback a single operation
+   */
+  async rollbackOperation(operation) {
+    if (operation.rollbackExecuted) {
+      throw new Error(`Operation already rolled back: ${operation.id}`);
+    }
+
+    switch (operation.type) {
+      case ROLLBACK_TYPES.FILE_UPDATE:
+        await this.rollbackFileUpdate(operation);
+        break;
+      case ROLLBACK_TYPES.FILE_CREATE:
+        await this.rollbackFileCreate(operation);
+        break;
+      case ROLLBACK_TYPES.FILE_DELETE:
+        await this.rollbackFileDelete(operation);
+        break;
+      case ROLLBACK_TYPES.FILE_MOVE:
+        await this.rollbackFileMove(operation);
+        break;
+      case ROLLBACK_TYPES.DIRECTORY_CREATE:
+        await this.rollbackDirectoryCreate(operation);
+        break;
+      case ROLLBACK_TYPES.DIRECTORY_DELETE:
+        await this.rollbackDirectoryDelete(operation);
+        break;
+      default:
+        throw new Error(`Unknown rollback operation type: ${operation.type}`);
+    }
+
+    operation.rollback();
+  }
+
+  /**
+   * Rollback file update
+   */
+  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
+   */
+  async rollbackFileCreate(operation) {
+    if (fs.existsSync(operation.targetPath)) {
+      fs.unlinkSync(operation.targetPath);
+    }
+  }
+
+  /**
+   * Rollback file deletion
+   */
+  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
+   */
+  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
+   */
+  async rollbackDirectoryCreate(operation) {
+    if (fs.existsSync(operation.targetPath)) {
+      fs.rmSync(operation.targetPath, { recursive: true, force: true });
+    }
+  }
+
+  /**
+   * Rollback directory deletion
+   */
+  async rollbackDirectoryDelete(operation) {
+    if (!operation.backupPath || !fs.existsSync(operation.backupPath)) {
+      throw new Error(`Backup not found for directory deletion: ${operation.targetPath}`);
+    }
+
+    // Restore deleted directory
+    this.copyDirectory(operation.backupPath, operation.targetPath);
+  }
+
+  /**
+   * Get backup path for a file
+   */
+  getBackupPath(filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    const backupPath = path.join(this.getSessionBackupDir(), relativePath);
+    return backupPath;
+  }
+
+  /**
+   * Copy directory recursively
+   */
+  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()) {
+        this.copyDirectory(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+
+  /**
+   * Get operation summary
+   */
+  getSummary() {
+    const summary = {
+      sessionId: this.sessionId,
+      totalOperations: this.operations.length,
+      executedOperations: this.operations.filter(op => op.executed).length,
+      rollbackOperations: this.operations.filter(op => op.rollbackExecuted).length,
+      byType: {},
+      backupDirectory: this.getSessionBackupDir()
+    };
+
+    // Count operations by type
+    for (const operation of this.operations) {
+      if (!summary.byType[operation.type]) {
+        summary.byType[operation.type] = 0;
+      }
+      summary.byType[operation.type]++;
+    }
+
+    return summary;
+  }
+
+  /**
+   * Save rollback state to file
+   */
+  saveState() {
+    const stateFile = path.join(this.getSessionBackupDir(), 'rollback-state.json');
+    const state = {
+      sessionId: this.sessionId,
+      operations: this.operations,
+      summary: this.getSummary(),
+      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'));
+    this.sessionId = state.sessionId;
+    this.operations = state.operations.map(op => Object.assign(new RollbackOperation(), op));
+
+    return state;
+  }
+
+  /**
+   * 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 = 7 * 24 * 60 * 60 * 1000) { // 7 days default
+    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;
+  }
+
+  /**
+   * Clear current session operations
+   */
+  clear() {
+    this.operations = [];
+  }
+
+  /**
+   * Get backup size
+   */
+  getBackupSize() {
+    const sessionDir = this.getSessionBackupDir();
+    if (!fs.existsSync(sessionDir)) {
+      return 0;
+    }
+
+    return this.getDirectorySize(sessionDir);
+  }
+
+  /**
+   * Get directory size recursively
+   */
+  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 += this.getDirectorySize(fullPath);
+        } else {
+          totalSize += fs.statSync(fullPath).size;
+        }
+      }
+    } catch (error) {
+      // Directory might not exist or be inaccessible
+    }
+
+    return totalSize;
+  }
+}
+
+module.exports = {
+  RollbackManager,
+  RollbackOperation,
+  ROLLBACK_TYPES
+};
+// Updated for 800 line limit test