attocode 0.1.0

package/dist/src/integrations/file-change-tracker.d.ts

@@ -0,0 +1,161 @@
+/**
+ * File Change Tracker
+ *
+ * Tracks file changes for undo capability in agent sessions.
+ * Provides before/after content capture, diff generation, and undo functionality.
+ *
+ * @example
+ * ```typescript
+ * import Database from 'better-sqlite3';
+ * import { FileChangeTracker } from './file-change-tracker.js';
+ *
+ * const db = new Database('sessions.db');
+ * const tracker = new FileChangeTracker(db, 'session-123');
+ *
+ * // Record a file change
+ * const changeId = await tracker.recordChange({
+ *   filePath: '/path/to/file.ts',
+ *   operation: 'edit',
+ *   contentBefore: 'old content',
+ *   contentAfter: 'new content',
+ *   turnNumber: 1,
+ * });
+ *
+ * // Undo the change
+ * const result = await tracker.undoChange(changeId);
+ * ```
+ */
+import Database from 'better-sqlite3';
+/**
+ * Configuration for FileChangeTracker.
+ */
+export interface FileChangeTrackerConfig {
+    /** Whether tracking is enabled (default: true) */
+    enabled?: boolean;
+    /** Maximum bytes for full content storage (default: 50KB). Above this, store diff only. */
+    maxFullContentBytes?: number;
+}
+/**
+ * Represents a file change record.
+ */
+export interface FileChange {
+    /** Unique change ID */
+    id: number;
+    /** Session this change belongs to */
+    sessionId: string;
+    /** Turn number when change occurred */
+    turnNumber: number;
+    /** Path to the changed file */
+    filePath: string;
+    /** Type of operation */
+    operation: 'create' | 'write' | 'edit' | 'delete';
+    /** Content before the change (null for creates) */
+    contentBefore: string | null;
+    /** Content after the change (null for deletes) */
+    contentAfter: string | null;
+    /** Unified diff (when using diff storage mode) */
+    diffUnified: string | null;
+    /** How content is stored */
+    storageMode: 'full' | 'diff';
+    /** Bytes before change */
+    bytesBefore: number;
+    /** Bytes after change */
+    bytesAfter: number;
+    /** Whether this change has been undone */
+    isUndone: boolean;
+    /** ID of the change that undid this one */
+    undoChangeId: number | null;
+    /** Tool call ID that made this change */
+    toolCallId: string | null;
+    /** ISO timestamp of when change was recorded */
+    createdAt: string;
+}
+/**
+ * Result of an undo operation.
+ */
+export interface UndoResult {
+    /** Whether the undo succeeded */
+    success: boolean;
+    /** Path to the affected file */
+    filePath: string;
+    /** Human-readable message */
+    message: string;
+    /** Change ID that was undone (if successful) */
+    changeId?: number;
+}
+/**
+ * Summary of changes in a session.
+ */
+export interface ChangeSummary {
+    /** Total number of changes */
+    totalChanges: number;
+    /** Number of active (non-undone) changes */
+    activeChanges: number;
+    /** Number of undone changes */
+    undoneChanges: number;
+    /** Files that were modified */
+    filesModified: string[];
+    /** Changes by operation type */
+    byOperation: {
+        create: number;
+        write: number;
+        edit: number;
+        delete: number;
+    };
+}
+/**
+ * Tracks file changes for undo capability.
+ */
+export declare class FileChangeTracker {
+    private db;
+    private sessionId;
+    private config;
+    private stmts;
+    constructor(db: Database.Database, sessionId: string, config?: FileChangeTrackerConfig);
+    /**
+     * Prepare SQL statements for reuse.
+     */
+    private prepareStatements;
+    /**
+     * Record a file change.
+     */
+    recordChange(params: {
+        filePath: string;
+        operation: 'create' | 'write' | 'edit' | 'delete';
+        contentBefore?: string;
+        contentAfter?: string;
+        turnNumber: number;
+        toolCallId?: string;
+    }): Promise<number>;
+    /**
+     * Undo a specific change by ID.
+     */
+    undoChange(changeId: number): Promise<UndoResult>;
+    /**
+     * Undo the last change to a specific file.
+     */
+    undoLastChange(filePath: string): Promise<UndoResult>;
+    /**
+     * Undo all changes in a turn.
+     */
+    undoTurn(turnNumber: number): Promise<UndoResult[]>;
+    /**
+     * Get all changes for a file.
+     */
+    getFileHistory(filePath: string): FileChange[];
+    /**
+     * Get all changes in session.
+     */
+    getChanges(options?: {
+        filePath?: string;
+    }): FileChange[];
+    /**
+     * Get session change summary.
+     */
+    getSessionChangeSummary(): ChangeSummary;
+}
+/**
+ * Create a FileChangeTracker instance.
+ */
+export declare function createFileChangeTracker(db: Database.Database, sessionId: string, config?: FileChangeTrackerConfig): FileChangeTracker;
+//# sourceMappingURL=file-change-tracker.d.ts.map

package/dist/src/integrations/file-change-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-change-tracker.d.ts","sourceRoot":"","sources":["../../../src/integrations/file-change-tracker.ts"],"names":[],"mappings":"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"}

package/dist/src/integrations/file-change-tracker.js

@@ -0,0 +1,520 @@
+/**
+ * File Change Tracker
+ *
+ * Tracks file changes for undo capability in agent sessions.
+ * Provides before/after content capture, diff generation, and undo functionality.
+ *
+ * @example
+ * ```typescript
+ * import Database from 'better-sqlite3';
+ * import { FileChangeTracker } from './file-change-tracker.js';
+ *
+ * const db = new Database('sessions.db');
+ * const tracker = new FileChangeTracker(db, 'session-123');
+ *
+ * // Record a file change
+ * const changeId = await tracker.recordChange({
+ *   filePath: '/path/to/file.ts',
+ *   operation: 'edit',
+ *   contentBefore: 'old content',
+ *   contentAfter: 'new content',
+ *   turnNumber: 1,
+ * });
+ *
+ * // Undo the change
+ * const result = await tracker.undoChange(changeId);
+ * ```
+ */
+import { writeFile, unlink } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+// =============================================================================
+// DIFF UTILITIES
+// =============================================================================
+/**
+ * Generate a simple unified diff between two strings.
+ * This is a basic implementation - for production, consider using a proper diff library.
+ */
+function generateUnifiedDiff(before, after, filePath) {
+    const beforeLines = before.split('\n');
+    const afterLines = after.split('\n');
+    const header = [
+        `--- a/${filePath}`,
+        `+++ b/${filePath}`,
+    ];
+    // Simple line-by-line diff (not optimal but functional)
+    const hunks = [];
+    let i = 0;
+    let j = 0;
+    while (i < beforeLines.length || j < afterLines.length) {
+        // Find next difference
+        const startI = i;
+        const startJ = j;
+        // Skip matching lines
+        while (i < beforeLines.length && j < afterLines.length && beforeLines[i] === afterLines[j]) {
+            i++;
+            j++;
+        }
+        // If we've found a difference or reached the end
+        if (i < beforeLines.length || j < afterLines.length) {
+            // Determine the hunk boundaries
+            const contextBefore = Math.max(0, i - 3);
+            const hunkStart = contextBefore + 1;
+            // Find the extent of the difference
+            const diffStartI = i;
+            const diffStartJ = j;
+            // Advance through differing lines
+            while (i < beforeLines.length || j < afterLines.length) {
+                if (i < beforeLines.length && j < afterLines.length && beforeLines[i] === afterLines[j]) {
+                    // Found a match - check if it's the end of the diff section
+                    let matchCount = 0;
+                    let tempI = i;
+                    let tempJ = j;
+                    while (tempI < beforeLines.length && tempJ < afterLines.length &&
+                        beforeLines[tempI] === afterLines[tempJ] && matchCount < 3) {
+                        matchCount++;
+                        tempI++;
+                        tempJ++;
+                    }
+                    if (matchCount >= 3) {
+                        break;
+                    }
+                }
+                if (i < beforeLines.length)
+                    i++;
+                if (j < afterLines.length)
+                    j++;
+            }
+            // Build the hunk
+            const hunkLines = [];
+            const beforeCount = i - contextBefore;
+            const afterCount = j - (startJ + (contextBefore - startI));
+            hunkLines.push(`@@ -${hunkStart},${beforeCount} +${hunkStart},${afterCount} @@`);
+            // Add context before
+            for (let k = contextBefore; k < diffStartI; k++) {
+                hunkLines.push(` ${beforeLines[k]}`);
+            }
+            // Add removed lines
+            for (let k = diffStartI; k < i; k++) {
+                if (k < beforeLines.length) {
+                    hunkLines.push(`-${beforeLines[k]}`);
+                }
+            }
+            // Add added lines
+            for (let k = diffStartJ; k < j; k++) {
+                if (k < afterLines.length) {
+                    hunkLines.push(`+${afterLines[k]}`);
+                }
+            }
+            hunks.push(hunkLines.join('\n'));
+        }
+    }
+    return [...header, ...hunks].join('\n');
+}
+/**
+ * Apply a unified diff to restore original content.
+ * Returns the original content before the diff was applied.
+ */
+function applyReverseDiff(currentContent, diff) {
+    // Parse diff hunks
+    const lines = diff.split('\n');
+    const resultLines = currentContent.split('\n');
+    let lineIndex = 0;
+    let i = 0;
+    // Skip header lines
+    while (i < lines.length && !lines[i].startsWith('@@')) {
+        i++;
+    }
+    while (i < lines.length) {
+        const line = lines[i];
+        if (line.startsWith('@@')) {
+            // Parse hunk header: @@ -start,count +start,count @@
+            const match = line.match(/@@ -(\d+),?\d* \+(\d+),?\d* @@/);
+            if (match) {
+                lineIndex = parseInt(match[2], 10) - 1;
+            }
+            i++;
+            continue;
+        }
+        if (line.startsWith('+')) {
+            // This was an addition - remove it to reverse
+            if (lineIndex < resultLines.length && resultLines[lineIndex] === line.slice(1)) {
+                resultLines.splice(lineIndex, 1);
+            }
+            i++;
+            continue;
+        }
+        if (line.startsWith('-')) {
+            // This was a removal - add it back to reverse
+            resultLines.splice(lineIndex, 0, line.slice(1));
+            lineIndex++;
+            i++;
+            continue;
+        }
+        if (line.startsWith(' ')) {
+            // Context line
+            lineIndex++;
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return resultLines.join('\n');
+}
+// =============================================================================
+// FILE CHANGE TRACKER
+// =============================================================================
+/**
+ * Tracks file changes for undo capability.
+ */
+export class FileChangeTracker {
+    db;
+    sessionId;
+    config;
+    stmts;
+    constructor(db, sessionId, config) {
+        this.db = db;
+        this.sessionId = sessionId;
+        this.config = {
+            enabled: config?.enabled ?? true,
+            maxFullContentBytes: config?.maxFullContentBytes ?? 50 * 1024, // 50KB
+        };
+        this.prepareStatements();
+    }
+    /**
+     * Prepare SQL statements for reuse.
+     */
+    prepareStatements() {
+        this.stmts = {
+            insertChange: this.db.prepare(`
+        INSERT INTO file_changes (
+          session_id, entry_id, tool_call_id, turn_number, file_path,
+          operation, content_before, content_after, diff_unified,
+          storage_mode, bytes_before, bytes_after, is_undone,
+          undo_change_id, created_at
+        )
+        VALUES (
+          @sessionId, @entryId, @toolCallId, @turnNumber, @filePath,
+          @operation, @contentBefore, @contentAfter, @diffUnified,
+          @storageMode, @bytesBefore, @bytesAfter, @isUndone,
+          @undoChangeId, @createdAt
+        )
+      `),
+            getChange: this.db.prepare(`
+        SELECT
+          id, session_id as sessionId, turn_number as turnNumber,
+          file_path as filePath, operation, content_before as contentBefore,
+          content_after as contentAfter, diff_unified as diffUnified,
+          storage_mode as storageMode, bytes_before as bytesBefore,
+          bytes_after as bytesAfter, is_undone as isUndone,
+          undo_change_id as undoChangeId, tool_call_id as toolCallId,
+          created_at as createdAt
+        FROM file_changes
+        WHERE id = ? AND session_id = ?
+      `),
+            getChanges: this.db.prepare(`
+        SELECT
+          id, session_id as sessionId, turn_number as turnNumber,
+          file_path as filePath, operation, content_before as contentBefore,
+          content_after as contentAfter, diff_unified as diffUnified,
+          storage_mode as storageMode, bytes_before as bytesBefore,
+          bytes_after as bytesAfter, is_undone as isUndone,
+          undo_change_id as undoChangeId, tool_call_id as toolCallId,
+          created_at as createdAt
+        FROM file_changes
+        WHERE session_id = ?
+        ORDER BY id ASC
+      `),
+            getFileChanges: this.db.prepare(`
+        SELECT
+          id, session_id as sessionId, turn_number as turnNumber,
+          file_path as filePath, operation, content_before as contentBefore,
+          content_after as contentAfter, diff_unified as diffUnified,
+          storage_mode as storageMode, bytes_before as bytesBefore,
+          bytes_after as bytesAfter, is_undone as isUndone,
+          undo_change_id as undoChangeId, tool_call_id as toolCallId,
+          created_at as createdAt
+        FROM file_changes
+        WHERE session_id = ? AND file_path = ?
+        ORDER BY id ASC
+      `),
+            getLastFileChange: this.db.prepare(`
+        SELECT
+          id, session_id as sessionId, turn_number as turnNumber,
+          file_path as filePath, operation, content_before as contentBefore,
+          content_after as contentAfter, diff_unified as diffUnified,
+          storage_mode as storageMode, bytes_before as bytesBefore,
+          bytes_after as bytesAfter, is_undone as isUndone,
+          undo_change_id as undoChangeId, tool_call_id as toolCallId,
+          created_at as createdAt
+        FROM file_changes
+        WHERE session_id = ? AND file_path = ? AND is_undone = 0
+        ORDER BY id DESC
+        LIMIT 1
+      `),
+            getTurnChanges: this.db.prepare(`
+        SELECT
+          id, session_id as sessionId, turn_number as turnNumber,
+          file_path as filePath, operation, content_before as contentBefore,
+          content_after as contentAfter, diff_unified as diffUnified,
+          storage_mode as storageMode, bytes_before as bytesBefore,
+          bytes_after as bytesAfter, is_undone as isUndone,
+          undo_change_id as undoChangeId, tool_call_id as toolCallId,
+          created_at as createdAt
+        FROM file_changes
+        WHERE session_id = ? AND turn_number = ? AND is_undone = 0
+        ORDER BY id DESC
+      `),
+            markUndone: this.db.prepare(`
+        UPDATE file_changes
+        SET is_undone = 1, undo_change_id = ?
+        WHERE id = ? AND session_id = ?
+      `),
+            getSessionSummary: this.db.prepare(`
+        SELECT
+          COUNT(*) as totalChanges,
+          SUM(CASE WHEN is_undone = 0 THEN 1 ELSE 0 END) as activeChanges,
+          SUM(CASE WHEN is_undone = 1 THEN 1 ELSE 0 END) as undoneChanges,
+          SUM(CASE WHEN operation = 'create' AND is_undone = 0 THEN 1 ELSE 0 END) as createCount,
+          SUM(CASE WHEN operation = 'write' AND is_undone = 0 THEN 1 ELSE 0 END) as writeCount,
+          SUM(CASE WHEN operation = 'edit' AND is_undone = 0 THEN 1 ELSE 0 END) as editCount,
+          SUM(CASE WHEN operation = 'delete' AND is_undone = 0 THEN 1 ELSE 0 END) as deleteCount
+        FROM file_changes
+        WHERE session_id = ?
+      `),
+        };
+    }
+    /**
+     * Record a file change.
+     */
+    async recordChange(params) {
+        if (!this.config.enabled) {
+            return -1;
+        }
+        const now = new Date().toISOString();
+        const contentBefore = params.contentBefore ?? null;
+        const contentAfter = params.contentAfter ?? null;
+        const bytesBefore = contentBefore ? Buffer.byteLength(contentBefore, 'utf-8') : 0;
+        const bytesAfter = contentAfter ? Buffer.byteLength(contentAfter, 'utf-8') : 0;
+        // Determine storage mode
+        let storageMode = 'full';
+        let diffUnified = null;
+        let storedBefore = contentBefore;
+        let storedAfter = contentAfter;
+        // Use diff mode for large files
+        const totalBytes = bytesBefore + bytesAfter;
+        if (totalBytes > this.config.maxFullContentBytes && contentBefore && contentAfter) {
+            storageMode = 'diff';
+            diffUnified = generateUnifiedDiff(contentBefore, contentAfter, params.filePath);
+            // In diff mode, we only store the after content (current state) and the diff
+            // to reconstruct the before content
+            storedBefore = null;
+            storedAfter = contentAfter;
+        }
+        const result = this.stmts.insertChange.run({
+            sessionId: this.sessionId,
+            entryId: null,
+            toolCallId: params.toolCallId ?? null,
+            turnNumber: params.turnNumber,
+            filePath: params.filePath,
+            operation: params.operation,
+            contentBefore: storedBefore,
+            contentAfter: storedAfter,
+            diffUnified,
+            storageMode,
+            bytesBefore,
+            bytesAfter,
+            isUndone: 0,
+            undoChangeId: null,
+            createdAt: now,
+        });
+        return result.lastInsertRowid;
+    }
+    /**
+     * Undo a specific change by ID.
+     */
+    async undoChange(changeId) {
+        const row = this.stmts.getChange.get(changeId, this.sessionId);
+        if (!row) {
+            return {
+                success: false,
+                filePath: '',
+                message: `Change ${changeId} not found`,
+            };
+        }
+        if (row.isUndone) {
+            return {
+                success: false,
+                filePath: row.filePath,
+                message: `Change ${changeId} has already been undone`,
+            };
+        }
+        const filePath = row.filePath;
+        try {
+            // Determine what content to restore
+            let contentToRestore = null;
+            if (row.storageMode === 'full') {
+                contentToRestore = row.contentBefore;
+            }
+            else if (row.storageMode === 'diff' && row.diffUnified && row.contentAfter) {
+                // Reconstruct the before content from the diff
+                contentToRestore = applyReverseDiff(row.contentAfter, row.diffUnified);
+            }
+            // Perform the undo based on operation type
+            switch (row.operation) {
+                case 'create':
+                    // Undo create = delete the file
+                    if (existsSync(filePath)) {
+                        await unlink(filePath);
+                    }
+                    break;
+                case 'write':
+                case 'edit':
+                    // Undo write/edit = restore previous content
+                    if (contentToRestore !== null) {
+                        await writeFile(filePath, contentToRestore, 'utf-8');
+                    }
+                    else if (row.operation === 'write') {
+                        // If no previous content for a write, delete the file
+                        if (existsSync(filePath)) {
+                            await unlink(filePath);
+                        }
+                    }
+                    break;
+                case 'delete':
+                    // Undo delete = recreate the file with original content
+                    if (contentToRestore !== null) {
+                        await writeFile(filePath, contentToRestore, 'utf-8');
+                    }
+                    break;
+            }
+            // Mark as undone (no undo change id since this isn't creating a new change record)
+            this.stmts.markUndone.run(null, changeId, this.sessionId);
+            return {
+                success: true,
+                filePath,
+                message: `Successfully undid ${row.operation} on ${filePath}`,
+                changeId,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                filePath,
+                message: `Failed to undo change: ${error instanceof Error ? error.message : String(error)}`,
+                changeId,
+            };
+        }
+    }
+    /**
+     * Undo the last change to a specific file.
+     */
+    async undoLastChange(filePath) {
+        const row = this.stmts.getLastFileChange.get(this.sessionId, filePath);
+        if (!row) {
+            return {
+                success: false,
+                filePath,
+                message: `No undoable changes found for ${filePath}`,
+            };
+        }
+        return this.undoChange(row.id);
+    }
+    /**
+     * Undo all changes in a turn.
+     */
+    async undoTurn(turnNumber) {
+        const rows = this.stmts.getTurnChanges.all(this.sessionId, turnNumber);
+        const results = [];
+        // Undo in reverse order (last change first)
+        for (const row of rows) {
+            const result = await this.undoChange(row.id);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Get all changes for a file.
+     */
+    getFileHistory(filePath) {
+        const rows = this.stmts.getFileChanges.all(this.sessionId, filePath);
+        return rows.map(row => ({
+            id: row.id,
+            sessionId: row.sessionId,
+            turnNumber: row.turnNumber,
+            filePath: row.filePath,
+            operation: row.operation,
+            contentBefore: row.contentBefore,
+            contentAfter: row.contentAfter,
+            diffUnified: row.diffUnified,
+            storageMode: row.storageMode,
+            bytesBefore: row.bytesBefore,
+            bytesAfter: row.bytesAfter,
+            isUndone: row.isUndone === 1,
+            undoChangeId: row.undoChangeId,
+            toolCallId: row.toolCallId,
+            createdAt: row.createdAt,
+        }));
+    }
+    /**
+     * Get all changes in session.
+     */
+    getChanges(options) {
+        if (options?.filePath) {
+            return this.getFileHistory(options.filePath);
+        }
+        const rows = this.stmts.getChanges.all(this.sessionId);
+        return rows.map(row => ({
+            id: row.id,
+            sessionId: row.sessionId,
+            turnNumber: row.turnNumber,
+            filePath: row.filePath,
+            operation: row.operation,
+            contentBefore: row.contentBefore,
+            contentAfter: row.contentAfter,
+            diffUnified: row.diffUnified,
+            storageMode: row.storageMode,
+            bytesBefore: row.bytesBefore,
+            bytesAfter: row.bytesAfter,
+            isUndone: row.isUndone === 1,
+            undoChangeId: row.undoChangeId,
+            toolCallId: row.toolCallId,
+            createdAt: row.createdAt,
+        }));
+    }
+    /**
+     * Get session change summary.
+     */
+    getSessionChangeSummary() {
+        const row = this.stmts.getSessionSummary.get(this.sessionId);
+        // Get unique file paths from active changes
+        const changes = this.getChanges();
+        const activeFiles = new Set();
+        for (const change of changes) {
+            if (!change.isUndone) {
+                activeFiles.add(change.filePath);
+            }
+        }
+        return {
+            totalChanges: row.totalChanges || 0,
+            activeChanges: row.activeChanges || 0,
+            undoneChanges: row.undoneChanges || 0,
+            filesModified: Array.from(activeFiles),
+            byOperation: {
+                create: row.createCount || 0,
+                write: row.writeCount || 0,
+                edit: row.editCount || 0,
+                delete: row.deleteCount || 0,
+            },
+        };
+    }
+}
+// =============================================================================
+// FACTORY
+// =============================================================================
+/**
+ * Create a FileChangeTracker instance.
+ */
+export function createFileChangeTracker(db, sessionId, config) {
+    return new FileChangeTracker(db, sessionId, config);
+}
+//# sourceMappingURL=file-change-tracker.js.map