undoai 0.1.0-beta.1 → 1.0.1

package/src/core/snapshot.ts

@@ -0,0 +1,144 @@
+import { Storage, SnapshotMetadata } from './storage.js';
+
+/**
+ * Snapshot manager for creating and restoring snapshots
+ */
+export class SnapshotManager {
+    private projectRoot: string;
+
+    constructor(projectRoot: string) {
+        this.projectRoot = projectRoot;
+    }
+
+    /**
+     * Create a snapshot from changed files
+     */
+    createSnapshot(
+        changedFiles: Set<string>,
+        label: 'AI_BURST' | 'AUTO' = 'AI_BURST'
+    ): string {
+        // Generate snapshot ID (timestamp)
+        const timestamp = Date.now();
+        const snapshotId = timestamp.toString();
+
+        // Create snapshot directory
+        Storage.createSnapshotDir(snapshotId);
+
+        // Filter files: only snapshot files that still exist
+        // (skip deleted files to avoid ENOENT errors)
+        const fileArray = Array.from(changedFiles);
+        const existingFiles: string[] = [];
+        const skippedFiles: string[] = [];
+
+        for (const file of fileArray) {
+            if (Storage.fileExists(file)) {
+                try {
+                    Storage.copyFileToSnapshot(file, snapshotId, this.projectRoot);
+                    existingFiles.push(file);
+                } catch (error) {
+                    console.error(`Failed to copy file ${file}:`, error);
+                    skippedFiles.push(file);
+                }
+            } else {
+                // File was deleted before snapshot - skip it
+                skippedFiles.push(file);
+            }
+        }
+
+        // Create metadata with only successfully backed up files
+        const metadata: SnapshotMetadata = {
+            timestamp,
+            date: new Date(timestamp).toISOString(),
+            projectRoot: this.projectRoot,
+            changedFiles: existingFiles, // Only files that were actually saved
+            fileCount: existingFiles.length,
+            label,
+        };
+
+        // Save metadata
+        Storage.saveMetadata(snapshotId, metadata);
+
+        // Log summary if files were skipped
+        if (skippedFiles.length > 0) {
+            console.log(`⚠️  Skipped ${skippedFiles.length} deleted file(s)`);
+        }
+
+        return snapshotId;
+    }
+
+    /**
+     * Restore files from a snapshot
+     */
+    restoreSnapshot(snapshotId: string): number {
+        // Get metadata
+        const metadata = Storage.getSnapshotMetadata(snapshotId);
+
+        if (!metadata) {
+            throw new Error(`Snapshot ${snapshotId} not found`);
+        }
+
+        // Check if project root matches
+        if (metadata.projectRoot !== this.projectRoot) {
+            throw new Error(
+                `Snapshot was created in different project: ${metadata.projectRoot}`
+            );
+        }
+
+        // Restore all files
+        let restoredCount = 0;
+        for (const file of metadata.changedFiles) {
+            try {
+                Storage.restoreFileFromSnapshot(file, snapshotId, this.projectRoot);
+                restoredCount++;
+            } catch (error) {
+                console.error(`Failed to restore file ${file}:`, error);
+            }
+        }
+
+        return restoredCount;
+    }
+
+    /**
+     * List all available snapshots
+     */
+    listSnapshots(): Array<{ id: string; metadata: SnapshotMetadata }> {
+        const snapshotIds = Storage.getSnapshotIds();
+        const snapshots = [];
+
+        for (const id of snapshotIds) {
+            const metadata = Storage.getSnapshotMetadata(id);
+            if (metadata) {
+                snapshots.push({ id, metadata });
+            }
+        }
+
+        return snapshots;
+    }
+
+    /**
+     * Get snapshot details
+     */
+    getSnapshot(snapshotId: string): { id: string; metadata: SnapshotMetadata } | null {
+        const metadata = Storage.getSnapshotMetadata(snapshotId);
+
+        if (!metadata) {
+            return null;
+        }
+
+        return { id: snapshotId, metadata };
+    }
+
+    /**
+     * Delete a snapshot
+     */
+    deleteSnapshot(snapshotId: string): void {
+        Storage.deleteSnapshot(snapshotId);
+    }
+
+    /**
+     * Get snapshot count
+     */
+    getSnapshotCount(): number {
+        return Storage.getSnapshotIds().length;
+    }
+}

package/src/core/storage.ts

@@ -0,0 +1,250 @@
+import fs from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+import zlib from 'zlib';
+
+/**
+ * Storage paths configuration
+ */
+export const STORAGE_PATHS = {
+    root: path.join(homedir(), '.undoai'),
+    snapshots: path.join(homedir(), '.undoai', 'snapshots'),
+    daemonPid: path.join(homedir(), '.undoai', 'daemon.pid'),
+    config: path.join(homedir(), '.undoai', 'config.json'),
+} as const;
+
+/**
+ * Metadata for a snapshot
+ */
+export interface SnapshotMetadata {
+    timestamp: number;
+    date: string;
+    projectRoot: string;
+    changedFiles: string[];
+    fileCount: number;
+    label: 'AI_BURST' | 'AUTO';
+}
+
+/**
+ * Storage manager for undoai snapshots
+ */
+export class Storage {
+    /**
+     * Initialize storage directory structure
+     */
+    static init(): void {
+        // Create root directory
+        if (!fs.existsSync(STORAGE_PATHS.root)) {
+            fs.mkdirSync(STORAGE_PATHS.root, { recursive: true });
+        }
+
+        // Create snapshots directory
+        if (!fs.existsSync(STORAGE_PATHS.snapshots)) {
+            fs.mkdirSync(STORAGE_PATHS.snapshots, { recursive: true });
+        }
+    }
+
+    /**
+     * Check if storage is initialized
+     */
+    static isInitialized(): boolean {
+        return fs.existsSync(STORAGE_PATHS.root) && fs.existsSync(STORAGE_PATHS.snapshots);
+    }
+
+    /**
+     * Check if a file exists
+     */
+    static fileExists(filePath: string): boolean {
+        try {
+            return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+        } catch {
+            return false;
+        }
+    }
+
+
+    /**
+     * Get all snapshot IDs (sorted by timestamp, newest first)
+     */
+    static getSnapshotIds(): string[] {
+        if (!fs.existsSync(STORAGE_PATHS.snapshots)) {
+            return [];
+        }
+
+        const entries = fs.readdirSync(STORAGE_PATHS.snapshots, { withFileTypes: true });
+        const snapshotIds = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort((a, b) => parseInt(b) - parseInt(a)); // Newest first
+
+        return snapshotIds;
+    }
+
+    /**
+     * Get snapshot metadata
+     */
+    static getSnapshotMetadata(snapshotId: string): SnapshotMetadata | null {
+        const metadataPath = path.join(STORAGE_PATHS.snapshots, snapshotId, 'metadata.json');
+
+        if (!fs.existsSync(metadataPath)) {
+            return null;
+        }
+
+        try {
+            const content = fs.readFileSync(metadataPath, 'utf-8');
+            return JSON.parse(content);
+        } catch (error) {
+            console.error(`Failed to read metadata for snapshot ${snapshotId}:`, error);
+            return null;
+        }
+    }
+
+    /**
+     * Get snapshot directory path
+     */
+    static getSnapshotDir(snapshotId: string): string {
+        return path.join(STORAGE_PATHS.snapshots, snapshotId);
+    }
+
+    /**
+     * Get snapshot files directory path
+     */
+    static getSnapshotFilesDir(snapshotId: string): string {
+        return path.join(STORAGE_PATHS.snapshots, snapshotId, 'files');
+    }
+
+    /**
+     * Create a new snapshot directory
+     */
+    static createSnapshotDir(snapshotId: string): string {
+        const snapshotDir = this.getSnapshotDir(snapshotId);
+        const filesDir = this.getSnapshotFilesDir(snapshotId);
+
+        fs.mkdirSync(snapshotDir, { recursive: true });
+        fs.mkdirSync(filesDir, { recursive: true });
+
+        return snapshotDir;
+    }
+
+    /**
+     * Save snapshot metadata
+     */
+    static saveMetadata(snapshotId: string, metadata: SnapshotMetadata): void {
+        const metadataPath = path.join(STORAGE_PATHS.snapshots, snapshotId, 'metadata.json');
+        fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), 'utf-8');
+    }
+
+    /**
+     * Convert file path to safe filename (replace / with __)
+     * Example: /home/user/project/src/auth.ts -> src__auth.ts
+     */
+    static pathToSafeFilename(filePath: string, projectRoot: string): string {
+        const relativePath = path.relative(projectRoot, filePath);
+        return relativePath.replace(/\//g, '__').replace(/\\/g, '__');
+    }
+
+    /**
+     * Convert safe filename back to relative path
+     * Example: src__auth.ts -> src/auth.ts
+     */
+    static safeFilenameToPath(safeFilename: string): string {
+        return safeFilename.replace(/__/g, path.sep);
+    }
+
+    /**
+     * Copy file to snapshot with compression
+     */
+    static copyFileToSnapshot(
+        sourceFile: string,
+        snapshotId: string,
+        projectRoot: string
+    ): void {
+        const safeFilename = this.pathToSafeFilename(sourceFile, projectRoot);
+        const destPath = path.join(this.getSnapshotFilesDir(snapshotId), safeFilename + '.gz');
+
+        // Read, compress, and save file
+        const fileContent = fs.readFileSync(sourceFile);
+        const compressed = zlib.gzipSync(fileContent);
+        fs.writeFileSync(destPath, compressed);
+    }
+
+    /**
+     * Restore file from snapshot with decompression
+     */
+    static restoreFileFromSnapshot(
+        originalPath: string,
+        snapshotId: string,
+        projectRoot: string
+    ): void {
+        const safeFilename = this.pathToSafeFilename(originalPath, projectRoot);
+        const sourcePath = path.join(this.getSnapshotFilesDir(snapshotId), safeFilename + '.gz');
+
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Snapshot file not found: ${safeFilename}.gz`);
+        }
+
+        // Ensure target directory exists
+        const targetDir = path.dirname(originalPath);
+        if (!fs.existsSync(targetDir)) {
+            fs.mkdirSync(targetDir, { recursive: true });
+        }
+
+        // Decompress and restore file
+        const compressed = fs.readFileSync(sourcePath);
+        const decompressed = zlib.gunzipSync(compressed);
+        fs.writeFileSync(originalPath, decompressed);
+    }
+
+    /**
+     * Delete a snapshot
+     */
+    static deleteSnapshot(snapshotId: string): void {
+        const snapshotDir = this.getSnapshotDir(snapshotId);
+
+        if (fs.existsSync(snapshotDir)) {
+            fs.rmSync(snapshotDir, { recursive: true, force: true });
+        }
+    }
+
+    /**
+     * Get total storage size in bytes
+     */
+    static getStorageSize(): number {
+        if (!fs.existsSync(STORAGE_PATHS.snapshots)) {
+            return 0;
+        }
+
+        let totalSize = 0;
+
+        const calculateDirSize = (dirPath: string): void => {
+            const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+            for (const entry of entries) {
+                const fullPath = path.join(dirPath, entry.name);
+
+                if (entry.isDirectory()) {
+                    calculateDirSize(fullPath);
+                } else {
+                    const stats = fs.statSync(fullPath);
+                    totalSize += stats.size;
+                }
+            }
+        };
+
+        calculateDirSize(STORAGE_PATHS.snapshots);
+        return totalSize;
+    }
+
+    /**
+     * Format bytes to human readable string
+     */
+    static formatBytes(bytes: number): string {
+        if (bytes === 0) return '0 Bytes';
+
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+}

package/src/example.ts

@@ -0,0 +1,33 @@
+import { FileWatcher } from './watcher.js';
+
+/**
+ * Example usage of the FileWatcher
+ */
+function main() {
+    // Initialize the watcher
+    const watcher = new FileWatcher({
+        watchPath: process.cwd(), // Watch current directory
+        onBurstChange: (changedFiles) => {
+            console.log(`\n🔥 Burst detected! ${changedFiles.size} files changed:`);
+            changedFiles.forEach((file) => {
+                console.log(`  - ${file}`);
+            });
+        },
+        burstThreshold: 5,    // Trigger when ≥5 files change
+        debounceDelay: 2000,  // After 2000ms of no changes
+    });
+
+    // Start watching
+    console.log('👀 Watching for file changes...');
+    console.log('💡 Make changes to ≥5 files, then wait 2 seconds\n');
+    watcher.start();
+
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        console.log('\n\n👋 Stopping watcher...');
+        await watcher.stop();
+        process.exit(0);
+    });
+}
+
+main();

package/src/utils/logger.ts

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+
+/**
+ * Logger utility with colored output
+ */
+export class Logger {
+    /**
+     * Success message (green with checkmark)
+     */
+    static success(message: string): void {
+        console.log(chalk.green('✅ ' + message));
+    }
+
+    /**
+     * Error message (red with cross)
+     */
+    static error(message: string): void {
+        console.log(chalk.red('❌ ' + message));
+    }
+
+    /**
+     * Warning message (yellow with warning icon)
+     */
+    static warn(message: string): void {
+        console.log(chalk.yellow('⚠️  ' + message));
+    }
+
+    /**
+     * Info message (blue with info icon)
+     */
+    static info(message: string): void {
+        console.log(chalk.blue('ℹ️  ' + message));
+    }
+
+    /**
+     * Snapshot message (camera icon)
+     */
+    static snapshot(message: string): void {
+        console.log(chalk.cyan('📸 ' + message));
+    }
+
+    /**
+     * Watch message (eyes icon)
+     */
+    static watch(message: string): void {
+        console.log(chalk.magenta('👀 ' + message));
+    }
+
+    /**
+     * Plain message (no icon or color)
+     */
+    static plain(message: string): void {
+        console.log(message);
+    }
+
+    /**
+     * Dim/subtle message
+     */
+    static dim(message: string): void {
+        console.log(chalk.dim(message));
+    }
+
+    /**
+     * Bold message
+     */
+    static bold(message: string): void {
+        console.log(chalk.bold(message));
+    }
+}

package/src/watcher.ts

@@ -0,0 +1,163 @@
+import chokidar from 'chokidar';
+import { join } from 'path';
+
+/**
+ * Configuration options for the file watcher
+ */
+export interface WatcherOptions {
+    /** Directory to watch for file changes */
+    watchPath: string;
+    /** Callback triggered when burst threshold is met */
+    onBurstChange: (changedFiles: Set<string>) => void;
+    /** Minimum number of files that must change to trigger burst (default: 5) */
+    burstThreshold?: number;
+    /** Debounce delay in milliseconds (default: 2000ms) */
+    debounceDelay?: number;
+}
+
+/**
+ * File watcher that monitors directory changes and triggers callbacks
+ * when a burst of changes occurs (≥5 files, no changes for ≥2000ms)
+ */
+export class FileWatcher {
+    private watcher: chokidar.FSWatcher | null = null;
+    private changedFiles: Set<string> = new Set();
+    private debounceTimer: NodeJS.Timeout | null = null;
+
+    private readonly watchPath: string;
+    private readonly onBurstChange: (changedFiles: Set<string>) => void;
+    private readonly burstThreshold: number;
+    private readonly debounceDelay: number;
+
+    constructor(options: WatcherOptions) {
+        this.watchPath = options.watchPath;
+        this.onBurstChange = options.onBurstChange;
+        this.burstThreshold = options.burstThreshold ?? 5;
+        this.debounceDelay = options.debounceDelay ?? 2000;
+    }
+
+    /**
+     * Start watching the directory for file changes
+     */
+    public start(): void {
+        this.watcher = chokidar.watch(this.watchPath, {
+            // Watch configuration
+            persistent: true,
+            ignoreInitial: true, // Don't trigger events for existing files on startup
+
+            // Ignored paths - use glob patterns
+            ignored: [
+                '**/node_modules/**',
+                '**/.git/**',
+                '**/dist/**',
+                '**/build/**',
+                '**/_tmp_*',              // Temp files
+                '**/*.tmp',               // Temp extensions
+                '**/pnpm-lock.yaml.*',    // pnpm temp lock files
+                '**/package.json.*',      // npm/pnpm temp package files
+            ],
+        });
+
+        // Handle file addition
+        this.watcher.on('add', (filePath: string) => {
+            this.handleFileChange(filePath, 'add');
+        });
+
+        // Handle file modification
+        this.watcher.on('change', (filePath: string) => {
+            this.handleFileChange(filePath, 'change');
+        });
+
+        // Handle file deletion
+        this.watcher.on('unlink', (filePath: string) => {
+            this.handleFileChange(filePath, 'unlink');
+        });
+
+        // Handle file rename - chokidar treats this as unlink (old) + add (new)
+        // We handle both events separately, so no special handling needed
+        // The rename effectively becomes two separate events in our changedFiles Set
+
+        // Error handling
+        this.watcher.on('error', (error: Error) => {
+            console.error('Watcher error:', error);
+        });
+    }
+
+    /**
+     * Handle a file change event
+     * Debounce Logic:
+     * 1. Add the file path to the Set (automatically prevents duplicates)
+     * 2. Clear any existing debounce timer
+     * 3. Start a new timer
+     * 4. If timer expires (no new changes for debounceDelay ms):
+     *    - Check if we have ≥ burstThreshold unique files
+     *    - If yes, trigger the callback and reset the buffer
+     */
+    private handleFileChange(filePath: string, eventType: string): void {
+        // Debug: log individual file changes
+        console.log(`  📝 [${eventType}] ${filePath}`);
+
+        // Add file to the set of changed files (Set automatically prevents duplicates)
+        this.changedFiles.add(filePath);
+
+        // Clear the existing debounce timer if any
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+        }
+
+        // Start a new debounce timer
+        this.debounceTimer = setTimeout(() => {
+            // Timer expired - no new changes for debounceDelay ms
+
+            // ALWAYS trigger callback if there are ANY changes
+            // Let the callback (smart detection in watch.ts) decide whether to snapshot
+            if (this.changedFiles.size > 0) {
+                // Create a copy of the changed files set for the callback
+                const filesSnapshot = new Set(this.changedFiles);
+
+                // Clear the buffer before triggering callback
+                this.changedFiles.clear();
+
+                // Trigger callback - smart detection will decide if snapshot needed
+                this.onBurstChange(filesSnapshot);
+            }
+
+            // Clear the timer reference
+            this.debounceTimer = null;
+        }, this.debounceDelay);
+    }
+
+    /**
+     * Stop watching and clean up resources
+     */
+    public async stop(): Promise<void> {
+        // Clear any pending debounce timer
+        if (this.debounceTimer) {
+            clearTimeout(this.debounceTimer);
+            this.debounceTimer = null;
+        }
+
+        // Close the watcher
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+
+        // Clear the changed files buffer
+        this.changedFiles.clear();
+    }
+
+    /**
+     * Get the current count of changed files in the buffer
+     */
+    public getChangedFilesCount(): number {
+        return this.changedFiles.size;
+    }
+
+    /**
+     * Manually clear the changed files buffer
+     */
+    public clearBuffer(): void {
+        this.changedFiles.clear();
+    }
+}

package/test-1-burst.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+# Test 1: Burst Detection (3+ files)
+
+echo "🧪 Test 1: Burst Detection"
+echo "=========================="
+echo ""
+
+# Cleanup
+rm -f test-burst-*.ts 2>/dev/null
+
+echo "Creating 3 test files..."
+sleep 1
+
+# Create 3 files rapidly
+echo "export const test1 = 'hello';" > test-burst-1.ts
+echo "export const test2 = 'world';" > test-burst-2.ts
+echo "export const test3 = 'foo';" > test-burst-3.ts
+
+echo "✅ Created 3 files"
+echo ""
+echo "Wait 3 seconds for debounce..."
+sleep 3
+
+echo ""
+echo "📊 Check watcher output above for:"
+echo "   - Should see: 📸 Snapshot saved (3 files changed)"
+echo "   - Should see: Reason: Burst detected (3 files)"
+echo ""
+
+# Check snapshot created
+SNAPSHOT_COUNT=$(ls -1 ~/.undoai/snapshots/ 2>/dev/null | wc -l)
+echo "📁 Total snapshots: $SNAPSHOT_COUNT"
+echo ""
+
+echo "✅ Test 1 completed!"
+echo ""