undoai 0.1.0-beta.1 → 1.0.1

package/src/cli/commands/restore.ts

@@ -0,0 +1,222 @@
+import inquirer from 'inquirer';
+import { SnapshotManager } from '../../core/snapshot.js';
+import { Storage } from '../../core/storage.js';
+import { Logger } from '../../utils/logger.js';
+import path from 'path';
+import { minimatch } from 'minimatch';
+
+/**
+ * Format relative time
+ */
+function formatRelativeTime(timestamp: number): string {
+    const now = Date.now();
+    const diff = now - timestamp;
+
+    const seconds = Math.floor(diff / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+
+    if (days > 0) return `${days} day${days > 1 ? 's' : ''} ago`;
+    if (hours > 0) return `${hours} hour${hours > 1 ? 's' : ''} ago`;
+    if (minutes > 0) return `${minutes} min${minutes > 1 ? 's' : ''} ago`;
+    return 'just now';
+}
+
+interface RestoreOptions {
+    interactive?: boolean;
+    files?: string;
+    pattern?: string;
+}
+
+/**
+ * Restore command - restore files from a snapshot
+ */
+export async function restoreCommand(options: RestoreOptions = {}): Promise<void> {
+    // Initialize storage if needed
+    if (!Storage.isInitialized()) {
+        Logger.error('No snapshots found. Start watching with "undoai watch" first.');
+        process.exit(1);
+    }
+
+    // Get current directory
+    const projectRoot = process.cwd();
+    const snapshotManager = new SnapshotManager(projectRoot);
+
+    // List available snapshots
+    const snapshots = snapshotManager.listSnapshots();
+
+    // Filter out empty snapshots (snapshots with 0 files)
+    const validSnapshots = snapshots.filter(s => s.metadata.fileCount > 0);
+
+    if (validSnapshots.length === 0) {
+        Logger.error('No snapshots available');
+        Logger.info('Start watching with "undoai watch" to create snapshots');
+        process.exit(1);
+    }
+
+    console.log('');
+    Logger.info('Available snapshots:');
+    console.log('');
+
+    // Create choices for inquirer
+    const choices = validSnapshots.map((snapshot: { id: string; metadata: any }, index: number) => {
+        const { id, metadata } = snapshot;
+        const relativeTime = formatRelativeTime(metadata.timestamp);
+        const label = metadata.label === 'AI_BURST' ? '🤖 AI' : '📝 Auto';
+
+        return {
+            name: `${index + 1}. [${relativeTime}]  ${metadata.fileCount} file${metadata.fileCount > 1 ? 's' : ''}  ${label}`,
+            value: id,
+            short: `Snapshot ${index + 1}`,
+        };
+    });
+
+    // Add cancel option
+    choices.push({
+        name: '❌ Cancel',
+        value: 'CANCEL',
+        short: 'Cancel',
+    });
+
+    // Prompt user to select snapshot
+    const { snapshotId } = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'snapshotId',
+            message: 'Which snapshot do you want to restore?',
+            choices,
+            pageSize: 10,
+        },
+    ]);
+
+    if (snapshotId === 'CANCEL') {
+        Logger.info('Restore cancelled');
+        process.exit(0);
+    }
+
+    // Get snapshot details
+    const snapshot = snapshotManager.getSnapshot(snapshotId);
+    if (!snapshot) {
+        Logger.error('Snapshot not found');
+        process.exit(1);
+    }
+
+    // Determine which files to restore
+    let filesToRestore = snapshot.metadata.changedFiles;
+
+    // FEATURE: Pattern-based filtering
+    if (options.files) {
+        const fileList = options.files.split(',').map(f => f.trim());
+        filesToRestore = filesToRestore.filter((file: string) =>
+            fileList.some(pattern => minimatch(file, pattern))
+        );
+
+        if (filesToRestore.length === 0) {
+            Logger.error('No files match the specified pattern');
+            process.exit(1);
+        }
+
+        console.log('');
+        Logger.info(`Matched ${filesToRestore.length} files from pattern`);
+    }
+
+    // FEATURE: Interactive file selection
+    if (options.interactive) {
+        console.log('');
+        Logger.info('Select files to restore:');
+        console.log('');
+
+        const fileChoices = filesToRestore.map((file: string) => {
+            const relativePath = path.relative(projectRoot, file);
+            return {
+                name: relativePath,
+                value: file,
+                checked: false, // Default unchecked
+            };
+        });
+
+        const { selectedFiles } = await inquirer.prompt([
+            {
+                type: 'checkbox',
+                name: 'selectedFiles',
+                message: 'Select files (Space to select, Enter to confirm):',
+                choices: fileChoices,
+                pageSize: 15,
+                validate: (answer) => {
+                    if (answer.length === 0) {
+                        return 'You must select at least one file';
+                    }
+                    return true;
+                },
+            },
+        ]);
+
+        filesToRestore = selectedFiles;
+
+        if (filesToRestore.length === 0) {
+            Logger.info('No files selected');
+            process.exit(0);
+        }
+    }
+
+    // Show preview of what will be restored
+    console.log('');
+    Logger.info(`📋 Preview: ${filesToRestore.length} file${filesToRestore.length > 1 ? 's' : ''} will be restored`);
+    console.log('');
+
+    filesToRestore.slice(0, 10).forEach((file: string) => {
+        const relativePath = path.relative(projectRoot, file);
+        console.log(`  ✏️  ${relativePath}`);
+    });
+
+    if (filesToRestore.length > 10) {
+        console.log(`  ... and ${filesToRestore.length - 10} more`);
+    }
+
+    console.log('');
+    Logger.warn('⚠️  Current changes to these files will be overwritten');
+
+    // Confirm
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Continue with restore?',
+            default: true,
+        },
+    ]);
+
+    if (!confirm) {
+        Logger.info('Restore cancelled');
+        process.exit(0);
+    }
+
+    // Restore snapshot (selective or full)
+    try {
+        let restoredCount = 0;
+
+        if (options.interactive || options.files) {
+            // Selective restore
+            for (const file of filesToRestore) {
+                try {
+                    Storage.restoreFileFromSnapshot(file, snapshotId, projectRoot);
+                    restoredCount++;
+                } catch (error) {
+                    Logger.warn(`Failed to restore ${file}: ${error}`);
+                }
+            }
+        } else {
+            // Full restore
+            restoredCount = snapshotManager.restoreSnapshot(snapshotId);
+        }
+
+        console.log('');
+        Logger.success(`✅ Restored ${restoredCount} file${restoredCount > 1 ? 's' : ''}`);
+        Logger.dim(`From: ${formatRelativeTime(snapshot.metadata.timestamp)}`);
+    } catch (error) {
+        console.log('');
+        Logger.error(`Failed to restore: ${error}`);
+        process.exit(1);
+    }
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,51 @@
+import { DaemonManager } from '../../core/daemon.js';
+import { Storage, STORAGE_PATHS } from '../../core/storage.js';
+import { Logger } from '../../utils/logger.js';
+import chalk from 'chalk';
+
+/**
+ * Status command - show daemon status and info
+ */
+export async function statusCommand(): Promise<void> {
+    const isRunning = DaemonManager.isRunning();
+    const isInitialized = Storage.isInitialized();
+
+    console.log('');
+    Logger.bold('undoai Status');
+    console.log('');
+
+    // Daemon status
+    if (isRunning) {
+        const pid = DaemonManager.getPid();
+        console.log(chalk.green('🟢 Running') + chalk.dim(` (PID: ${pid})`));
+    } else {
+        console.log(chalk.red('🔴 Not running'));
+    }
+
+    console.log('');
+
+    // Storage info
+    if (isInitialized) {
+        const snapshotIds = Storage.getSnapshotIds();
+        const snapshotCount = snapshotIds.length;
+        const storageSize = Storage.getStorageSize();
+
+        Logger.dim('💾 Storage:');
+        console.log(chalk.dim(`   Location: ${STORAGE_PATHS.root}`));
+        console.log(chalk.dim(`   Snapshots: ${snapshotCount}`));
+        console.log(chalk.dim(`   Size: ${Storage.formatBytes(storageSize)}`));
+    } else {
+        Logger.dim('💾 Storage: Not initialized');
+        Logger.dim('   Run "undoai watch" to initialize');
+    }
+
+    console.log('');
+
+    // Show commands
+    Logger.dim('📝 Commands:');
+    console.log(chalk.dim('   undoai watch    - Start watching'));
+    console.log(chalk.dim('   undoai restore  - Restore snapshot'));
+    console.log(chalk.dim('   undoai stop     - Stop watching'));
+    console.log(chalk.dim('   undoai status   - Show this status'));
+    console.log('');
+}

package/src/cli/commands/stop.ts

@@ -0,0 +1,22 @@
+import { DaemonManager } from '../../core/daemon.js';
+import { Logger } from '../../utils/logger.js';
+
+/**
+ * Stop command - stop watching daemon
+ */
+export async function stopCommand(): Promise<void> {
+    if (!DaemonManager.isRunning()) {
+        Logger.error('undoai is not running');
+        Logger.info('Use "undoai watch" to start watching');
+        process.exit(1);
+    }
+
+    const stopped = DaemonManager.stop();
+
+    if (stopped) {
+        Logger.success('undoai stopped');
+    } else {
+        Logger.error('Failed to stop undoai');
+        process.exit(1);
+    }
+}

package/src/cli/commands/watch.ts

@@ -0,0 +1,162 @@
+import { FileWatcher } from '../../watcher.js';
+import { SnapshotManager } from '../../core/snapshot.js';
+import { Storage, STORAGE_PATHS } from '../../core/storage.js';
+import { DaemonManager } from '../../core/daemon.js';
+import { Logger } from '../../utils/logger.js';
+import path from 'path';
+import { minimatch } from 'minimatch';
+
+/**
+ * Important file patterns that should trigger snapshot even if only 1 file changed
+ */
+const IMPORTANT_FILE_PATTERNS = [
+    '.env',
+    '.env.*',
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'tsconfig.json',
+    'jsconfig.json',
+    '**/*.prisma',
+    '**/schema.prisma',
+    '**/migrations/**',
+    'Dockerfile',
+    'docker-compose.yml',
+    'docker-compose.*.yml',
+    '.github/workflows/**',
+    '.gitlab-ci.yml',
+    'Jenkinsfile',
+];
+
+/**
+ * Check if file is important (should trigger snapshot even if single file)
+ */
+function isImportantFile(filePath: string, projectRoot: string): boolean {
+    const relativePath = path.relative(projectRoot, filePath);
+    return IMPORTANT_FILE_PATTERNS.some(pattern => minimatch(relativePath, pattern));
+}
+
+/**
+ * Smart detection: should we create snapshot?
+ */
+function shouldCreateSnapshot(
+    changedFiles: Set<string>,
+    projectRoot: string,
+    timeDiff?: number
+): { should: boolean; reason: string } {
+    const fileCount = changedFiles.size;
+
+    // Priority 1: Burst detection (≥3 files)
+    if (fileCount >= 3) {
+        return { should: true, reason: `Burst detected (${fileCount} files)` };
+    }
+
+    // Priority 2: Important file changed (even if 1 file)
+    const hasImportant = Array.from(changedFiles).some(file =>
+        isImportantFile(file, projectRoot)
+    );
+    if (hasImportant) {
+        return { should: true, reason: 'Important file changed' };
+    }
+
+    // Priority 3: Velocity-based AI detection
+    if (timeDiff && fileCount >= 2 && timeDiff < 1000) {
+        // 2+ files in < 1 second = likely AI
+        return { should: true, reason: 'High velocity change (likely AI)' };
+    }
+
+    return { should: false, reason: 'Below threshold' };
+}
+
+/**
+ * Watch command - start watching for file changes
+ */
+export async function watchCommand(): Promise<void> {
+    // Check if already running
+    if (DaemonManager.isRunning()) {
+        Logger.error('undoai is already watching');
+        Logger.info('Use "undoai stop" to stop watching');
+        process.exit(1);
+    }
+
+    // Initialize storage
+    Storage.init();
+
+    // Get current directory as project root
+    const projectRoot = process.cwd();
+
+    // Create snapshot manager
+    const snapshotManager = new SnapshotManager(projectRoot);
+
+    // Create initial snapshot if needed
+    const existingSnapshots = snapshotManager.listSnapshots();
+    if (existingSnapshots.length === 0) {
+        console.log('');
+        Logger.info('📸 Creating initial baseline snapshot...');
+        Logger.dim('This captures your current working state');
+
+        // We'll implement full initial snapshot in next iteration
+        // For now, just log that baseline will be created on first change
+        Logger.info('💡 Baseline will be created on first file change');
+        console.log('');
+    }
+
+    let lastChangeTime = Date.now();
+
+    // Create file watcher with smart detection
+    const watcher = new FileWatcher({
+        watchPath: projectRoot,
+        onBurstChange: (changedFiles: Set<string>) => {
+            const currentTime = Date.now();
+            const timeDiff = currentTime - lastChangeTime;
+            lastChangeTime = currentTime;
+
+            // Smart detection
+            const detection = shouldCreateSnapshot(changedFiles, projectRoot, timeDiff);
+
+            if (detection.should) {
+                // Create snapshot
+                try {
+                    const snapshotId = snapshotManager.createSnapshot(changedFiles, 'AI_BURST');
+                    Logger.snapshot(`Snapshot saved (${changedFiles.size} files changed)`);
+                    Logger.dim(`Reason: ${detection.reason}`);
+                    Logger.dim(`Snapshot ID: ${snapshotId}`);
+                } catch (error) {
+                    Logger.error(`Failed to create snapshot: ${error}`);
+                }
+            } else {
+                // Just log, no snapshot
+                Logger.dim(`${changedFiles.size} file(s) changed (${detection.reason})`);
+            }
+        },
+        burstThreshold: 3, // Lowered from 5 to 3
+        debounceDelay: 2000,
+    });
+
+    // Start watching
+    watcher.start();
+
+    // Mark daemon as running
+    DaemonManager.markAsRunning(process.pid);
+
+    // Display startup message
+    console.log('');
+    Logger.success('undoai is now watching');
+    Logger.dim(`📁 Project: ${projectRoot}`);
+    Logger.dim(`💾 Storage: ${STORAGE_PATHS.root}`);
+    Logger.dim(`🔒 100% local - your code never leaves this machine`);
+    console.log('');
+    Logger.info('🎯 Smart detection enabled:');
+    Logger.dim('  • ≥3 files changed = snapshot');
+    Logger.dim('  • Important files (.env, package.json, etc) = snapshot');
+    Logger.dim('  • High velocity changes = snapshot');
+    console.log('');
+    Logger.info('Watching for file changes... (Press Ctrl+C to stop)');
+    console.log('');
+
+    // Setup graceful shutdown
+    DaemonManager.setupShutdownHandlers(async () => {
+        await watcher.stop();
+    });
+}

package/src/cli/index.ts

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { watchCommand } from './commands/watch.js';
+import { restoreCommand } from './commands/restore.js';
+import { stopCommand } from './commands/stop.js';
+import { statusCommand } from './commands/status.js';
+
+const program = new Command();
+
+program
+    .name('undoai')
+    .description('Free, local undo button for AI coding')
+    .version('1.0.0');
+
+// Watch command
+program
+    .command('watch')
+    .description('Start watching for file changes')
+    .action(async () => {
+        await watchCommand();
+    });
+
+// Restore command
+program
+    .command('restore')
+    .description('Restore files from a snapshot')
+    .option('-i, --interactive', 'Select specific files to restore')
+    .option('-f, --files <patterns>', 'Restore specific files (comma-separated patterns)')
+    .option('-p, --pattern <glob>', 'Restore files matching glob pattern')
+    .action(async (options) => {
+        await restoreCommand(options);
+    });
+
+// Stop command
+program
+    .command('stop')
+    .description('Stop watching daemon')
+    .action(async () => {
+        await stopCommand();
+    });
+
+// Status command
+program
+    .command('status')
+    .description('Show undoai status')
+    .action(async () => {
+        await statusCommand();
+    });
+
+// Parse arguments
+program.parse();

package/src/core/daemon.ts

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import { spawn, ChildProcess } from 'child_process';
+import { STORAGE_PATHS } from './storage.js';
+
+/**
+ * Daemon process manager
+ */
+export class DaemonManager {
+    /**
+     * Check if daemon is running
+     */
+    static isRunning(): boolean {
+        if (!fs.existsSync(STORAGE_PATHS.daemonPid)) {
+            return false;
+        }
+
+        try {
+            const pid = parseInt(fs.readFileSync(STORAGE_PATHS.daemonPid, 'utf-8'));
+
+            // Check if process exists
+            process.kill(pid, 0);
+            return true;
+        } catch (error) {
+            // Process doesn't exist, clean up stale PID file
+            this.cleanupPidFile();
+            return false;
+        }
+    }
+
+    /**
+     * Get daemon PID
+     */
+    static getPid(): number | null {
+        if (!fs.existsSync(STORAGE_PATHS.daemonPid)) {
+            return null;
+        }
+
+        try {
+            return parseInt(fs.readFileSync(STORAGE_PATHS.daemonPid, 'utf-8'));
+        } catch (error) {
+            return null;
+        }
+    }
+
+    /**
+     * Save daemon PID
+     */
+    static savePid(pid: number): void {
+        fs.writeFileSync(STORAGE_PATHS.daemonPid, pid.toString(), 'utf-8');
+    }
+
+    /**
+     * Clean up PID file
+     */
+    static cleanupPidFile(): void {
+        if (fs.existsSync(STORAGE_PATHS.daemonPid)) {
+            fs.unlinkSync(STORAGE_PATHS.daemonPid);
+        }
+    }
+
+    /**
+     * Stop daemon process
+     */
+    static stop(): boolean {
+        const pid = this.getPid();
+
+        if (!pid) {
+            return false;
+        }
+
+        try {
+            process.kill(pid, 'SIGTERM');
+            this.cleanupPidFile();
+            return true;
+        } catch (error) {
+            // Process doesn't exist
+            this.cleanupPidFile();
+            return false;
+        }
+    }
+
+    /**
+     * Start daemon in background (for watch command)
+     * Note: This is called from the watch command itself
+     */
+    static markAsRunning(pid: number): void {
+        this.savePid(pid);
+    }
+
+    /**
+     * Setup graceful shutdown handlers
+     */
+    static setupShutdownHandlers(onShutdown: () => Promise<void>): void {
+        const shutdown = async (signal: string) => {
+            console.log(`\n\n👋 Received ${signal}, stopping watcher...`);
+            await onShutdown();
+            this.cleanupPidFile();
+            process.exit(0);
+        };
+
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+    }
+}