revert-ai 1.1.1

package/src/core/Operation.js

@@ -0,0 +1,39 @@
+import crypto from 'crypto';
+
+export class Operation {
+  constructor(type, data) {
+    this.id = (crypto.randomUUID ? crypto.randomUUID() : `${Date.now()}-${Math.floor(Math.random()*1e9)}`);
+    this.timestamp = new Date();
+    this.type = type;
+    this.data = data;
+    this.undone = false;
+  }
+
+  static fromJSON(json) {
+    const op = new Operation(json.type, json.data);
+    op.id = json.id;
+    op.timestamp = new Date(json.timestamp);
+    op.undone = json.undone || false;
+    return op;
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      timestamp: this.timestamp.toISOString(),
+      type: this.type,
+      data: this.data,
+      undone: this.undone
+    };
+  }
+}
+
+export const OperationType = {
+  FILE_CREATE: 'file_create',
+  FILE_EDIT: 'file_edit',
+  FILE_DELETE: 'file_delete',
+  FILE_RENAME: 'file_rename',
+  DIRECTORY_CREATE: 'directory_create',
+  DIRECTORY_DELETE: 'directory_delete',
+  BASH_COMMAND: 'bash_command'
+};

package/src/core/OperationPreview.js

@@ -0,0 +1,176 @@
+import fs from 'fs/promises';
+import chalk from 'chalk';
+import { OperationType } from './Operation.js';
+import { i18n } from '../i18n/i18n.js';
+import { renderSideBySide } from '../utils/diffRenderer.js';
+
+export class OperationPreview {
+  static async generatePreview(operation) {
+    switch (operation.type) {
+      case OperationType.FILE_CREATE:
+        return await this.previewFileCreate(operation);
+      case OperationType.FILE_EDIT:
+        return await this.previewFileEdit(operation);
+      case OperationType.FILE_DELETE:
+        return await this.previewFileDelete(operation);
+      case OperationType.FILE_RENAME:
+        return await this.previewFileRename(operation);
+      case OperationType.DIRECTORY_CREATE:
+        return await this.previewDirectoryCreate(operation);
+      case OperationType.DIRECTORY_DELETE:
+        return await this.previewDirectoryDelete(operation);
+      case OperationType.BASH_COMMAND:
+        return await this.previewBashCommand(operation);
+      default:
+        return { preview: `Unknown operation: ${operation.type}`, hasContent: false };
+    }
+  }
+
+  static async previewFileCreate(operation) {
+    const { filePath } = operation.data;
+    
+    try {
+      const exists = await fs.access(filePath).then(() => true).catch(() => false);
+      if (!exists) {
+        return {
+          preview: `${chalk.red('File does not exist:')} ${filePath}`,
+          hasContent: false
+        };
+      }
+
+      const content = await fs.readFile(filePath, 'utf8');
+      const lines = content.split('\n');
+      const preview = lines.slice(0, 5).join('\n');
+      const truncated = lines.length > 5;
+      
+      return {
+        preview: `${chalk.red(i18n.t('action.will_delete_file'))} ${filePath}\n${chalk.gray(i18n.t('status.current_content'))}\n${preview}${truncated ? '\n...' : ''}`,
+        hasContent: true,
+        action: 'delete'
+      };
+    } catch (error) {
+      return {
+        preview: `${chalk.red('Error reading file:')} ${filePath} - ${error.message}`,
+        hasContent: false
+      };
+    }
+  }
+
+  static async previewFileEdit(operation) {
+    const { filePath, originalContent, oldString, newString, replaceAll, edits, isMultiEdit } = operation.data;
+    
+    try {
+      const currentContent = await fs.readFile(filePath, 'utf8');
+      let preview = `${chalk.yellow(i18n.t('action.will_revert_file'))} ${filePath}\n\n`;
+      
+      let revertedContent = currentContent;
+      
+      if (originalContent) {
+        revertedContent = originalContent;
+      } else if (isMultiEdit && edits) {
+        for (let i = edits.length - 1; i >= 0; i--) {
+          const edit = edits[i];
+          if (edit.new_string && edit.old_string !== undefined) {
+            if (revertedContent.includes(edit.new_string)) {
+              revertedContent = revertedContent.replace(edit.new_string, edit.old_string);
+            }
+          }
+        }
+      } else if (oldString !== undefined && newString) {
+        if (replaceAll) {
+          revertedContent = revertedContent.split(newString).join(oldString);
+        } else {
+          if (revertedContent.includes(newString)) {
+            revertedContent = revertedContent.replace(newString, oldString);
+          }
+        }
+      }
+      
+      preview += renderSideBySide(currentContent, revertedContent, { maxLines: 15 });
+      
+      return {
+        preview,
+        hasContent: true,
+        action: 'revert'
+      };
+    } catch (error) {
+      return {
+        preview: `${chalk.yellow(i18n.t('action.will_revert_file'))} ${filePath}\n${chalk.red('Error:')} ${error.message}`,
+        hasContent: false,
+        action: 'revert'
+      };
+    }
+  }
+
+  static async previewFileDelete(operation) {
+    const { filePath, content } = operation.data;
+    
+    if (!content) {
+      return {
+        preview: `${chalk.green(i18n.t('action.will_restore_file'))} ${filePath}\n${chalk.gray(i18n.t('status.content_not_available'))}`,
+        hasContent: false
+      };
+    }
+
+    const lines = content.split('\n');
+    const preview = lines.slice(0, 5).join('\n');
+    const truncated = lines.length > 5;
+    
+    return {
+      preview: `${chalk.green(i18n.t('action.will_restore_file'))} ${filePath}\n${chalk.gray(i18n.t('status.content_to_restore'))}\n${preview}${truncated ? '\n...' : ''}`,
+      hasContent: true,
+      action: 'restore'
+    };
+  }
+
+  static async previewFileRename(operation) {
+    const { oldPath, newPath } = operation.data;
+    
+    return {
+      preview: `${chalk.yellow(i18n.t('action.will_rename_back'))} ${newPath} → ${oldPath}`,
+      hasContent: false,
+      action: 'rename'
+    };
+  }
+
+  static async previewDirectoryCreate(operation) {
+    const { dirPath } = operation.data;
+    
+    try {
+      const exists = await fs.access(dirPath).then(() => true).catch(() => false);
+      const status = exists ? chalk.red('Will remove directory:') : chalk.gray('Directory already removed:');
+      
+      return {
+        preview: `${status} ${dirPath}`,
+        hasContent: false,
+        action: exists ? 'remove' : 'none'
+      };
+    } catch (error) {
+      return {
+        preview: `${chalk.yellow('Will remove directory:')} ${dirPath}`,
+        hasContent: false,
+        action: 'remove'
+      };
+    }
+  }
+
+  static async previewDirectoryDelete(operation) {
+    const { dirPath } = operation.data;
+    
+    return {
+      preview: `${chalk.green('Will restore directory:')} ${dirPath}`,
+      hasContent: false,
+      action: 'restore'
+    };
+  }
+
+  static async previewBashCommand(operation) {
+    const { command } = operation.data;
+    
+    return {
+      preview: `${chalk.red(i18n.t('action.cannot_undo_bash'))} ${command}\n${chalk.gray(i18n.t('action.manual_intervention'))}`,
+      hasContent: false,
+      action: 'manual'
+    };
+  }
+}

package/src/core/RedoManager.js

@@ -0,0 +1,270 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { OperationType } from './Operation.js';
+
+export class RedoManager {
+  constructor() {
+    this.backupDir = path.join(os.homedir(), '.revert-ai', 'backups');
+  }
+
+  async init() {
+    await fs.mkdir(this.backupDir, { recursive: true });
+  }
+
+  async redo(operation) {
+    switch (operation.type) {
+      case OperationType.FILE_CREATE:
+        return await this.redoFileCreate(operation);
+      case OperationType.FILE_EDIT:
+        return await this.redoFileEdit(operation);
+      case OperationType.FILE_DELETE:
+        return await this.redoFileDelete(operation);
+      case OperationType.FILE_RENAME:
+        return await this.redoFileRename(operation);
+      case OperationType.DIRECTORY_CREATE:
+        return await this.redoDirectoryCreate(operation);
+      case OperationType.DIRECTORY_DELETE:
+        return await this.redoDirectoryDelete(operation);
+      case OperationType.BASH_COMMAND:
+        return await this.redoBashCommand(operation);
+      default:
+        throw new Error(`Unknown operation type: ${operation.type}`);
+    }
+  }
+
+  async redoFileCreate(operation) {
+    const { filePath, content } = operation.data;
+    
+    try {
+      // Check if file already exists
+      const exists = await fs.access(filePath).then(() => true).catch(() => false);
+      if (exists) {
+        return {
+          success: false,
+          message: `Cannot redo file creation: ${filePath} already exists`
+        };
+      }
+
+      // Try to restore from backup first
+      const backupPath = path.join(this.backupDir, `${operation.id}-deleted`);
+      let fileContent = content || '';
+      
+      try {
+        fileContent = await fs.readFile(backupPath, 'utf8');
+      } catch (e) {
+        // If no backup, use original content if available
+        if (!content) {
+          return {
+            success: false,
+            message: `Cannot redo file creation: no content available for ${filePath}`
+          };
+        }
+      }
+
+      await fs.writeFile(filePath, fileContent);
+      
+      return {
+        success: true,
+        message: `File recreated: ${filePath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to redo file creation: ${error.message}`
+      };
+    }
+  }
+
+  async redoFileEdit(operation) {
+    const { filePath, originalContent, oldString, newString, replaceAll, edits, isMultiEdit } = operation.data;
+    
+    try {
+      const currentContent = await fs.readFile(filePath, 'utf8');
+      const backupPath = path.join(this.backupDir, `${operation.id}-redo`);
+      await fs.writeFile(backupPath, currentContent);
+      
+      let redoneContent = currentContent;
+      
+      if (originalContent) {
+        // This was a legacy full-content edit, but we can't safely redo it
+        // because we don't know what the "new" content should be
+        return {
+          success: false,
+          message: `Cannot redo legacy file edit: insufficient data for ${filePath}`
+        };
+      } else if (isMultiEdit && edits) {
+        // Redo MultiEdit by applying each edit in original order
+        for (const edit of edits) {
+          if (edit.old_string !== undefined && edit.new_string) {
+            if (redoneContent.includes(edit.old_string)) {
+              redoneContent = redoneContent.replace(edit.old_string, edit.new_string);
+            }
+          }
+        }
+      } else if (oldString !== undefined && newString) {
+        // Redo single Edit operation - apply the original string replacement
+        if (replaceAll) {
+          // Replace all occurrences
+          redoneContent = redoneContent.split(oldString).join(newString);
+        } else {
+          // Replace first occurrence only
+          if (redoneContent.includes(oldString)) {
+            redoneContent = redoneContent.replace(oldString, newString);
+          } else {
+            return {
+              success: false,
+              message: `Cannot redo edit: original string not found in ${filePath}`
+            };
+          }
+        }
+      } else {
+        return {
+          success: false,
+          message: `Cannot redo file edit: insufficient data for ${filePath}`
+        };
+      }
+      
+      await fs.writeFile(filePath, redoneContent);
+      
+      return {
+        success: true,
+        message: `File edit redone: ${filePath}`,
+        backupPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to redo file edit: ${error.message}`
+      };
+    }
+  }
+
+  async redoFileDelete(operation) {
+    const { filePath } = operation.data;
+    
+    try {
+      const exists = await fs.access(filePath).then(() => true).catch(() => false);
+      if (!exists) {
+        return {
+          success: false,
+          message: `Cannot redo file deletion: ${filePath} does not exist`
+        };
+      }
+
+      // Backup the file before deleting
+      const backupPath = path.join(this.backupDir, `${operation.id}-redo-deleted`);
+      const content = await fs.readFile(filePath, 'utf8');
+      await fs.writeFile(backupPath, content);
+      
+      await fs.unlink(filePath);
+      
+      return {
+        success: true,
+        message: `File deleted again: ${filePath}`,
+        backupPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to redo file deletion: ${error.message}`
+      };
+    }
+  }
+
+  async redoFileRename(operation) {
+    const { oldPath, newPath } = operation.data;
+    
+    try {
+      const oldExists = await fs.access(oldPath).then(() => true).catch(() => false);
+      const newExists = await fs.access(newPath).then(() => true).catch(() => false);
+      
+      if (!oldExists) {
+        return {
+          success: false,
+          message: `Cannot redo rename: ${oldPath} does not exist`
+        };
+      }
+      
+      if (newExists) {
+        return {
+          success: false,
+          message: `Cannot redo rename: ${newPath} already exists`
+        };
+      }
+
+      await fs.rename(oldPath, newPath);
+      
+      return {
+        success: true,
+        message: `File renamed again: ${oldPath} → ${newPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to redo rename: ${error.message}`
+      };
+    }
+  }
+
+  async redoDirectoryCreate(operation) {
+    const { dirPath } = operation.data;
+    
+    try {
+      const exists = await fs.access(dirPath).then(() => true).catch(() => false);
+      if (exists) {
+        return {
+          success: false,
+          message: `Cannot redo directory creation: ${dirPath} already exists`
+        };
+      }
+
+      await fs.mkdir(dirPath, { recursive: true });
+      
+      return {
+        success: true,
+        message: `Directory created again: ${dirPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to redo directory creation: ${error.message}`
+      };
+    }
+  }
+
+  async redoDirectoryDelete(operation) {
+    const { dirPath } = operation.data;
+    
+    try {
+      const exists = await fs.access(dirPath).then(() => true).catch(() => false);
+      if (!exists) {
+        return {
+          success: false,
+          message: `Cannot redo directory deletion: ${dirPath} does not exist`
+        };
+      }
+
+      await fs.rmdir(dirPath);
+      
+      return {
+        success: true,
+        message: `Directory deleted again: ${dirPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to redo directory deletion: ${error.message}`
+      };
+    }
+  }
+
+  async redoBashCommand(operation) {
+    const { command } = operation.data;
+    
+    return {
+      success: false,
+      message: `Cannot redo bash command: ${command}\nPlease manually re-run the command.`
+    };
+  }
+}

package/src/core/SessionTracker.js

@@ -0,0 +1,98 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { Operation, OperationType } from './Operation.js';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export class SessionTracker {
+  constructor(sessionId = null) {
+    this.sessionId = sessionId || new Date().toISOString().replace(/[:.]/g, '-');
+    this.operations = [];
+    this.sessionDir = path.join(os.homedir(), '.revert-ai', 'sessions');
+    this.sessionFile = path.join(this.sessionDir, `${this.sessionId}.json`);
+  }
+
+  async init() {
+    await fs.mkdir(this.sessionDir, { recursive: true });
+    await this.load();
+  }
+
+  async load() {
+    try {
+      const data = await fs.readFile(this.sessionFile, 'utf8');
+      const session = JSON.parse(data);
+      this.operations = session.operations.map(op => Operation.fromJSON(op));
+    } catch (error) {
+      if (error.code !== 'ENOENT') {
+        throw error;
+      }
+    }
+  }
+
+  async save() {
+    const sessionData = {
+      sessionId: this.sessionId,
+      operations: this.operations.map(op => op.toJSON())
+    };
+    await fs.writeFile(this.sessionFile, JSON.stringify(sessionData, null, 2));
+  }
+
+  async addOperation(operation) {
+    this.operations.push(operation);
+    await this.save();
+  }
+
+  async getOperations(includeUndone = false) {
+    return includeUndone 
+      ? this.operations 
+      : this.operations.filter(op => !op.undone);
+  }
+
+  async getOperation(id) {
+    return this.operations.find(op => op.id === id);
+  }
+
+  async markUndone(operationId) {
+    const operation = await this.getOperation(operationId);
+    if (operation) {
+      operation.undone = true;
+      await this.save();
+    }
+    return operation;
+  }
+
+  static async listSessions() {
+    const sessionDir = path.join(os.homedir(), '.revert-ai', 'sessions');
+    try {
+      const files = await fs.readdir(sessionDir);
+      return files
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace('.json', ''));
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [];
+      }
+      throw error;
+    }
+  }
+
+  static async getCurrentSession() {
+    const currentFile = path.join(os.homedir(), '.revert-ai', 'current-session');
+    try {
+      const sessionId = await fs.readFile(currentFile, 'utf8');
+      return sessionId.trim();
+    } catch (error) {
+      return null;
+    }
+  }
+
+  static async setCurrentSession(sessionId) {
+    const currentFile = path.join(os.homedir(), '.revert-ai', 'current-session');
+    await fs.mkdir(path.dirname(currentFile), { recursive: true });
+    await fs.writeFile(currentFile, sessionId);
+  }
+}