centaurus-cli 2.9.4 → 2.9.6

package/dist/services/checkpoint-manager.js

@@ -0,0 +1,926 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import fg from 'fast-glob';
+import { logError, logWarning } from '../utils/logger.js';
+const DEFAULT_IGNORE_PATTERNS = [
+    '**/.git/**',
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/out/**',
+    '**/.next/**',
+    '**/.turbo/**',
+    '**/.cache/**',
+    '**/coverage/**',
+    '**/__pycache__/**',
+    '**/.venv/**',
+    '**/venv/**',
+    '**/.idea/**',
+    '**/.vscode/**',
+    '**/.DS_Store',
+    '**/Thumbs.db',
+    '**/.centaurus/**',
+];
+export class CheckpointManager {
+    checkpoints = [];
+    currentChatId = null;
+    discardedIds = new Set();
+    baseDir;
+    constructor() {
+        this.baseDir = path.join(os.homedir(), '.centaurus', 'checkpoints');
+        this.ensureDirSync(this.baseDir);
+    }
+    setCurrentChatId(chatId) {
+        this.currentChatId = chatId;
+        this.loadIndex();
+    }
+    clear() {
+        this.checkpoints = [];
+        this.discardedIds.clear();
+    }
+    list() {
+        return [...this.checkpoints].sort((a, b) => b.createdAtMs - a.createdAtMs);
+    }
+    /**
+     * Get session changes for an active checkpoint (live calculation).
+     * Returns added/modified/deleted file lists plus per-file line stats.
+     */
+    async getSessionChanges(checkpointId, handler) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === checkpointId);
+        if (!checkpoint)
+            return null;
+        const isRemote = checkpoint.contextType !== 'local';
+        if (isRemote && (!handler || !handler.isConnected())) {
+            return null;
+        }
+        const changes = await this.calculateChanges(checkpoint, handler);
+        // Calculate line-level stats for modified files
+        const stats = [];
+        if (!isRemote) {
+            for (const filePath of changes.modified) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                const currentPath = path.join(checkpoint.cwd, filePath);
+                const lineStat = this.calculateLineStats(snapshotPath, currentPath);
+                stats.push({ filePath, ...lineStat });
+            }
+            // For added files, count all lines as insertions
+            for (const filePath of changes.added) {
+                const currentPath = path.join(checkpoint.cwd, filePath);
+                try {
+                    const content = fs.readFileSync(currentPath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    stats.push({ filePath, insertions: lines, deletions: 0 });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+            // For deleted files, count all lines as deletions
+            for (const filePath of changes.deleted) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                try {
+                    const content = fs.readFileSync(snapshotPath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    stats.push({ filePath, insertions: 0, deletions: lines });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+        }
+        else if (handler) {
+            // Remote stats: use handler to read remote file contents
+            for (const filePath of changes.modified) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                const remotePath = checkpoint.cwd + '/' + filePath;
+                try {
+                    const snapshotContent = fs.readFileSync(snapshotPath, 'utf-8');
+                    const remoteContent = await handler.readFile(remotePath);
+                    const lineStat = this.calculateLineStatsFromContent(snapshotContent, remoteContent);
+                    stats.push({ filePath, ...lineStat });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+            for (const filePath of changes.added) {
+                const remotePath = checkpoint.cwd + '/' + filePath;
+                try {
+                    const remoteContent = await handler.readFile(remotePath);
+                    const lines = remoteContent.split('\n').length;
+                    stats.push({ filePath, insertions: lines, deletions: 0 });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+            for (const filePath of changes.deleted) {
+                const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+                try {
+                    const content = fs.readFileSync(snapshotPath, 'utf-8');
+                    const lines = content.split('\n').length;
+                    stats.push({ filePath, insertions: 0, deletions: lines });
+                }
+                catch {
+                    stats.push({ filePath, insertions: 0, deletions: 0 });
+                }
+            }
+        }
+        return { changes, stats };
+    }
+    /**
+     * Get a unified diff for a single file within a checkpoint.
+     * Compares the snapshot version to the current version.
+     */
+    async getFileDiff(checkpointId, filePath, handler) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === checkpointId);
+        if (!checkpoint)
+            return null;
+        const isRemote = checkpoint.contextType !== 'local';
+        const snapshotPath = path.join(checkpoint.snapshotDir, filePath);
+        const snapshotExists = fs.existsSync(snapshotPath);
+        if (isRemote) {
+            if (!handler || !handler.isConnected()) {
+                return null;
+            }
+            const remotePath = checkpoint.cwd + '/' + filePath;
+            let remoteContent = null;
+            try {
+                remoteContent = await handler.readFile(remotePath);
+            }
+            catch {
+                remoteContent = null;
+            }
+            if (!snapshotExists && remoteContent === null) {
+                return null;
+            }
+            // Added file
+            if (!snapshotExists && remoteContent !== null) {
+                const lines = remoteContent.split('\n');
+                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+                diff += lines.map(l => `+${l}`).join('\n');
+                return diff;
+            }
+            // Deleted file
+            if (snapshotExists && remoteContent === null) {
+                try {
+                    const content = fs.readFileSync(snapshotPath, 'utf-8');
+                    const lines = content.split('\n');
+                    let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
+                    diff += lines.map(l => `-${l}`).join('\n');
+                    return diff;
+                }
+                catch {
+                    return `[Binary or unreadable file: ${filePath}]`;
+                }
+            }
+            // Modified file
+            try {
+                const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
+                const newContent = remoteContent ?? '';
+                return this.generateUnifiedDiff(filePath, oldContent, newContent);
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        // Local diff (original logic)
+        const currentPath = path.join(checkpoint.cwd, filePath);
+        const currentExists = fs.existsSync(currentPath);
+        if (!snapshotExists && !currentExists) {
+            return null;
+        }
+        // Added file: show full content as additions
+        if (!snapshotExists && currentExists) {
+            try {
+                const content = fs.readFileSync(currentPath, 'utf-8');
+                const lines = content.split('\n');
+                let diff = `--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${lines.length} @@\n`;
+                diff += lines.map(l => `+${l}`).join('\n');
+                return diff;
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        // Deleted file: show full content as deletions
+        if (snapshotExists && !currentExists) {
+            try {
+                const content = fs.readFileSync(snapshotPath, 'utf-8');
+                const lines = content.split('\n');
+                let diff = `--- a/${filePath}\n+++ /dev/null\n@@ -1,${lines.length} +0,0 @@\n`;
+                diff += lines.map(l => `-${l}`).join('\n');
+                return diff;
+            }
+            catch {
+                return `[Binary or unreadable file: ${filePath}]`;
+            }
+        }
+        // Modified file: produce unified diff
+        try {
+            const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
+            const newContent = fs.readFileSync(currentPath, 'utf-8');
+            return this.generateUnifiedDiff(filePath, oldContent, newContent);
+        }
+        catch {
+            return `[Binary or unreadable file: ${filePath}]`;
+        }
+    }
+    /**
+     * Get the initial checkpoint for the current chat session.
+     * This represents the state at the start of the conversation.
+     */
+    getInitialCheckpoint() {
+        if (this.checkpoints.length === 0)
+            return null;
+        // Sort by creation time to find the first one
+        return [...this.checkpoints].sort((a, b) => a.createdAtMs - b.createdAtMs)[0];
+    }
+    /**
+     * Calculate insertions/deletions between two file versions
+     */
+    calculateLineStats(snapshotPath, currentPath) {
+        try {
+            const oldContent = fs.readFileSync(snapshotPath, 'utf-8');
+            const newContent = fs.readFileSync(currentPath, 'utf-8');
+            return this.calculateLineStatsFromContent(oldContent, newContent);
+        }
+        catch {
+            return { insertions: 0, deletions: 0 };
+        }
+    }
+    calculateLineStatsFromContent(oldContent, newContent) {
+        const oldLines = oldContent.split('\n');
+        const newLines = newContent.split('\n');
+        // Simple LCS-based diff to count insertions and deletions
+        const oldSet = new Map();
+        for (const line of oldLines) {
+            oldSet.set(line, (oldSet.get(line) || 0) + 1);
+        }
+        const newSet = new Map();
+        for (const line of newLines) {
+            newSet.set(line, (newSet.get(line) || 0) + 1);
+        }
+        let deletions = 0;
+        for (const [line, count] of oldSet) {
+            const newCount = newSet.get(line) || 0;
+            if (newCount < count) {
+                deletions += count - newCount;
+            }
+        }
+        let insertions = 0;
+        for (const [line, count] of newSet) {
+            const oldCount = oldSet.get(line) || 0;
+            if (oldCount < count) {
+                insertions += count - oldCount;
+            }
+        }
+        return { insertions, deletions };
+    }
+    /**
+     * Generate a unified diff between old and new content
+     */
+    generateUnifiedDiff(filePath, oldContent, newContent) {
+        const oldLines = oldContent.split('\n');
+        const newLines = newContent.split('\n');
+        // Use a simple diff algorithm: find common prefix/suffix, then show changes
+        let result = `--- a/${filePath}\n+++ b/${filePath}\n`;
+        // Find changed regions using a simple approach
+        const hunks = this.computeHunks(oldLines, newLines);
+        if (hunks.length === 0) {
+            return `No differences found in ${filePath}`;
+        }
+        for (const hunk of hunks) {
+            result += `@@ -${hunk.oldStart + 1},${hunk.oldCount} +${hunk.newStart + 1},${hunk.newCount} @@\n`;
+            for (const line of hunk.lines) {
+                result += line + '\n';
+            }
+        }
+        return result;
+    }
+    /**
+     * Compute diff hunks between old and new lines using Myers-like approach
+     */
+    computeHunks(oldLines, newLines) {
+        // Build an edit script using LCS
+        const lcs = this.longestCommonSubsequence(oldLines, newLines);
+        const editScript = [];
+        let oldIdx = 0;
+        let newIdx = 0;
+        let lcsIdx = 0;
+        while (oldIdx < oldLines.length || newIdx < newLines.length) {
+            if (lcsIdx < lcs.length && oldIdx < oldLines.length && newIdx < newLines.length &&
+                oldLines[oldIdx] === lcs[lcsIdx] && newLines[newIdx] === lcs[lcsIdx]) {
+                editScript.push({ type: 'keep', oldIdx, newIdx, line: oldLines[oldIdx] });
+                oldIdx++;
+                newIdx++;
+                lcsIdx++;
+            }
+            else if (oldIdx < oldLines.length && (lcsIdx >= lcs.length || oldLines[oldIdx] !== lcs[lcsIdx])) {
+                editScript.push({ type: 'delete', oldIdx, newIdx, line: oldLines[oldIdx] });
+                oldIdx++;
+            }
+            else if (newIdx < newLines.length) {
+                editScript.push({ type: 'insert', oldIdx, newIdx, line: newLines[newIdx] });
+                newIdx++;
+            }
+        }
+        // Group into hunks with context (3 lines)
+        const CONTEXT = 3;
+        const hunks = [];
+        let currentHunk = null;
+        let contextCounter = 0;
+        for (let i = 0; i < editScript.length; i++) {
+            const edit = editScript[i];
+            if (edit.type !== 'keep') {
+                // Start a new hunk or extend current
+                if (!currentHunk) {
+                    // Look back for context
+                    const contextStart = Math.max(0, i - CONTEXT);
+                    currentHunk = {
+                        oldStart: editScript[contextStart]?.oldIdx ?? edit.oldIdx,
+                        oldCount: 0,
+                        newStart: editScript[contextStart]?.newIdx ?? edit.newIdx,
+                        newCount: 0,
+                        lines: [],
+                    };
+                    for (let j = contextStart; j < i; j++) {
+                        if (editScript[j].type === 'keep') {
+                            currentHunk.lines.push(` ${editScript[j].line}`);
+                            currentHunk.oldCount++;
+                            currentHunk.newCount++;
+                        }
+                    }
+                }
+                if (edit.type === 'delete') {
+                    currentHunk.lines.push(`-${edit.line}`);
+                    currentHunk.oldCount++;
+                }
+                else {
+                    currentHunk.lines.push(`+${edit.line}`);
+                    currentHunk.newCount++;
+                }
+                contextCounter = 0;
+            }
+            else if (currentHunk) {
+                contextCounter++;
+                if (contextCounter <= CONTEXT) {
+                    currentHunk.lines.push(` ${edit.line}`);
+                    currentHunk.oldCount++;
+                    currentHunk.newCount++;
+                }
+                else {
+                    // End the hunk
+                    hunks.push(currentHunk);
+                    currentHunk = null;
+                    contextCounter = 0;
+                }
+            }
+        }
+        if (currentHunk) {
+            hunks.push(currentHunk);
+        }
+        return hunks;
+    }
+    /**
+     * Compute longest common subsequence of two string arrays
+     * Uses optimized approach for large files (limit LCS table size)
+     */
+    longestCommonSubsequence(a, b) {
+        // For very large files, use a simpler approach
+        if (a.length > 1000 || b.length > 1000) {
+            return this.simpleLCS(a, b);
+        }
+        const m = a.length;
+        const n = b.length;
+        const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                if (a[i - 1] === b[j - 1]) {
+                    dp[i][j] = dp[i - 1][j - 1] + 1;
+                }
+                else {
+                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+                }
+            }
+        }
+        // Backtrack
+        const result = [];
+        let i = m, j = n;
+        while (i > 0 && j > 0) {
+            if (a[i - 1] === b[j - 1]) {
+                result.unshift(a[i - 1]);
+                i--;
+                j--;
+            }
+            else if (dp[i - 1][j] > dp[i][j - 1]) {
+                i--;
+            }
+            else {
+                j--;
+            }
+        }
+        return result;
+    }
+    /**
+     * Simple LCS for large files - uses hash-based matching
+     */
+    simpleLCS(a, b) {
+        const bMap = new Map();
+        for (let i = 0; i < b.length; i++) {
+            const positions = bMap.get(b[i]) || [];
+            positions.push(i);
+            bMap.set(b[i], positions);
+        }
+        const result = [];
+        let lastMatchB = -1;
+        for (let i = 0; i < a.length; i++) {
+            const positions = bMap.get(a[i]);
+            if (positions) {
+                // Find earliest position after lastMatchB
+                for (const pos of positions) {
+                    if (pos > lastMatchB) {
+                        result.push(a[i]);
+                        lastMatchB = pos;
+                        break;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    markDiscarded(id) {
+        this.discardedIds.add(id);
+    }
+    async startCheckpoint(params) {
+        if (!this.currentChatId) {
+            return null;
+        }
+        const checkpointId = this.generateCheckpointId();
+        const checkpointDir = path.join(this.getChatDir(), checkpointId);
+        const snapshotDir = path.join(checkpointDir, 'snapshot');
+        const manifestPath = path.join(checkpointDir, 'manifest.json');
+        try {
+            this.ensureDirSync(snapshotDir);
+            // Use remote snapshot when a handler is provided (SSH/WSL/Docker sessions)
+            const isRemote = params.contextType !== 'local' && params.handler;
+            const manifest = isRemote
+                ? await this.createRemoteSnapshot(params.cwd, snapshotDir, params.handler)
+                : await this.createSnapshot(params.cwd, snapshotDir);
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+            const meta = {
+                id: checkpointId,
+                prompt: params.prompt,
+                createdAt: new Date().toISOString(),
+                createdAtMs: Date.now(),
+                cwd: params.cwd,
+                contextType: params.contextType,
+                remoteSessionInfo: params.remoteSessionInfo,
+                conversationIndex: params.conversationIndex,
+                uiMessageIndex: params.uiMessageIndex,
+                uiMessageId: params.uiMessageId,
+                snapshotDir,
+                manifestPath,
+                commands: [],
+                toolCalls: [],
+                status: 'active',
+            };
+            this.checkpoints.push(meta);
+            this.saveIndex();
+            return meta;
+        }
+        catch (error) {
+            logError('Failed to create checkpoint snapshot', error);
+            return null;
+        }
+    }
+    async finalizeCheckpoint(id) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === id);
+        if (!checkpoint)
+            return;
+        if (this.discardedIds.has(id)) {
+            this.discardCheckpoint(id);
+            return;
+        }
+        try {
+            const changes = await this.calculateChanges(checkpoint);
+            checkpoint.changes = changes;
+            checkpoint.status = 'finalized';
+            this.saveIndex();
+        }
+        catch (error) {
+            logWarning(`Failed to finalize checkpoint ${id}: ${error.message}`);
+        }
+    }
+    recordToolCall(id, toolCall) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === id);
+        if (!checkpoint || checkpoint.status === 'discarded')
+            return;
+        if (toolCall.id && checkpoint.toolCalls.some(tc => tc.id === toolCall.id)) {
+            return;
+        }
+        checkpoint.toolCalls.push(toolCall);
+        if (toolCall.name === 'execute_command') {
+            const command = toolCall.arguments?.CommandLine || toolCall.arguments?.command;
+            const isShellInput = Boolean(toolCall.arguments?.shell_input);
+            if (command && !isShellInput) {
+                checkpoint.commands.push(String(command));
+            }
+        }
+        if (toolCall.name === 'background_command') {
+            const command = toolCall.arguments?.command;
+            const action = toolCall.arguments?.action;
+            if (command && action === 'start') {
+                checkpoint.commands.push(String(command));
+            }
+        }
+        this.saveIndex();
+    }
+    async revertToCheckpoint(id, handler) {
+        const checkpoint = this.checkpoints.find(cp => cp.id === id);
+        if (!checkpoint) {
+            throw new Error(`Checkpoint "${id}" not found`);
+        }
+        // Remote checkpoint requires a connected handler to revert
+        if (checkpoint.contextType !== 'local') {
+            if (!handler || !handler.isConnected()) {
+                const sessionType = checkpoint.contextType.toUpperCase();
+                const sessionInfo = checkpoint.remoteSessionInfo;
+                const target = sessionInfo?.connectionString || sessionInfo?.hostname || 'the remote machine';
+                throw new Error(`This checkpoint was created during a ${sessionType} session (${target}). ` +
+                    `You are not currently connected to that session. Please reconnect to the ${sessionType} session first, then retry /revert.`);
+            }
+            return this.revertRemoteCheckpoint(checkpoint, handler);
+        }
+        // Local revert (original logic)
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        const manifestSet = new Set(manifest.files.map(file => file.path));
+        const currentFiles = await this.scanFiles(checkpoint.cwd);
+        const errors = [];
+        let removed = 0;
+        for (const filePath of currentFiles) {
+            if (!manifestSet.has(filePath)) {
+                const absolutePath = path.join(checkpoint.cwd, filePath);
+                try {
+                    this.removeFileOrDirSync(absolutePath);
+                    removed++;
+                }
+                catch (error) {
+                    errors.push(`Failed to remove ${filePath}: ${error.message}`);
+                }
+            }
+        }
+        let restored = 0;
+        for (const file of manifest.files) {
+            const sourcePath = path.join(checkpoint.snapshotDir, file.path);
+            const targetPath = path.join(checkpoint.cwd, file.path);
+            try {
+                this.ensureDirSync(path.dirname(targetPath));
+                this.removeFileOrDirSync(targetPath);
+                fs.copyFileSync(sourcePath, targetPath);
+                restored++;
+            }
+            catch (error) {
+                errors.push(`Failed to restore ${file.path}: ${error.message}`);
+            }
+        }
+        return { checkpoint, restored, removed, errors };
+    }
+    /**
+     * Revert a remote checkpoint by uploading snapshot files back to the remote machine.
+     */
+    async revertRemoteCheckpoint(checkpoint, handler) {
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        const manifestSet = new Set(manifest.files.map(file => file.path));
+        const currentFiles = await this.scanRemoteFiles(checkpoint.cwd, handler);
+        const errors = [];
+        // Remove files that were added after the checkpoint
+        let removed = 0;
+        for (const filePath of currentFiles) {
+            if (!manifestSet.has(filePath)) {
+                const remotePath = checkpoint.cwd + '/' + filePath;
+                try {
+                    const result = await handler.executeCommand(`rm -f "${remotePath}"`);
+                    if (result.exitCode === 0) {
+                        removed++;
+                    }
+                    else {
+                        errors.push(`Failed to remove ${filePath}: ${result.stderr}`);
+                    }
+                }
+                catch (error) {
+                    errors.push(`Failed to remove ${filePath}: ${error.message}`);
+                }
+            }
+        }
+        // Restore files from the snapshot
+        let restored = 0;
+        for (const file of manifest.files) {
+            const localSnapshotPath = path.join(checkpoint.snapshotDir, file.path);
+            const remotePath = checkpoint.cwd + '/' + file.path;
+            try {
+                // Read the snapshot content from local storage
+                const content = fs.readFileSync(localSnapshotPath, 'utf-8');
+                // Ensure remote directory exists
+                const remoteDir = remotePath.substring(0, remotePath.lastIndexOf('/'));
+                await handler.executeCommand(`mkdir -p "${remoteDir}"`);
+                // Write the file back to the remote machine
+                await handler.writeFile(remotePath, content);
+                restored++;
+            }
+            catch (error) {
+                errors.push(`Failed to restore ${file.path}: ${error.message}`);
+            }
+        }
+        return { checkpoint, restored, removed, errors };
+    }
+    removeCheckpointsFrom(id) {
+        const index = this.checkpoints.findIndex(cp => cp.id === id);
+        if (index === -1)
+            return;
+        // Remove checkpoints FROM the given checkpoint (INCLUDING the checkpoint itself)
+        // This is used during revert - the reverted checkpoint is also removed
+        // because the user will re-submit the prompt
+        const toRemove = this.checkpoints.slice(index);
+        for (const checkpoint of toRemove) {
+            this.discardCheckpoint(checkpoint.id);
+        }
+    }
+    /**
+     * Discard a single checkpoint by id.
+     * Used when a background/late checkpoint should not be kept.
+     */
+    discardCheckpointById(id) {
+        this.discardCheckpoint(id);
+    }
+    deleteCheckpointsForChat(chatId) {
+        const chatDir = path.join(this.baseDir, chatId);
+        try {
+            if (fs.existsSync(chatDir)) {
+                fs.rmSync(chatDir, { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            logWarning(`Failed to delete checkpoints for chat ${chatId}: ${error.message}`);
+        }
+        if (this.currentChatId === chatId) {
+            this.clear();
+        }
+    }
+    discardCheckpoint(id) {
+        const checkpointIndex = this.checkpoints.findIndex(cp => cp.id === id);
+        if (checkpointIndex === -1)
+            return;
+        const [checkpoint] = this.checkpoints.splice(checkpointIndex, 1);
+        this.discardedIds.delete(id);
+        try {
+            if (fs.existsSync(path.dirname(checkpoint.manifestPath))) {
+                fs.rmSync(path.dirname(checkpoint.manifestPath), { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            logWarning(`Failed to delete checkpoint ${id}: ${error.message}`);
+        }
+        this.saveIndex();
+    }
+    async calculateChanges(checkpoint, handler) {
+        const manifest = this.readManifest(checkpoint.manifestPath);
+        const manifestSet = new Set(manifest.files.map(file => file.path));
+        // Use remote scanning when checkpoint is remote and handler is available
+        const isRemote = checkpoint.contextType !== 'local' && handler && handler.isConnected();
+        const currentFiles = isRemote
+            ? await this.scanRemoteFiles(checkpoint.cwd, handler)
+            : await this.scanFiles(checkpoint.cwd);
+        const currentSet = new Set(currentFiles);
+        const added = [];
+        const deleted = [];
+        const modified = [];
+        for (const filePath of currentFiles) {
+            if (!manifestSet.has(filePath)) {
+                added.push(filePath);
+            }
+        }
+        for (const file of manifest.files) {
+            if (!currentSet.has(file.path)) {
+                deleted.push(file.path);
+                continue;
+            }
+            if (isRemote) {
+                // For remote: read current file from remote and compare with local snapshot
+                try {
+                    const remotePath = checkpoint.cwd + '/' + file.path;
+                    const remoteContent = await handler.readFile(remotePath);
+                    const snapshotPath = path.join(checkpoint.snapshotDir, file.path);
+                    const snapshotContent = fs.readFileSync(snapshotPath, 'utf-8');
+                    if (remoteContent !== snapshotContent) {
+                        modified.push(file.path);
+                    }
+                }
+                catch {
+                    modified.push(file.path); // Assume modified if we can't read
+                }
+            }
+            else {
+                const currentPath = path.join(checkpoint.cwd, file.path);
+                const snapshotPath = path.join(checkpoint.snapshotDir, file.path);
+                if (this.filesDiffer(snapshotPath, currentPath)) {
+                    modified.push(file.path);
+                }
+            }
+        }
+        return { added, modified, deleted };
+    }
+    readManifest(manifestPath) {
+        const raw = fs.readFileSync(manifestPath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    async createSnapshot(cwd, snapshotDir) {
+        const files = await this.scanFiles(cwd);
+        const manifestEntries = [];
+        for (const filePath of files) {
+            const absolutePath = path.join(cwd, filePath);
+            try {
+                const stat = fs.statSync(absolutePath);
+                if (!stat.isFile())
+                    continue;
+                const snapshotPath = path.join(snapshotDir, filePath);
+                this.ensureDirSync(path.dirname(snapshotPath));
+                fs.copyFileSync(absolutePath, snapshotPath);
+                manifestEntries.push({
+                    path: filePath,
+                    size: stat.size,
+                    mtimeMs: stat.mtimeMs,
+                    mode: stat.mode,
+                });
+            }
+            catch (error) {
+                logWarning(`Failed to snapshot ${filePath}: ${error.message}`);
+            }
+        }
+        return {
+            version: 1,
+            createdAt: new Date().toISOString(),
+            cwd,
+            files: manifestEntries,
+        };
+    }
+    /**
+     * Create a snapshot of remote files by downloading them via the handler.
+     * Files are stored locally in the snapshot directory for later comparison/revert.
+     */
+    async createRemoteSnapshot(cwd, snapshotDir, handler) {
+        const files = await this.scanRemoteFiles(cwd, handler);
+        const manifestEntries = [];
+        for (const filePath of files) {
+            const remotePath = cwd + '/' + filePath;
+            try {
+                const content = await handler.readFile(remotePath);
+                const snapshotPath = path.join(snapshotDir, filePath);
+                this.ensureDirSync(path.dirname(snapshotPath));
+                fs.writeFileSync(snapshotPath, content, 'utf-8');
+                const contentBuffer = Buffer.from(content, 'utf-8');
+                manifestEntries.push({
+                    path: filePath,
+                    size: contentBuffer.length,
+                    mtimeMs: Date.now(),
+                    mode: 0o644,
+                });
+            }
+            catch (error) {
+                logWarning(`Failed to snapshot remote file ${filePath}: ${error.message}`);
+            }
+        }
+        return {
+            version: 1,
+            createdAt: new Date().toISOString(),
+            cwd,
+            files: manifestEntries,
+        };
+    }
+    async scanFiles(cwd) {
+        const files = await fg(['**/*'], {
+            cwd,
+            dot: true,
+            onlyFiles: true,
+            followSymbolicLinks: false,
+            unique: true,
+            ignore: DEFAULT_IGNORE_PATTERNS,
+        });
+        return files.map((file) => file.replace(/\\/g, '/'));
+    }
+    /**
+     * Scan files on a remote machine using the handler's executeCommand.
+     * Uses `find` with ignore patterns equivalent to DEFAULT_IGNORE_PATTERNS.
+     */
+    async scanRemoteFiles(cwd, handler) {
+        // Build find command with exclusion patterns matching DEFAULT_IGNORE_PATTERNS
+        const excludeDirs = [
+            '.git', 'node_modules', 'dist', 'build', 'out',
+            '.next', '.turbo', '.cache', 'coverage',
+            '__pycache__', '.venv', 'venv', '.idea', '.vscode', '.centaurus',
+        ];
+        const excludeFiles = ['.DS_Store', 'Thumbs.db'];
+        const pruneArgs = excludeDirs.map(d => `-name "${d}" -prune`).join(' -o ');
+        const notFileArgs = excludeFiles.map(f => `! -name "${f}"`).join(' ');
+        // find <cwd> ( -name .git -prune -o ... ) -o -type f ! -name .DS_Store ... -print
+        const findCmd = `find "${cwd}" \\( ${pruneArgs} \\) -o -type f ${notFileArgs} -print 2>/dev/null`;
+        try {
+            const result = await handler.executeCommand(findCmd);
+            if (result.exitCode !== 0 && !result.stdout.trim()) {
+                logWarning(`Remote file scan failed: ${result.stderr}`);
+                return [];
+            }
+            const cwdPrefix = cwd.endsWith('/') ? cwd : cwd + '/';
+            return result.stdout
+                .split('\n')
+                .map(line => line.trim())
+                .filter(line => line.length > 0 && line.startsWith(cwdPrefix))
+                .map(line => line.substring(cwdPrefix.length))
+                .filter(relPath => relPath.length > 0);
+        }
+        catch (error) {
+            logWarning(`Failed to scan remote files: ${error.message}`);
+            return [];
+        }
+    }
+    filesDiffer(snapshotPath, currentPath) {
+        try {
+            const snapStat = fs.statSync(snapshotPath);
+            const currStat = fs.statSync(currentPath);
+            if (snapStat.size !== currStat.size) {
+                return true;
+            }
+            const snapBuffer = fs.readFileSync(snapshotPath);
+            const currBuffer = fs.readFileSync(currentPath);
+            if (snapBuffer.length !== currBuffer.length) {
+                return true;
+            }
+            return !snapBuffer.equals(currBuffer);
+        }
+        catch {
+            return true;
+        }
+    }
+    removeFileOrDirSync(targetPath) {
+        if (!fs.existsSync(targetPath))
+            return;
+        const stat = fs.lstatSync(targetPath);
+        if (stat.isDirectory()) {
+            fs.rmSync(targetPath, { recursive: true, force: true });
+            return;
+        }
+        fs.rmSync(targetPath, { force: true });
+    }
+    generateCheckpointId() {
+        const timestamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '');
+        const random = Math.random().toString(36).substring(2, 6);
+        return `cp-${timestamp}-${random}`;
+    }
+    ensureDirSync(dirPath) {
+        if (!fs.existsSync(dirPath)) {
+            fs.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    getChatDir() {
+        if (!this.currentChatId) {
+            return this.baseDir;
+        }
+        const dir = path.join(this.baseDir, this.currentChatId);
+        this.ensureDirSync(dir);
+        return dir;
+    }
+    getIndexPath() {
+        if (!this.currentChatId)
+            return null;
+        return path.join(this.getChatDir(), 'index.json');
+    }
+    loadIndex() {
+        this.checkpoints = [];
+        this.discardedIds.clear();
+        const indexPath = this.getIndexPath();
+        if (!indexPath || !fs.existsSync(indexPath)) {
+            return;
+        }
+        try {
+            const raw = fs.readFileSync(indexPath, 'utf-8');
+            const data = JSON.parse(raw);
+            this.checkpoints = data.filter(entry => fs.existsSync(entry.manifestPath));
+        }
+        catch (error) {
+            logWarning(`Failed to load checkpoint index: ${error.message}`);
+        }
+    }
+    saveIndex() {
+        const indexPath = this.getIndexPath();
+        if (!indexPath)
+            return;
+        try {
+            fs.writeFileSync(indexPath, JSON.stringify(this.checkpoints, null, 2), 'utf-8');
+        }
+        catch (error) {
+            logWarning(`Failed to save checkpoint index: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=checkpoint-manager.js.map