revert-ai 1.1.1

package/src/core/UndoManager.js

@@ -0,0 +1,207 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { OperationType } from './Operation.js';
+
+export class UndoManager {
+  constructor() {
+    this.backupDir = path.join(os.homedir(), '.revert-ai', 'backups');
+  }
+
+  async init() {
+    await fs.mkdir(this.backupDir, { recursive: true });
+  }
+
+  async undo(operation) {
+    switch (operation.type) {
+      case OperationType.FILE_CREATE:
+        return await this.undoFileCreate(operation);
+      case OperationType.FILE_EDIT:
+        return await this.undoFileEdit(operation);
+      case OperationType.FILE_DELETE:
+        return await this.undoFileDelete(operation);
+      case OperationType.FILE_RENAME:
+        return await this.undoFileRename(operation);
+      case OperationType.DIRECTORY_CREATE:
+        return await this.undoDirectoryCreate(operation);
+      case OperationType.DIRECTORY_DELETE:
+        return await this.undoDirectoryDelete(operation);
+      case OperationType.BASH_COMMAND:
+        return await this.undoBashCommand(operation);
+      default:
+        throw new Error(`Unknown operation type: ${operation.type}`);
+    }
+  }
+
+  async undoFileCreate(operation) {
+    const { filePath } = operation.data;
+    const backupPath = path.join(this.backupDir, `${operation.id}-deleted`);
+    
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      await fs.writeFile(backupPath, content);
+      await fs.unlink(filePath);
+      
+      return {
+        success: true,
+        message: `File deleted: ${filePath}`,
+        backupPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to undo file creation: ${error.message}`
+      };
+    }
+  }
+
+  async undoFileEdit(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}-current`);
+      await fs.writeFile(backupPath, currentContent);
+      
+      let revertedContent = currentContent;
+      
+      if (originalContent) {
+        // Legacy mode: we have the full original content (from local tracking)
+        revertedContent = originalContent;
+      } else if (isMultiEdit && edits) {
+        // Handle MultiEdit by reversing each edit in reverse order
+        for (let i = edits.length - 1; i >= 0; i--) {
+          const edit = edits[i];
+          if (edit.new_string && edit.old_string !== undefined) {
+            // Try to replace new_string back with old_string
+            if (revertedContent.includes(edit.new_string)) {
+              revertedContent = revertedContent.replace(edit.new_string, edit.old_string);
+            }
+          }
+        }
+      } else if (oldString !== undefined && newString) {
+        // Handle single Edit operation - reverse the string replacement
+        if (replaceAll) {
+          // Replace all occurrences
+          revertedContent = revertedContent.split(newString).join(oldString);
+        } else {
+          // Replace first occurrence only
+          if (revertedContent.includes(newString)) {
+            revertedContent = revertedContent.replace(newString, oldString);
+          } else {
+            return {
+              success: false,
+              message: `Cannot undo edit: expected string not found in ${filePath}`
+            };
+          }
+        }
+      } else {
+        return {
+          success: false,
+          message: `Cannot undo file edit: insufficient data for ${filePath}`
+        };
+      }
+      
+      await fs.writeFile(filePath, revertedContent);
+      
+      return {
+        success: true,
+        message: `File edit reverted: ${filePath}`,
+        backupPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to undo file edit: ${error.message}`
+      };
+    }
+  }
+
+  async undoFileDelete(operation) {
+    const { filePath, content } = operation.data;
+    
+    if (!content) {
+      return {
+        success: false,
+        message: `Cannot restore file: content not available for ${filePath}`
+      };
+    }
+    
+    try {
+      await fs.writeFile(filePath, content);
+      
+      return {
+        success: true,
+        message: `File restored: ${filePath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to restore file: ${error.message}`
+      };
+    }
+  }
+
+  async undoFileRename(operation) {
+    const { oldPath, newPath } = operation.data;
+    
+    try {
+      await fs.rename(newPath, oldPath);
+      
+      return {
+        success: true,
+        message: `File renamed back: ${newPath} → ${oldPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to undo rename: ${error.message}`
+      };
+    }
+  }
+
+  async undoDirectoryCreate(operation) {
+    const { dirPath } = operation.data;
+    
+    try {
+      await fs.rmdir(dirPath);
+      
+      return {
+        success: true,
+        message: `Directory removed: ${dirPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to remove directory: ${error.message}`
+      };
+    }
+  }
+
+  async undoDirectoryDelete(operation) {
+    const { dirPath } = operation.data;
+    
+    try {
+      await fs.mkdir(dirPath, { recursive: true });
+      
+      return {
+        success: true,
+        message: `Directory restored: ${dirPath}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        message: `Failed to restore directory: ${error.message}`
+      };
+    }
+  }
+
+  async undoBashCommand(operation) {
+    const { command } = operation.data;
+    
+    return {
+      success: false,
+      message: `Cannot auto-undo bash command: ${command}\nPlease manually revert any changes.`
+    };
+  }
+}

package/src/core/UndoTracker.js

@@ -0,0 +1,72 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+export class UndoTracker {
+  constructor() {
+    this.undoFile = path.join(os.homedir(), '.revert-ai', 'undone-operations.json');
+  }
+
+  async init() {
+    await fs.mkdir(path.dirname(this.undoFile), { recursive: true });
+  }
+
+  async getUndoneOperations() {
+    try {
+      const data = await fs.readFile(this.undoFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return {};
+      }
+      throw error;
+    }
+  }
+
+  async markAsUndone(operationId, sessionFile) {
+    const undoneOps = await this.getUndoneOperations();
+    
+    if (!undoneOps[sessionFile]) {
+      undoneOps[sessionFile] = [];
+    }
+    
+    if (!undoneOps[sessionFile].includes(operationId)) {
+      undoneOps[sessionFile].push(operationId);
+      await fs.writeFile(this.undoFile, JSON.stringify(undoneOps, null, 2));
+    }
+  }
+
+  async markAsRedone(operationId, sessionFile) {
+    const undoneOps = await this.getUndoneOperations();
+    
+    if (undoneOps[sessionFile]) {
+      const index = undoneOps[sessionFile].indexOf(operationId);
+      if (index > -1) {
+        undoneOps[sessionFile].splice(index, 1);
+        await fs.writeFile(this.undoFile, JSON.stringify(undoneOps, null, 2));
+      }
+    }
+  }
+
+  async isUndone(operationId, sessionFile) {
+    const undoneOps = await this.getUndoneOperations();
+    return undoneOps[sessionFile]?.includes(operationId) || false;
+  }
+
+  async filterUndoneOperations(operations, sessionFile) {
+    const undoneOps = await this.getUndoneOperations();
+    const undoneIds = undoneOps[sessionFile] || [];
+    
+    return operations.filter(op => !undoneIds.includes(op.id));
+  }
+
+  async getUndoneOperationsList(operations, sessionFile) {
+    const undoneOps = await this.getUndoneOperations();
+    const undoneIds = undoneOps[sessionFile] || [];
+    
+    // Return operations that have been undone, in reverse order (most recent first)
+    return operations
+      .filter(op => undoneIds.includes(op.id))
+      .reverse();
+  }
+}

package/src/hooks/claude-tracker.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises';
+import { SessionTracker } from '../core/SessionTracker.js';
+import { Operation, OperationType } from '../core/Operation.js';
+
+async function trackOperation() {
+  try {
+    const input = JSON.parse(process.argv[2] || '{}');
+    
+    let sessionId = await SessionTracker.getCurrentSession();
+    if (!sessionId) {
+      sessionId = new Date().toISOString().replace(/[:.]/g, '-');
+      await SessionTracker.setCurrentSession(sessionId);
+    }
+    
+    const tracker = new SessionTracker(sessionId);
+    await tracker.init();
+    
+    let operation = null;
+    
+    if (input.tool === 'Write' && input.parameters?.file_path) {
+      operation = new Operation(OperationType.FILE_CREATE, {
+        filePath: input.parameters.file_path,
+        content: input.parameters.content || ''
+      });
+    } else if (input.tool === 'Edit' && input.parameters?.file_path) {
+      let originalContent = '';
+      try {
+        originalContent = await fs.readFile(input.parameters.file_path, 'utf8');
+      } catch (e) {}
+      
+      operation = new Operation(OperationType.FILE_EDIT, {
+        filePath: input.parameters.file_path,
+        originalContent,
+        newContent: input.parameters.new_string || ''
+      });
+    } else if (input.tool === 'Bash' && input.parameters?.command) {
+      const command = input.parameters.command;
+      
+      if (command.includes('rm ') && command.includes('-f')) {
+        const match = command.match(/rm\s+.*?\s+([^\s]+)$/);
+        if (match) {
+          const filePath = match[1];
+          let content = '';
+          try {
+            content = await fs.readFile(filePath, 'utf8');
+          } catch (e) {}
+          
+          operation = new Operation(OperationType.FILE_DELETE, {
+            filePath,
+            content
+          });
+        }
+      } else if (command.includes('mv ')) {
+        const match = command.match(/mv\s+([^\s]+)\s+([^\s]+)$/);
+        if (match) {
+          operation = new Operation(OperationType.FILE_RENAME, {
+            oldPath: match[1],
+            newPath: match[2]
+          });
+        }
+      } else if (command.includes('mkdir')) {
+        const match = command.match(/mkdir\s+.*?\s+([^\s]+)$/);
+        if (match) {
+          operation = new Operation(OperationType.DIRECTORY_CREATE, {
+            dirPath: match[1]
+          });
+        }
+      } else if (command.includes('rmdir') || (command.includes('rm') && command.includes('-r'))) {
+        const match = command.match(/rm(?:dir)?\s+.*?\s+([^\s]+)$/);
+        if (match) {
+          operation = new Operation(OperationType.DIRECTORY_DELETE, {
+            dirPath: match[1]
+          });
+        }
+      } else {
+        operation = new Operation(OperationType.BASH_COMMAND, {
+          command
+        });
+      }
+    }
+    
+    if (operation) {
+      await tracker.addOperation(operation);
+    }
+  } catch (error) {
+    console.error('Failed to track operation:', error.message);
+  }
+}
+
+trackOperation();

package/src/i18n/i18n.js

@@ -0,0 +1,72 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { languages } from './languages.js';
+
+class I18n {
+  constructor() {
+    this.currentLanguage = 'en';
+    this.configFile = path.join(os.homedir(), '.revert-ai', 'config.json');
+  }
+
+  async init() {
+    await this.loadConfig();
+  }
+
+  async loadConfig() {
+    try {
+      const config = JSON.parse(await fs.readFile(this.configFile, 'utf8'));
+      this.currentLanguage = config.language || 'en';
+    } catch (error) {
+      // Use default language if config doesn't exist
+      this.currentLanguage = 'en';
+    }
+  }
+
+  async saveConfig() {
+    try {
+      await fs.mkdir(path.dirname(this.configFile), { recursive: true });
+      const config = { language: this.currentLanguage };
+      await fs.writeFile(this.configFile, JSON.stringify(config, null, 2));
+    } catch (error) {
+      console.error('Failed to save language config:', error.message);
+    }
+  }
+
+  async setLanguage(lang) {
+    if (!languages[lang]) {
+      throw new Error(`Unsupported language: ${lang}`);
+    }
+    this.currentLanguage = lang;
+    await this.saveConfig();
+  }
+
+  t(key, params = {}) {
+    const lang = languages[this.currentLanguage] || languages['en'];
+    let message = lang.messages[key] || key;
+    
+    // Replace parameters in the message
+    Object.keys(params).forEach(param => {
+      message = message.replace(new RegExp(`\\{${param}\\}`, 'g'), params[param]);
+    });
+    
+    return message;
+  }
+
+  getAvailableLanguages() {
+    return Object.keys(languages).map(code => ({
+      code,
+      name: languages[code].name
+    }));
+  }
+
+  getCurrentLanguage() {
+    return {
+      code: this.currentLanguage,
+      name: languages[this.currentLanguage]?.name || 'Unknown'
+    };
+  }
+}
+
+// Create a singleton instance
+export const i18n = new I18n();