revert-ai 1.1.1

package/src/core/AgentParser.js

@@ -0,0 +1,34 @@
+export class AgentParser {
+  /**
+   * Get the mapped directory name in the agent's storage for the current workspace CWD
+   * @returns {Promise<string>}
+   */
+  async getCurrentProjectDir() {
+    throw new Error('getCurrentProjectDir() not implemented');
+  }
+
+  /**
+   * Get the path to the most recent session log file
+   * @returns {Promise<string|null>}
+   */
+  async getCurrentSessionFile() {
+    throw new Error('getCurrentSessionFile() not implemented');
+  }
+
+  /**
+   * Parse a session log file and return an array of Operations
+   * @param {string} sessionFile 
+   * @returns {Promise<import('./Operation.js').Operation[]>}
+   */
+  async parseSessionFile(sessionFile) {
+    throw new Error('parseSessionFile() not implemented');
+  }
+
+  /**
+   * Get all session files for this agent
+   * @returns {Promise<object[]>}
+   */
+  async getAllSessions() {
+    throw new Error('getAllSessions() not implemented');
+  }
+}

package/src/core/AiderSessionParser.js

@@ -0,0 +1,143 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { execSync } from 'child_process';
+import { AgentParser } from './AgentParser.js';
+import { Operation, OperationType } from './Operation.js';
+import { UndoTracker } from './UndoTracker.js';
+
+export class AiderSessionParser extends AgentParser {
+  constructor() {
+    super();
+  }
+
+  async detect() {
+    // Check if .aider.chat.history.md exists
+    const localAiderHistory = path.join(process.cwd(), '.aider.chat.history.md');
+    const exists = await fs.access(localAiderHistory).then(() => true).catch(() => false);
+    if (exists) return true;
+
+    // Check if git has aider commits
+    try {
+      const gitLogs = execSync('git log --grep="^[aA]ider:" -n 1 --oneline 2>/dev/null', { encoding: 'utf8' });
+      return gitLogs.trim().length > 0;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  async getCurrentProjectDir() {
+    return process.cwd();
+  }
+
+  async getCurrentSessionFile() {
+    const historyFile = path.join(process.cwd(), '.aider.chat.history.md');
+    const exists = await fs.access(historyFile).then(() => true).catch(() => false);
+    return exists ? historyFile : 'git-history';
+  }
+
+  async parseSessionFile(sessionFile, includeUndone = false) {
+    const operations = [];
+    
+    // Check if we are in a git repository
+    let isGit = false;
+    try {
+      execSync('git rev-parse --is-inside-work-tree 2>/dev/null');
+      isGit = true;
+    } catch (e) {
+      isGit = false;
+    }
+
+    if (!isGit) {
+      return operations; // No git support, return empty (or we can fallback to md parse if we build it later)
+    }
+
+    try {
+      // Get all Aider commits in reverse chronological order (newest first)
+      const commitLog = execSync('git log --grep="^[aA]ider:" --pretty=format:"%H|%ct|%s" --date=unix', { encoding: 'utf8' });
+      if (!commitLog.trim()) return [];
+
+      const lines = commitLog.split('\n');
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        const [hash, timestampStr, message] = line.split('|');
+        const timestamp = new Date(parseInt(timestampStr, 10) * 1000);
+
+        // Get list of changed files for this commit
+        const fileStatus = execSync(`git show --name-status --pretty="" ${hash}`, { encoding: 'utf8' });
+        const fileLines = fileStatus.split('\n');
+        
+        for (const fileLine of fileLines) {
+          if (!fileLine.trim()) continue;
+          const [status, filePath] = fileLine.split(/\s+/);
+          
+          if (!filePath) continue;
+          
+          // Formulate operation data based on git status
+          let opType;
+          let opData = { filePath: path.resolve(filePath) };
+
+          if (status === 'A') {
+            opType = OperationType.FILE_CREATE;
+            // Get content written
+            try {
+              opData.content = execSync(`git show ${hash}:${filePath}`, { encoding: 'utf8' });
+            } catch (e) {
+              opData.content = '';
+            }
+          } else if (status === 'D') {
+            opType = OperationType.FILE_DELETE;
+            // Get content before deletion
+            try {
+              opData.content = execSync(`git show ${hash}~1:${filePath}`, { encoding: 'utf8' });
+            } catch (e) {
+              opData.content = '';
+            }
+          } else if (status === 'M') {
+            opType = OperationType.FILE_EDIT;
+            // Get original and new content to reverse string edit
+            try {
+              opData.originalContent = execSync(`git show ${hash}~1:${filePath}`, { encoding: 'utf8' });
+              opData.newContent = execSync(`git show ${hash}:${filePath}`, { encoding: 'utf8' });
+            } catch (e) {
+              // fallback if we can't show parent
+            }
+          } else {
+            // General support
+            continue;
+          }
+
+          const op = new Operation(opType, opData);
+          op.id = `${hash}-${filePath.replace(/[^a-zA-Z0-9]/g, '_')}`; // unique operation id per file change in commit
+          op.timestamp = timestamp;
+          operations.push(op);
+        }
+      }
+    } catch (error) {
+      console.error('Error parsing Aider git history:', error.message);
+    }
+
+    if (includeUndone) {
+      return operations;
+    }
+
+    // Filter out operations already undone
+    const undoTracker = new UndoTracker();
+    await undoTracker.init();
+    const filteredOperations = await undoTracker.filterUndoneOperations(operations, 'aider-session');
+
+    return filteredOperations;
+  }
+
+  async getAllSessions() {
+    const hasAider = await this.detect();
+    if (hasAider) {
+      return [{
+        id: 'aider-session',
+        project: process.cwd(),
+        rawProjectDir: path.basename(process.cwd()),
+        file: 'git-history'
+      }];
+    }
+    return [];
+  }
+}

package/src/core/ClaudeSessionParser.js

@@ -0,0 +1,243 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+import { Operation, OperationType } from './Operation.js';
+import { UndoTracker } from './UndoTracker.js';
+import { AgentParser } from './AgentParser.js';
+
+export class ClaudeSessionParser extends AgentParser {
+  constructor() {
+    super();
+    this.claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+  }
+
+  async getCurrentProjectDir() {
+    const cwd = process.cwd();
+    let safePath;
+    
+    // Claude uses different formats for different operating systems
+    if (process.platform === 'win32') {
+      // Windows: C:\Users\... → C--Users-...
+      safePath = cwd.replace(/:[\\\/]/g, '--')
+                     .replace(/[\\/]/g, '-')
+                     .replace(/[\s_]/g, '-');
+    } else {
+      // Linux/macOS: /home/... → -home-...
+      safePath = cwd.replace(/[\s\/_]/g, '-');
+    }
+    
+    return path.join(this.claudeProjectsDir, safePath);
+  }
+
+  async getCurrentSessionFile() {
+    const projectDir = await this.getCurrentProjectDir();
+    
+    try {
+      const files = await fs.readdir(projectDir);
+      const sessionFiles = files.filter(f => f.endsWith('.jsonl'));
+      
+      if (sessionFiles.length === 0) return null;
+      
+      // Get the most recently modified session file
+      const stats = await Promise.all(
+        sessionFiles.map(async f => ({
+          file: f,
+          path: path.join(projectDir, f),
+          mtime: (await fs.stat(path.join(projectDir, f))).mtime
+        }))
+      );
+      
+      stats.sort((a, b) => b.mtime - a.mtime);
+      return stats[0].path;
+    } catch (error) {
+      if (error.code === 'ENOENT') return null;
+      throw error;
+    }
+  }
+
+  async parseSessionFile(sessionFile, includeUndone = false) {
+    const operations = [];
+    const fileStream = createReadStream(sessionFile);
+    const rl = createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      try {
+        const entry = JSON.parse(line);
+        
+        // Look for tool use messages
+        if (entry.type === 'assistant' && entry.message?.content) {
+          for (const content of entry.message.content) {
+            if (content.type === 'tool_use') {
+              const operation = this.extractOperation(content, entry.timestamp);
+              if (operation) {
+                operations.push(operation);
+              }
+            }
+          }
+        }
+      } catch (e) {
+        // Skip invalid JSON lines
+      }
+    }
+
+    if (includeUndone) {
+      return operations;
+    }
+
+    // Filter out operations that have already been undone
+    const undoTracker = new UndoTracker();
+    await undoTracker.init();
+    const filteredOperations = await undoTracker.filterUndoneOperations(operations, sessionFile);
+    
+    return filteredOperations;
+  }
+
+  extractOperation(toolUse, timestamp) {
+    const { name, input } = toolUse;
+    
+    switch (name) {
+      case 'Write':
+        if (input.file_path) {
+          const op = new Operation(OperationType.FILE_CREATE, {
+            filePath: input.file_path,
+            content: input.content || ''
+          });
+          op.timestamp = new Date(timestamp);
+          op.id = toolUse.id;
+          return op;
+        }
+        break;
+
+      case 'Edit':
+        if (input.file_path) {
+          const op = new Operation(OperationType.FILE_EDIT, {
+            filePath: input.file_path,
+            // Note: We only have the string that was replaced, not the full file content
+            // This will be handled differently in UndoManager
+            oldString: input.old_string || '',
+            newString: input.new_string || '',
+            replaceAll: input.replace_all || false
+          });
+          op.timestamp = new Date(timestamp);
+          op.id = toolUse.id;
+          return op;
+        }
+        break;
+        
+      case 'MultiEdit':
+        if (input.file_path) {
+          // For MultiEdit, we have multiple edits but still just the strings
+          const op = new Operation(OperationType.FILE_EDIT, {
+            filePath: input.file_path,
+            edits: input.edits || [],
+            isMultiEdit: true
+          });
+          op.timestamp = new Date(timestamp);
+          op.id = toolUse.id;
+          return op;
+        }
+        break;
+
+      case 'Bash':
+        if (input.command) {
+          const command = input.command;
+          
+          // Try to detect file operations in bash commands
+          if (command.includes('rm ') && !command.includes('rmdir')) {
+            const match = command.match(/rm\s+(?:-[rf]+\s+)?([^\s]+)/);
+            if (match) {
+              const op = new Operation(OperationType.FILE_DELETE, {
+                filePath: match[1],
+                content: '' // We can't recover content from session history
+              });
+              op.timestamp = new Date(timestamp);
+              op.id = toolUse.id;
+              return op;
+            }
+          } else if (command.includes('mv ')) {
+            const match = command.match(/mv\s+([^\s]+)\s+([^\s]+)/);
+            if (match) {
+              const op = new Operation(OperationType.FILE_RENAME, {
+                oldPath: match[1],
+                newPath: match[2]
+              });
+              op.timestamp = new Date(timestamp);
+              op.id = toolUse.id;
+              return op;
+            }
+          } else if (command.includes('mkdir')) {
+            const match = command.match(/mkdir\s+(?:-p\s+)?([^\s]+)/);
+            if (match) {
+              const op = new Operation(OperationType.DIRECTORY_CREATE, {
+                dirPath: match[1]
+              });
+              op.timestamp = new Date(timestamp);
+              op.id = toolUse.id;
+              return op;
+            }
+          } else {
+            // Generic bash command
+            const op = new Operation(OperationType.BASH_COMMAND, {
+              command: command
+            });
+            op.timestamp = new Date(timestamp);
+            op.id = toolUse.id;
+            return op;
+          }
+        }
+        break;
+    }
+    
+    return null;
+  }
+
+  async getAllSessions() {
+    try {
+      const projectDirs = await fs.readdir(this.claudeProjectsDir);
+      const sessions = [];
+      
+      for (const projectDir of projectDirs) {
+        const fullPath = path.join(this.claudeProjectsDir, projectDir);
+        const stat = await fs.stat(fullPath);
+        
+        if (stat.isDirectory()) {
+          const files = await fs.readdir(fullPath);
+          const sessionFiles = files.filter(f => f.endsWith('.jsonl'));
+          
+          for (const sessionFile of sessionFiles) {
+            const sessionId = sessionFile.replace('.jsonl', '');
+            // Convert back to proper path - reverse the Claude encoding
+            let projectPath = projectDir;
+            
+            if (process.platform === 'win32') {
+              // Windows: C--Users-... → C:\Users\...
+              projectPath = projectPath.replace(/--/g, ':\\');
+              projectPath = projectPath.replace(/-/g, '\\');
+            } else {
+              // Linux/macOS: -home-... → /home/...
+              projectPath = projectPath.replace(/^-/, '/');
+              projectPath = projectPath.replace(/-/g, '/');
+            }
+            
+            sessions.push({
+              id: sessionId,
+              project: projectPath, // Decoded path for display
+              rawProjectDir: projectDir, // Raw directory name for comparison
+              file: path.join(fullPath, sessionFile)
+            });
+          }
+        }
+      }
+      
+      return sessions;
+    } catch (error) {
+      if (error.code === 'ENOENT') return [];
+      throw error;
+    }
+  }
+}

package/src/core/DependencyCascading.js

@@ -0,0 +1,74 @@
+import { DependencyResolver } from './DependencyResolver.js';
+import path from 'path';
+
+/**
+ * Returns the list of files involved in an operation.
+ * @param {import('./Operation.js').Operation} op 
+ * @returns {string[]}
+ */
+export function getOperationFiles(op) {
+  const files = [];
+  if (op.data.filePath) files.push(op.data.filePath);
+  if (op.data.oldPath) files.push(op.data.oldPath);
+  if (op.data.newPath) files.push(op.data.newPath);
+  return files;
+}
+
+/**
+ * Given a selected operation to undo, returns only the operations that directly or 
+ * transitively depend on it, filter-cascading from the reversed operations list.
+ * @param {number} selectedOpIndex 
+ * @param {import('./Operation.js').Operation[]} reversedOps Newest first
+ * @param {string} workspaceRoot 
+ * @returns {import('./Operation.js').Operation[]}
+ */
+export function getDependentOperations(selectedOpIndex, reversedOps, workspaceRoot) {
+  const dependentIndices = new Set([selectedOpIndex]);
+  
+  // Extract all files involved in any of the operations for dependency tracing context
+  const allFiles = [...new Set(reversedOps.map(getOperationFiles).flat())];
+
+  // Process subsequent operations from oldest (closest to selected) to newest (index 0)
+  for (let i = selectedOpIndex - 1; i >= 0; i--) {
+    const op = reversedOps[i];
+    const filesB = getOperationFiles(op);
+    let depends = false;
+
+    for (const depIdx of dependentIndices) {
+      const depOp = reversedOps[depIdx];
+      const filesA = getOperationFiles(depOp);
+
+      // 1. File path overlap (e.g. editing the same file)
+      const overlap = filesA.some(f => filesB.includes(f));
+      if (overlap) {
+        depends = true;
+        break;
+      }
+
+      // 2. Import-based dependency check
+      for (const fileB of filesB) {
+        for (const fileA of filesA) {
+          if (DependencyResolver.transitivelyDependsOn(fileB, fileA, workspaceRoot, allFiles)) {
+            depends = true;
+            break;
+          }
+        }
+        if (depends) break;
+      }
+      if (depends) break;
+    }
+
+    if (depends) {
+      dependentIndices.add(i);
+    }
+  }
+
+  // Return the selected operations preserving their reversed order (newest first)
+  const result = [];
+  for (let i = 0; i <= selectedOpIndex; i++) {
+    if (dependentIndices.has(i)) {
+      result.push(reversedOps[i]);
+    }
+  }
+  return result;
+}

package/src/core/DependencyResolver.js

@@ -0,0 +1,206 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { parse } from '@babel/parser';
+
+export class DependencyResolver {
+  /**
+   * Parse a JS/TS file and return its relative import paths.
+   * @param {string} filePath 
+   * @returns {string[]}
+   */
+  static getJsImports(filePath) {
+    const imports = [];
+    let fileContent;
+    try {
+      fileContent = fs.readFileSync(filePath, 'utf8');
+    } catch (e) {
+      return [];
+    }
+
+    try {
+      const ast = parse(fileContent, {
+        sourceType: 'module',
+        plugins: ['typescript', 'jsx', 'classProperties', 'dynamicImport', 'decorators-legacy']
+      });
+
+      const traverse = (node) => {
+        if (!node) return;
+        if (node.type === 'ImportDeclaration' && node.source && node.source.value) {
+          imports.push(node.source.value);
+        }
+        if (
+          node.type === 'CallExpression' && 
+          node.callee && 
+          node.callee.name === 'require' && 
+          node.arguments && 
+          node.arguments[0] && 
+          typeof node.arguments[0].value === 'string'
+        ) {
+          imports.push(node.arguments[0].value);
+        }
+        
+        for (const key in node) {
+          if (node[key] && typeof node[key] === 'object') {
+            if (Array.isArray(node[key])) {
+              node[key].forEach(traverse);
+            } else {
+              traverse(node[key]);
+            }
+          }
+        }
+      };
+
+      traverse(ast.program);
+    } catch (e) {
+      // Fallback: syntax error (half-written file) -> Regex matching
+      const importRegex = /import\s+.*?\s+from\s+['"](.*?)['"]|require\(['"](.*?)['"]\)/g;
+      let match;
+      while ((match = importRegex.exec(fileContent)) !== null) {
+        imports.push(match[1] || match[2]);
+      }
+    }
+
+    // Filter to keep only relative paths within project
+    return imports.filter(imp => imp.startsWith('.') || imp.startsWith('/'));
+  }
+
+  /**
+   * Parse a Python file and return its module imports.
+   * @param {string} filePath 
+   * @returns {string[]}
+   */
+  static getPythonImports(filePath) {
+    const pythonScript = `
+import ast, sys, json
+try:
+    with open(sys.argv[1], "r", encoding="utf-8") as f:
+        tree = ast.parse(f.read())
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for name in node.names:
+                imports.append(name.name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                imports.append(node.module)
+    print(json.dumps(imports))
+except Exception:
+    print("[]")
+`;
+
+    try {
+      const output = execSync(`python3 -c '${pythonScript.replace(/'/g, "'\\''")}' "${filePath}"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] });
+      return JSON.parse(output.trim() || '[]');
+    } catch (e) {
+      // Fallback: Regex matching if python3 ast fails or is unavailable
+      const imports = [];
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const importRegex = /^(?:from\s+(\S+)\s+import|import\s+(\S+))/gm;
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+          const matched = match[1] || match[2];
+          if (matched) imports.push(matched);
+        }
+      } catch (err) {}
+      return imports;
+    }
+  }
+
+  /**
+   * Resolve an import statement relative to the importer file.
+   * @param {string} importerPath Absolute path of the file importing
+   * @param {string} importStr The raw string import path (e.g. '../../utils')
+   * @returns {string|null} Resolved absolute path or null
+   */
+  static resolveJsPath(importerPath, importStr) {
+    const dir = path.dirname(importerPath);
+    const absolute = path.resolve(dir, importStr);
+    
+    // Check possible extensions
+    const extensions = ['.js', '.jsx', '.ts', '.tsx', '/index.js', '/index.ts'];
+    if (fs.existsSync(absolute) && fs.statSync(absolute).isFile()) {
+      return absolute;
+    }
+    for (const ext of extensions) {
+      const candidate = absolute + ext;
+      if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+        return candidate;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Check if fileB depends on fileA.
+   * @param {string} fileB Importer candidate
+   * @param {string} fileA Target dependency candidate
+   * @param {string} workspaceRoot The workspace root
+   * @returns {boolean}
+   */
+  static dependsOn(fileB, fileA, workspaceRoot) {
+    const extB = path.extname(fileB);
+    const absA = path.resolve(workspaceRoot, fileA);
+    const absB = path.resolve(workspaceRoot, fileB);
+
+    if (absA === absB) return false;
+
+    // JavaScript / TypeScript dependency resolution
+    if (['.js', '.jsx', '.ts', '.tsx'].includes(extB)) {
+      const imports = this.getJsImports(absB);
+      for (const imp of imports) {
+        const resolved = this.resolveJsPath(absB, imp);
+        if (resolved && resolved === absA) {
+          return true;
+        }
+      }
+    }
+
+    // Python dependency resolution
+    if (extB === '.py') {
+      const imports = this.getPythonImports(absB);
+      // Python imports can be e.g. 'src.utils.math' or '.utils'
+      const baseNameA = path.basename(fileA, '.py');
+      for (const imp of imports) {
+        // Simple module name match (e.g. if fileA is src/utils/math.py, imp contains 'math' or 'src.utils.math')
+        if (imp === baseNameA || imp.endsWith('.' + baseNameA) || fileA.replace(/\//g, '.').includes(imp)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Determine transitive dependency map to see if fileB transitively depends on fileA.
+   * Uses BFS to trace dependency chain.
+   * @param {string} fileB Importer candidate
+   * @param {string} fileA Target dependency candidate
+   * @param {string} workspaceRoot The workspace root
+   * @param {string[]} allFiles All modified files in the session context
+   * @returns {boolean}
+   */
+  static transitivelyDependsOn(fileB, fileA, workspaceRoot, allFiles) {
+    const queue = [fileB];
+    const visited = new Set();
+
+    while (queue.length > 0) {
+      const current = queue.shift();
+      if (current === fileA) return true;
+      if (visited.has(current)) continue;
+      visited.add(current);
+
+      for (const otherFile of allFiles) {
+        if (otherFile !== current && !visited.has(otherFile)) {
+          if (this.dependsOn(current, otherFile, workspaceRoot)) {
+            queue.push(otherFile);
+          }
+        }
+      }
+    }
+
+    return false;
+  }
+}