revert-ai 1.1.1

package/bin/revert-ai.js

@@ -0,0 +1,589 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { SessionTracker } from '../src/core/SessionTracker.js';
+import { UndoManager } from '../src/core/UndoManager.js';
+import { formatDistance } from '../src/utils/formatting.js';
+import { Operation, OperationType } from '../src/core/Operation.js';
+import { AgentDetector } from '../src/core/AgentDetector.js';
+import { OperationPreview } from '../src/core/OperationPreview.js';
+import { i18n } from '../src/i18n/i18n.js';
+import { UndoTracker } from '../src/core/UndoTracker.js';
+import { RedoManager } from '../src/core/RedoManager.js';
+import { GitHelper } from '../src/utils/gitHelper.js';
+import { getDependentOperations } from '../src/core/DependencyCascading.js';
+import path from 'path';
+
+// Initialize i18n
+await i18n.init();
+
+const program = new Command();
+
+program
+  .name('revert-ai')
+  .description('Undo individual steps performed by Claude Code within a session')
+  .version('1.1.1');
+
+program
+  .command('list')
+  .description(i18n.t('cmd.list.description'))
+  .option('-a, --all', i18n.t('opt.all'))
+  .option('-s, --session <id>', i18n.t('opt.session'))
+  .option('--claude', i18n.t('opt.claude'), true)
+  .option('--local', i18n.t('opt.local'))
+  .action(async (options) => {
+    try {
+      let operations = [];
+      
+      if (!options.local) {
+        const detection = await AgentDetector.detect();
+        if (!detection) {
+          console.log(chalk.yellow('No active AI agent session (Claude Code or Aider) found in this directory.'));
+          return;
+        }
+        
+        const { agent, parser } = detection;
+        const sessionFile = await parser.getCurrentSessionFile();
+        operations = await parser.parseSessionFile(sessionFile, options.all);
+        console.log(chalk.bold(`\nOperations from ${agent === 'claude' ? 'Claude Code' : 'Aider'} session:\n`));
+      } else {
+        // Use local revert-ai tracking
+        const sessionId = options.session || await SessionTracker.getCurrentSession();
+        if (!sessionId) {
+          console.log(chalk.yellow('No local revert-ai session found.'));
+          return;
+        }
+
+        const tracker = new SessionTracker(sessionId);
+        await tracker.init();
+        operations = await tracker.getOperations(options.all);
+        console.log(chalk.bold(`\nOperations in local session ${sessionId}:\n`));
+      }
+      
+      if (operations.length === 0) {
+        console.log(chalk.yellow('No operations found.'));
+        return;
+      }
+
+      operations.forEach((op, index) => {
+        const status = op.undone ? chalk.red('[UNDONE]') : chalk.green('[ACTIVE]');
+        const time = formatDistance(op.timestamp);
+        
+        console.log(`${index + 1}. ${status} ${chalk.cyan(op.type)} - ${time}`);
+        console.log(`   ID: ${op.id}`);
+        
+        switch (op.type) {
+          case 'file_create':
+          case 'file_edit':
+          case 'file_delete':
+            console.log(`   File: ${op.data.filePath}`);
+            break;
+          case 'file_rename':
+            console.log(`   From: ${op.data.oldPath}`);
+            console.log(`   To: ${op.data.newPath}`);
+            break;
+          case 'directory_create':
+          case 'directory_delete':
+            console.log(`   Directory: ${op.data.dirPath}`);
+            break;
+          case 'bash_command':
+            console.log(`   Command: ${op.data.command}`);
+            break;
+        }
+        console.log('');
+      });
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('undo [operation-id]')
+  .description('Undo operations from the current Claude Code session')
+  .option('-s, --session <id>', 'Specify session ID')
+  .option('-y, --yes', 'Skip confirmation')
+  .option('--local', 'Use local revert-ai tracking instead of Claude sessions')
+  .action(async (operationId, options) => {
+    try {
+      let operations = [];
+      let sessionFile = null;
+      
+      if (options.local) {
+        // Use local revert-ai tracking
+        const sessionId = options.session || await SessionTracker.getCurrentSession();
+        if (!sessionId) {
+          console.log(chalk.yellow('No local revert-ai session found.'));
+          return;
+        }
+
+        const tracker = new SessionTracker(sessionId);
+        await tracker.init();
+        operations = await tracker.getOperations();
+      } else {
+        const detection = await AgentDetector.detect();
+        if (!detection) {
+          console.log(chalk.yellow('No active AI agent session found in this directory.'));
+          return;
+        }
+        const { parser } = detection;
+        sessionFile = await parser.getCurrentSessionFile();
+        operations = await parser.parseSessionFile(sessionFile);
+      }
+      
+      if (operations.length === 0) {
+        console.log(chalk.yellow('No operations to undo.'));
+        return;
+      }
+
+      // Reverse operations so most recent is first
+      operations.reverse();
+      
+      let selectedIndex = 0;
+      
+      if (!operationId) {
+        const choices = operations.map((op, index) => {
+          const dependentOps = getDependentOperations(index, operations, process.cwd());
+          let name = `${op.type} - ${formatDistance(op.timestamp)}`;
+          
+          if (dependentOps.length > 1) {
+            name += chalk.red(` (+ ${dependentOps.length - 1} dependent ops will be undone)`);
+          }
+          
+          return {
+            name: name,
+            value: index,
+            short: `${op.type} (${dependentOps.length} ops)`
+          };
+        });
+        
+        console.log(chalk.yellow('\n⚠️  AST Cascading undo: Selecting an operation will undo it and only other subsequent operations that depend on it.\n'));
+        
+        const answer = await inquirer.prompt([{
+          type: 'list',
+          name: 'selectedIndex',
+          message: 'Select operation to undo:',
+          choices: choices,
+          pageSize: 15
+        }]);
+        
+        selectedIndex = answer.selectedIndex;
+      } else {
+        selectedIndex = operations.findIndex(op => op.id === operationId);
+        if (selectedIndex === -1) {
+          console.log(chalk.red(`Operation ${operationId} not found.`));
+          return;
+        }
+      }
+      
+      const operationsToUndo = getDependentOperations(selectedIndex, operations, process.cwd());
+      
+      if (!options.yes) {
+        console.log(chalk.yellow(`\\nThis will undo ${operationsToUndo.length} operation(s):\\n`));
+        
+        for (let i = 0; i < operationsToUndo.length; i++) {
+          const op = operationsToUndo[i];
+          console.log(`${chalk.bold(`${i + 1}.`)} ${chalk.cyan(op.type)} - ${formatDistance(op.timestamp)}`);
+          
+          const preview = await OperationPreview.generatePreview(op);
+          console.log(`   ${preview.preview.replace(/\\n/g, '\\n   ')}`);
+          console.log('');
+        }
+        
+        const confirm = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'proceed',
+          message: `Are you sure you want to undo these ${operationsToUndo.length} operations?`,
+          default: false
+        }]);
+        
+        if (!confirm.proceed) {
+          console.log(chalk.yellow('Undo cancelled.'));
+          return;
+        }
+      if (GitHelper.isWorkspaceDirty()) {
+        const gitAnswer = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'stash',
+          message: '⚠️  You have uncommitted changes in your repository. Would you like to stash them before proceeding?',
+          default: true
+        }]);
+
+        if (gitAnswer.stash) {
+          console.log(chalk.cyan('\nStashing uncommitted changes...'));
+          GitHelper.saveStash(`revert-ai: Pre-undo stash for ${operationsToUndo.length} operations`);
+        }
+      }
+
+      const undoManager = new UndoManager();
+      await undoManager.init();
+      
+      const undoTracker = new UndoTracker();
+      await undoTracker.init();
+      
+      console.log(chalk.cyan(`\\nUndoing ${operationsToUndo.length} operations...\\n`));
+      
+      let successCount = 0;
+      let failCount = 0;
+      
+      for (const operation of operationsToUndo) {
+        const result = await undoManager.undo(operation);
+        
+        if (result.success) {
+          successCount++;
+          console.log(chalk.green(`✓ ${result.message}`));
+          if (result.backupPath) {
+            console.log(chalk.gray(`  Backup saved to: ${result.backupPath}`));
+          }
+          
+          // Mark operation as undone if using Claude Code sessions
+          if (sessionFile) {
+            await undoTracker.markAsUndone(operation.id, sessionFile);
+          }
+        } else {
+          failCount++;
+          console.log(chalk.red(`✗ ${result.message}`));
+        }
+      }
+      
+      console.log(chalk.bold(`\\nCompleted: ${chalk.green(successCount)} successful, ${chalk.red(failCount)} failed`));
+      
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('redo [operation-id]')
+  .description(i18n.t('cmd.redo.description'))
+  .option('-s, --session <id>', i18n.t('opt.session'))
+  .option('-y, --yes', i18n.t('opt.yes'))
+  .option('--local', 'Use local revert-ai tracking instead of Claude sessions')
+  .action(async (operationId, options) => {
+    try {
+      let operations = [];
+      let sessionFile = null;
+      
+      if (options.local) {
+        // Use local revert-ai tracking
+        const sessionId = options.session || await SessionTracker.getCurrentSession();
+        if (!sessionId) {
+          console.log(chalk.yellow('No local revert-ai session found.'));
+          return;
+        }
+
+        const tracker = new SessionTracker(sessionId);
+        await tracker.init();
+        // For local tracking, we'd need to implement redo tracking
+        console.log(chalk.yellow('Redo for local tracking is not yet implemented.'));
+        return;
+      } else {
+        const detection = await AgentDetector.detect();
+        if (!detection) {
+          console.log(chalk.yellow('No active AI agent session found in this directory.'));
+          return;
+        }
+        const { parser } = detection;
+        sessionFile = await parser.getCurrentSessionFile();
+        
+        // Get all operations including undone ones
+        const originalOperations = await parser.parseSessionFile(sessionFile, true);
+        const undoTracker = new UndoTracker();
+        await undoTracker.init();
+        
+        operations = await undoTracker.getUndoneOperationsList(originalOperations, sessionFile);
+      }
+      
+      if (operations.length === 0) {
+        console.log(chalk.yellow(i18n.t('msg.no_operations_to_redo')));
+        return;
+      }
+
+      // Operations are already in reverse order (most recent undo first)
+      let selectedIndex = 0;
+      
+      if (!operationId) {
+        const choices = operations.map((op, index) => {
+          const operationsToRedo = index + 1;
+          let name = `${op.type} - ${formatDistance(op.timestamp)}`;
+          
+          if (operationsToRedo > 1) {
+            name += chalk.green(` (+ ${operationsToRedo - 1} more will be redone)`);
+          }
+          
+          return {
+            name: name,
+            value: index,
+            short: `${op.type} (${operationsToRedo} ops)`
+          };
+        });
+        
+        console.log(chalk.yellow('\\n⚠️  Cascading redo: Selecting an operation will redo it and ALL undone operations that came before it.\\n'));
+        
+        const answer = await inquirer.prompt([{
+          type: 'list',
+          name: 'selectedIndex',
+          message: i18n.t('prompt.select_operation_redo'),
+          choices: choices,
+          pageSize: 15
+        }]);
+        
+        selectedIndex = answer.selectedIndex;
+      } else {
+        selectedIndex = operations.findIndex(op => op.id === operationId);
+        if (selectedIndex === -1) {
+          console.log(chalk.red(`Operation ${operationId} not found.`));
+          return;
+        }
+      }
+      
+      const operationsToRedo = operations.slice(0, selectedIndex + 1);
+      
+      if (!options.yes) {
+        console.log(chalk.yellow(`\\n${i18n.t('header.this_will_redo', { count: operationsToRedo.length })}\\n`));
+        
+        for (let i = 0; i < operationsToRedo.length; i++) {
+          const op = operationsToRedo[i];
+          console.log(`${chalk.bold(`${i + 1}.`)} ${chalk.cyan(op.type)} - ${formatDistance(op.timestamp)}`);
+          console.log('');
+        }
+        
+        const confirm = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'proceed',
+          message: i18n.t('prompt.confirm_redo', { count: operationsToRedo.length }),
+          default: false
+        }]);
+        
+        if (!confirm.proceed) {
+          console.log(chalk.yellow('Redo cancelled.'));
+          return;
+        }
+      }
+
+      const redoManager = new RedoManager();
+      await redoManager.init();
+      
+      const undoTracker = new UndoTracker();
+      await undoTracker.init();
+      
+      console.log(chalk.cyan(`\\n${i18n.t('header.redoing', { count: operationsToRedo.length })}\\n`));
+      
+      let successCount = 0;
+      let failCount = 0;
+      
+      // Redo operations in reverse order (oldest undone operation first)
+      for (const operation of operationsToRedo.reverse()) {
+        const result = await redoManager.redo(operation);
+        
+        if (result.success) {
+          successCount++;
+          console.log(chalk.green(`✓ ${result.message}`));
+          if (result.backupPath) {
+            console.log(chalk.gray(`  Backup saved to: ${result.backupPath}`));
+          }
+          
+          // Mark operation as redone (remove from undone list)
+          if (sessionFile) {
+            await undoTracker.markAsRedone(operation.id, sessionFile);
+          }
+        } else {
+          failCount++;
+          console.log(chalk.red(`✗ ${result.message}`));
+        }
+      }
+      
+      console.log(chalk.bold(`\\nCompleted: ${chalk.green(successCount)} successful, ${chalk.red(failCount)} failed`));
+      
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('preview [operation-id]')
+  .description('Preview what would be undone without making changes')
+  .option('-s, --session <id>', 'Specify session ID')
+  .option('--local', 'Use local revert-ai tracking instead of Claude sessions')
+  .action(async (operationId, options) => {
+    try {
+      let operations = [];
+      
+      if (options.local) {
+        const sessionId = options.session || await SessionTracker.getCurrentSession();
+        if (!sessionId) {
+          console.log(chalk.yellow('No local revert-ai session found.'));
+          return;
+        }
+
+        const tracker = new SessionTracker(sessionId);
+        await tracker.init();
+        operations = await tracker.getOperations();
+      } else {
+        const detection = await AgentDetector.detect();
+        if (!detection) {
+          console.log(chalk.yellow('No active AI agent session found in this directory.'));
+          return;
+        }
+        const { parser } = detection;
+        const sessionFile = await parser.getCurrentSessionFile();
+        operations = await parser.parseSessionFile(sessionFile);
+      }
+      
+      if (operations.length === 0) {
+        console.log(chalk.yellow('No operations found.'));
+        return;
+      }
+
+      operations.reverse();
+      
+      let selectedIndex = 0;
+      
+      if (!operationId) {
+        const choices = operations.map((op, index) => {
+          const dependentOps = getDependentOperations(index, operations, process.cwd());
+          let name = `${op.type} - ${formatDistance(op.timestamp)}`;
+          
+          if (dependentOps.length > 1) {
+            name += chalk.gray(` (+ ${dependentOps.length - 1} dependent ops would be undone)`);
+          }
+          
+          return {
+            name: name,
+            value: index
+          };
+        });
+        
+        const answer = await inquirer.prompt([{
+          type: 'list',
+          name: 'selectedIndex',
+          message: 'Select operation to preview:',
+          choices: choices,
+          pageSize: 15
+        }]);
+        
+        selectedIndex = answer.selectedIndex;
+      } else {
+        selectedIndex = operations.findIndex(op => op.id === operationId);
+        if (selectedIndex === -1) {
+          console.log(chalk.red(`Operation ${operationId} not found.`));
+          return;
+        }
+      }
+      
+      const operationsToUndo = getDependentOperations(selectedIndex, operations, process.cwd());
+      
+      console.log(chalk.blue(`\\n📋 Preview: Would undo ${operationsToUndo.length} operation(s):\\n`));
+      
+      for (let i = 0; i < operationsToUndo.length; i++) {
+        const op = operationsToUndo[i];
+        console.log(`${chalk.bold(`${i + 1}.`)} ${chalk.cyan(op.type)} - ${formatDistance(op.timestamp)}`);
+        
+        const preview = await OperationPreview.generatePreview(op);
+        console.log(`   ${preview.preview.replace(/\\n/g, '\\n   ')}`);
+        console.log('');
+      }
+      
+      console.log(chalk.gray('💡 To actually perform these undos, run: revert-ai undo'));
+      
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('sessions')
+  .description('List all available Claude Code sessions')
+  .option('--local', 'Show local revert-ai sessions instead of Claude sessions')
+  .action(async (options) => {
+    try {
+      if (options.local) {
+        const sessions = await SessionTracker.listSessions();
+        const currentSession = await SessionTracker.getCurrentSession();
+        
+        if (sessions.length === 0) {
+          console.log(chalk.yellow('No local sessions found.'));
+          return;
+        }
+        
+        console.log(chalk.bold('\nAvailable local sessions:\n'));
+        
+        sessions.forEach(session => {
+          const isCurrent = session === currentSession;
+          const marker = isCurrent ? chalk.green('→ ') : '  ';
+          console.log(`${marker}${session}`);
+        });
+      } else {
+        const detection = await AgentDetector.detect();
+        if (!detection) {
+          console.log(chalk.yellow('No active AI agent session found in this directory.'));
+          return;
+        }
+        const { parser } = detection;
+        const sessions = await parser.getAllSessions();
+        
+        if (sessions.length === 0) {
+          console.log(chalk.yellow('No active sessions found.'));
+          return;
+        }
+        
+        console.log(chalk.bold('\nAvailable sessions:\n'));
+        
+        const currentProjectDir = await parser.getCurrentProjectDir();
+        const currentProjectDirName = path.basename(currentProjectDir);
+
+        sessions.forEach(session => {
+          const isCurrent = session.rawProjectDir === currentProjectDirName;
+          const marker = isCurrent ? chalk.green('→ ') : '  ';
+          console.log(`${marker}${chalk.cyan(session.id)}`);
+          console.log(`  Project: ${session.project}`);
+        });
+      }
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('session <id>')
+  .description(i18n.t('cmd.session.description'))
+  .action(async (sessionId) => {
+    try {
+      await SessionTracker.setCurrentSession(sessionId);
+      console.log(chalk.green(`Switched to session: ${sessionId}`));
+    } catch (error) {
+      console.error(chalk.red(`Error: ${error.message}`));
+    }
+  });
+
+program
+  .command('language [lang]')
+  .description(i18n.t('cmd.language.description'))
+  .action(async (lang) => {
+    try {
+      if (!lang) {
+        // Show current language and available options
+        const current = i18n.getCurrentLanguage();
+        const available = i18n.getAvailableLanguages();
+        
+        console.log(chalk.bold(`\\nCurrent language: ${chalk.cyan(current.name)} (${current.code})\\n`));
+        console.log(chalk.bold('Available languages:'));
+        available.forEach(({ code, name }) => {
+          const marker = code === current.code ? chalk.green('→ ') : '  ';
+          console.log(`${marker}${code} - ${name}`);
+        });
+        console.log(chalk.gray('\\nUsage: revert-ai language <code>'));
+        return;
+      }
+      
+      await i18n.setLanguage(lang);
+      const newLang = i18n.getCurrentLanguage();
+      console.log(chalk.green(i18n.t('msg.language_set', { language: newLang.name })));
+    } catch (error) {
+      const available = i18n.getAvailableLanguages().map(l => l.code).join(', ');
+      console.error(chalk.red(i18n.t('msg.language_invalid', { languages: available })));
+    }
+  });
+
+program.parse(process.argv);

package/index.js

@@ -0,0 +1,4 @@
+export { SessionTracker } from './src/core/SessionTracker.js';
+export { UndoManager } from './src/core/UndoManager.js';
+export { Operation, OperationType } from './src/core/Operation.js';
+export { formatDistance } from './src/utils/formatting.js'; 

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "revert-ai",
+  "version": "1.1.1",
+  "description": "Intelligent undo/redo for AI Coding Assistants (Claude Code, Aider, etc.) with cascading safety, visual diffs, and Git checkpoints",
+  "main": "index.js",
+  "bin": {
+    "revert-ai": "./bin/revert-ai.js"
+  },
+  "scripts": {
+    "test": "NODE_OPTIONS=\"--experimental-vm-modules\" jest",
+    "test:watch": "NODE_OPTIONS=\"--experimental-vm-modules\" jest --watch",
+    "demo": "./demo-language.sh",
+    "build:binaries": "npx @yao-pkg/pkg bin/revert-ai.js --targets node18-macos-x64,node18-macos-arm64,node18-linux-x64,node18-win-x64 --out-path dist/",
+    "prepublishOnly": "npm test"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "undo",
+    "redo",
+    "revert",
+    "cli",
+    "ai-development",
+    "session-management",
+    "file-operations",
+    "backup",
+    "preview",
+    "internationalization",
+    "japanese"
+  ],
+  "author": "Harsha Rajkumar",
+  "license": "MIT",
+  "type": "module",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/harsharajkumar-273/revert-ai.git"
+  },
+  "bugs": {
+    "url": "https://github.com/harsharajkumar-273/revert-ai/issues"
+  },
+  "homepage": "https://github.com/harsharajkumar-273/revert-ai#readme",
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@babel/parser": "^8.0.4",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "inquirer": "^9.2.12"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "pkg": {
+    "scripts": "src/**/*.js",
+    "assets": [
+      "README.md",
+      "LICENSE"
+    ],
+    "targets": [
+      "node18-macos-x64",
+      "node18-macos-arm64",
+      "node18-linux-x64",
+      "node18-win-x64"
+    ],
+    "outputPath": "dist"
+  }
+}

package/src/core/AgentDetector.js

@@ -0,0 +1,27 @@
+import { ClaudeSessionParser } from './ClaudeSessionParser.js';
+import { AiderSessionParser } from './AiderSessionParser.js';
+
+export class AgentDetector {
+  /**
+   * Automatically detect which AI agent session is active in the current directory.
+   * Checks for Aider first, then Claude Code.
+   * @returns {Promise<{ agent: string, parser: import('./AgentParser.js').AgentParser } | null>}
+   */
+  static async detect() {
+    // 1. Check Aider first
+    const aider = new AiderSessionParser();
+    const hasAider = await aider.detect();
+    if (hasAider) {
+      return { agent: 'aider', parser: aider };
+    }
+
+    // 2. Check Claude Code
+    const claude = new ClaudeSessionParser();
+    const hasClaude = await claude.getCurrentSessionFile();
+    if (hasClaude) {
+      return { agent: 'claude', parser: claude };
+    }
+
+    return null;
+  }
+}