driftdetect 0.1.7 → 0.2.1

package/dist/commands/watch.js

@@ -1,111 +1,411 @@
 /**
  * Drift Watch Command
  *
- * Real-time file watching with pattern detection.
- * Monitors file changes and reports violations as they happen.
+ * Real-time file watching with pattern detection and persistence.
+ * Monitors file changes, detects patterns, persists to store, and emits events.
+ *
+ * @requirements Phase 1 - Watch mode should persist patterns to store
+ * @requirements Phase 2 - Smart merge strategy for pattern updates
+ * @requirements Phase 3 - File-level tracking for incremental updates
  */
 import { Command } from 'commander';
 import * as fs from 'node:fs';
+import * as fsPromises from 'node:fs/promises';
 import * as path from 'node:path';
+import * as crypto from 'node:crypto';
 import chalk from 'chalk';
 import { createAllDetectorsArray } from 'driftdetect-detectors';
-/**
- * Format timestamp for output
- */
+import { PatternStore } from 'driftdetect-core';
+// ============================================================================
+// Constants
+// ============================================================================
+const DRIFT_DIR = '.drift';
+const FILE_MAP_PATH = 'index/file-map.json';
+const LOCK_FILE_PATH = 'index/.lock';
+const LOCK_TIMEOUT_MS = 10000; // 10 seconds max lock hold time
+const LOCK_RETRY_MS = 100; // Retry every 100ms
+const SUPPORTED_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.py', '.css', '.scss', '.json', '.md'];
+const IGNORE_PATTERNS = ['node_modules', '.git', 'dist', 'build', 'coverage', '.turbo', '.drift'];
+// ============================================================================
+// Utility Functions
+// ============================================================================
 function timestamp() {
     return chalk.gray(`[${new Date().toLocaleTimeString()}]`);
 }
+function generateFileHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+}
+function generateStablePatternId(category, subcategory, detectorId, patternId) {
+    const key = `${category}:${subcategory}:${detectorId}:${patternId}`;
+    return crypto.createHash('sha256').update(key).digest('hex').slice(0, 16);
+}
+function mapToPatternCategory(category) {
+    const mapping = {
+        'api': 'api',
+        'auth': 'auth',
+        'security': 'security',
+        'errors': 'errors',
+        'structural': 'structural',
+        'components': 'components',
+        'styling': 'styling',
+        'logging': 'logging',
+        'testing': 'testing',
+        'data-access': 'data-access',
+        'config': 'config',
+        'types': 'types',
+        'performance': 'performance',
+        'accessibility': 'accessibility',
+        'documentation': 'documentation',
+    };
+    return mapping[category] || 'structural';
+}
+async function fileExists(filePath) {
+    try {
+        await fsPromises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDir(dirPath) {
+    await fsPromises.mkdir(dirPath, { recursive: true });
+}
 /**
- * Scan a single file for violations
+ * Acquire a file lock for exclusive access to .drift directory
+ * Uses a simple lock file with PID and timestamp
  */
-async function scanFile(filePath, detectors, categories) {
-    const violations = [];
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const ext = path.extname(filePath).toLowerCase();
-        const cwd = process.cwd();
-        const relativePath = path.relative(cwd, filePath);
-        let language = 'typescript';
-        if (['.ts', '.tsx'].includes(ext))
-            language = 'typescript';
-        else if (['.js', '.jsx'].includes(ext))
-            language = 'javascript';
-        else if (['.py'].includes(ext))
-            language = 'python';
-        else if (['.css', '.scss'].includes(ext))
-            language = 'css';
-        else if (['.json'].includes(ext))
-            language = 'json';
-        else if (['.md'].includes(ext))
-            language = 'markdown';
-        // Check if test file
-        const isTestFile = /\.(test|spec)\.[jt]sx?$/.test(filePath) ||
-            filePath.includes('__tests__') ||
-            filePath.includes('/test/') ||
-            filePath.includes('/tests/');
-        // Check if type definition
-        const isTypeDefinition = ext === '.d.ts';
-        // Create minimal project context
-        const projectContext = {
-            rootDir: cwd,
-            files: [relativePath],
-            config: {},
-        };
-        // Run detectors
-        for (const detector of detectors) {
-            // Filter by category if specified
-            if (categories && !categories.includes(detector.category)) {
-                continue;
+async function acquireLock(rootDir, holder) {
+    const lockPath = path.join(rootDir, DRIFT_DIR, LOCK_FILE_PATH);
+    await ensureDir(path.dirname(lockPath));
+    const startTime = Date.now();
+    while (Date.now() - startTime < LOCK_TIMEOUT_MS) {
+        try {
+            // Check if lock exists and is stale
+            if (await fileExists(lockPath)) {
+                const content = await fsPromises.readFile(lockPath, 'utf-8');
+                const lockInfo = JSON.parse(content);
+                const lockAge = Date.now() - new Date(lockInfo.timestamp).getTime();
+                // If lock is older than timeout, it's stale - remove it
+                if (lockAge > LOCK_TIMEOUT_MS) {
+                    await fsPromises.unlink(lockPath);
+                }
+                else {
+                    // Lock is held by another process, wait and retry
+                    await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_MS));
+                    continue;
+                }
             }
-            // Check if detector supports this language
-            if (!detector.supportsLanguage(language)) {
+            // Try to create lock file exclusively
+            const lockInfo = {
+                pid: process.pid,
+                timestamp: new Date().toISOString(),
+                holder,
+            };
+            await fsPromises.writeFile(lockPath, JSON.stringify(lockInfo), { flag: 'wx' });
+            return true;
+        }
+        catch (error) {
+            const err = error;
+            if (err.code === 'EEXIST') {
+                // Lock file was created by another process, retry
+                await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_MS));
                 continue;
             }
-            try {
-                // Create full detection context
-                const context = {
-                    file: relativePath,
-                    content,
-                    ast: null,
-                    imports: [],
-                    exports: [],
-                    projectContext,
-                    language,
-                    extension: ext,
-                    isTestFile,
-                    isTypeDefinition,
-                };
-                const result = await detector.detect(context);
-                // Check for violations
-                if (result.violations && result.violations.length > 0) {
-                    for (const v of result.violations) {
-                        violations.push({
-                            file: filePath,
-                            line: v.range?.start?.line ?? 1,
-                            message: v.message,
-                            severity: v.severity,
-                            patternName: detector.name,
+            // Other error, fail
+            return false;
+        }
+    }
+    // Timeout waiting for lock
+    return false;
+}
+/**
+ * Release the file lock
+ */
+async function releaseLock(rootDir) {
+    const lockPath = path.join(rootDir, DRIFT_DIR, LOCK_FILE_PATH);
+    try {
+        // Only release if we own the lock
+        if (await fileExists(lockPath)) {
+            const content = await fsPromises.readFile(lockPath, 'utf-8');
+            const lockInfo = JSON.parse(content);
+            if (lockInfo.pid === process.pid) {
+                await fsPromises.unlink(lockPath);
+            }
+        }
+    }
+    catch {
+        // Ignore errors during release
+    }
+}
+/**
+ * Execute a function with file lock protection
+ */
+async function withLock(rootDir, holder, fn) {
+    const acquired = await acquireLock(rootDir, holder);
+    if (!acquired) {
+        throw new Error('Failed to acquire lock - another process may be writing');
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        await releaseLock(rootDir);
+    }
+}
+// ============================================================================
+// File Map Management (Phase 3)
+// ============================================================================
+async function loadFileMap(rootDir) {
+    const mapPath = path.join(rootDir, DRIFT_DIR, FILE_MAP_PATH);
+    if (await fileExists(mapPath)) {
+        try {
+            const content = await fsPromises.readFile(mapPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            // Corrupted file, start fresh
+        }
+    }
+    return {
+        version: '1.0.0',
+        files: {},
+        lastUpdated: new Date().toISOString(),
+    };
+}
+async function saveFileMap(rootDir, fileMap) {
+    const mapPath = path.join(rootDir, DRIFT_DIR, FILE_MAP_PATH);
+    await ensureDir(path.dirname(mapPath));
+    fileMap.lastUpdated = new Date().toISOString();
+    // Atomic write: write to temp file, then rename
+    const tempPath = `${mapPath}.tmp`;
+    await fsPromises.writeFile(tempPath, JSON.stringify(fileMap, null, 2));
+    await fsPromises.rename(tempPath, mapPath);
+}
+// ============================================================================
+// Pattern Detection
+// ============================================================================
+async function detectPatternsInFile(filePath, content, detectors, categories, rootDir) {
+    const patterns = [];
+    const violations = [];
+    const ext = path.extname(filePath).toLowerCase();
+    const relativePath = path.relative(rootDir, filePath);
+    let language = 'typescript';
+    if (['.ts', '.tsx'].includes(ext))
+        language = 'typescript';
+    else if (['.js', '.jsx'].includes(ext))
+        language = 'javascript';
+    else if (['.py'].includes(ext))
+        language = 'python';
+    else if (['.css', '.scss'].includes(ext))
+        language = 'css';
+    else if (['.json'].includes(ext))
+        language = 'json';
+    else if (['.md'].includes(ext))
+        language = 'markdown';
+    const isTestFile = /\.(test|spec)\.[jt]sx?$/.test(filePath) ||
+        filePath.includes('__tests__') ||
+        filePath.includes('/test/') ||
+        filePath.includes('/tests/');
+    const isTypeDefinition = ext === '.d.ts';
+    const projectContext = {
+        rootDir,
+        files: [relativePath],
+        config: {},
+    };
+    // Aggregate patterns by detector+patternId
+    const patternMap = new Map();
+    for (const detector of detectors) {
+        if (categories && !categories.includes(detector.category)) {
+            continue;
+        }
+        if (!detector.supportsLanguage(language)) {
+            continue;
+        }
+        try {
+            const context = {
+                file: relativePath,
+                content,
+                ast: null,
+                imports: [],
+                exports: [],
+                projectContext,
+                language,
+                extension: ext,
+                isTestFile,
+                isTypeDefinition,
+            };
+            const result = await detector.detect(context);
+            const info = detector.getInfo();
+            // Process matches (patterns)
+            if (result.patterns && result.patterns.length > 0) {
+                for (const match of result.patterns) {
+                    const key = `${info.category}:${info.subcategory}:${detector.id}:${match.patternId}`;
+                    if (!patternMap.has(key)) {
+                        patternMap.set(key, {
+                            patternId: match.patternId,
+                            detectorId: detector.id,
+                            category: info.category,
+                            subcategory: info.subcategory,
+                            name: info.name,
+                            description: info.description,
+                            confidence: match.confidence,
+                            locations: [],
                         });
                     }
+                    const pattern = patternMap.get(key);
+                    const loc = {
+                        file: relativePath,
+                        line: match.location?.line ?? 1,
+                        column: match.location?.column ?? 0,
+                    };
+                    if (match.location?.endLine !== undefined) {
+                        loc.endLine = match.location.endLine;
+                    }
+                    if (match.location?.endColumn !== undefined) {
+                        loc.endColumn = match.location.endColumn;
+                    }
+                    pattern.locations.push(loc);
                 }
             }
-            catch {
-                // Skip detector errors silently
+            // Process violations
+            if (result.violations && result.violations.length > 0) {
+                for (const v of result.violations) {
+                    violations.push({
+                        file: relativePath,
+                        line: v.range?.start?.line ?? 1,
+                        column: v.range?.start?.character ?? 0,
+                        endLine: v.range?.end?.line,
+                        endColumn: v.range?.end?.character,
+                        message: v.message,
+                        severity: v.severity,
+                        patternId: v.patternId,
+                        detectorId: detector.id,
+                    });
+                }
             }
         }
+        catch {
+            // Skip detector errors
+        }
     }
-    catch {
-        // File read error - skip
+    patterns.push(...patternMap.values());
+    return { patterns, violations };
+}
+// ============================================================================
+// Pattern Store Integration (Phase 1 & 2)
+// ============================================================================
+function mergePatternIntoStore(store, detected, violations, file) {
+    const stableId = generateStablePatternId(detected.category, detected.subcategory, detected.detectorId, detected.patternId);
+    const now = new Date().toISOString();
+    const existingPattern = store.get(stableId);
+    // Get violations for this pattern as outliers
+    const patternViolations = violations.filter(v => v.detectorId === detected.detectorId && v.patternId === detected.patternId);
+    const newOutliers = patternViolations.map(v => ({
+        file: v.file,
+        line: v.line,
+        column: v.column,
+        reason: v.message,
+        deviationScore: v.severity === 'error' ? 1.0 : v.severity === 'warning' ? 0.7 : 0.4,
+    }));
+    if (existingPattern) {
+        // Phase 2: Smart merge - update existing pattern
+        // Remove old locations from this file, add new ones
+        const otherFileLocations = existingPattern.locations.filter(loc => loc.file !== file);
+        const mergedLocations = [...otherFileLocations, ...detected.locations].slice(0, 100);
+        // Same for outliers - filter to only include required fields
+        const otherFileOutliers = existingPattern.outliers.filter(o => o.file !== file);
+        const mergedOutliers = [
+            ...otherFileOutliers,
+            ...newOutliers,
+        ];
+        // Update pattern preserving status
+        store.update(stableId, {
+            locations: mergedLocations,
+            outliers: mergedOutliers,
+            metadata: {
+                ...existingPattern.metadata,
+                lastSeen: now,
+            },
+            confidence: {
+                ...existingPattern.confidence,
+                score: Math.max(existingPattern.confidence.score, detected.confidence),
+            },
+        });
+    }
+    else {
+        // New pattern - add to store
+        const confidenceScore = Math.min(0.95, detected.confidence);
+        const newPattern = {
+            id: stableId,
+            category: mapToPatternCategory(detected.category),
+            subcategory: detected.subcategory,
+            name: detected.name,
+            description: detected.description,
+            detector: {
+                type: 'regex',
+                config: {
+                    detectorId: detected.detectorId,
+                    patternId: detected.patternId,
+                },
+            },
+            confidence: {
+                frequency: Math.min(1, detected.locations.length / 10),
+                consistency: 0.9,
+                age: 0,
+                spread: 1,
+                score: confidenceScore,
+                level: confidenceScore >= 0.85 ? 'high' : confidenceScore >= 0.65 ? 'medium' : confidenceScore >= 0.45 ? 'low' : 'uncertain',
+            },
+            locations: detected.locations.slice(0, 100),
+            outliers: newOutliers,
+            metadata: {
+                firstSeen: now,
+                lastSeen: now,
+                source: 'auto-detected',
+                tags: [detected.category, detected.subcategory],
+            },
+            severity: patternViolations.length > 0
+                ? (patternViolations.some(v => v.severity === 'error') ? 'error' : 'warning')
+                : 'info',
+            autoFixable: false,
+            status: 'discovered',
+        };
+        store.add(newPattern);
     }
-    return violations;
+    return stableId;
 }
-/**
- * Print violations to console
- */
-function printViolations(filePath, violations, verbose) {
+function removeFileFromStore(store, file) {
+    // Remove all locations and outliers for this file from all patterns
+    const allPatterns = store.getAll();
+    for (const pattern of allPatterns) {
+        const hasLocationsInFile = pattern.locations.some(loc => loc.file === file);
+        const hasOutliersInFile = pattern.outliers.some(o => o.file === file);
+        if (hasLocationsInFile || hasOutliersInFile) {
+            const newLocations = pattern.locations.filter(loc => loc.file !== file);
+            const newOutliers = pattern.outliers.filter(o => o.file !== file);
+            if (newLocations.length === 0 && newOutliers.length === 0) {
+                // Pattern has no more locations - delete it
+                store.delete(pattern.id);
+            }
+            else {
+                // Update pattern with remaining locations
+                store.update(pattern.id, {
+                    locations: newLocations,
+                    outliers: newOutliers,
+                });
+            }
+        }
+    }
+}
+// ============================================================================
+// Console Output
+// ============================================================================
+function printViolations(filePath, violations, patternsUpdated, verbose) {
     const relativePath = path.relative(process.cwd(), filePath);
     if (violations.length === 0) {
-        console.log(`${timestamp()} ${chalk.green('✓')} ${relativePath}`);
+        const patternInfo = patternsUpdated > 0 ? chalk.cyan(` (${patternsUpdated} patterns)`) : '';
+        console.log(`${timestamp()} ${chalk.green('✓')} ${relativePath}${patternInfo}`);
         return;
     }
     const errors = violations.filter(v => v.severity === 'error');
@@ -118,24 +418,25 @@ function printViolations(filePath, violations, verbose) {
             summary += ', ';
         summary += chalk.yellow(`${warnings.length} warning${warnings.length > 1 ? 's' : ''}`);
     }
-    console.log(`${timestamp()} ${chalk.red('✗')} ${relativePath} - ${summary}`);
+    const patternInfo = patternsUpdated > 0 ? chalk.cyan(` | ${patternsUpdated} patterns`) : '';
+    console.log(`${timestamp()} ${chalk.red('✗')} ${relativePath} - ${summary}${patternInfo}`);
     if (verbose) {
         for (const v of violations) {
             const icon = v.severity === 'error' ? chalk.red('●') : chalk.yellow('●');
             console.log(`    ${icon} Line ${v.line}: ${v.message}`);
-            console.log(`      ${chalk.gray(`[${v.patternName}]`)}`);
         }
     }
 }
-/**
- * Update AI context file
- */
-function updateContextFile(contextPath) {
+function updateContextFile(contextPath, stats) {
     try {
         const content = `# Drift Context (Auto-updated)
 
 Last updated: ${new Date().toISOString()}
 
+## Current Stats
+- Patterns tracked: ${stats.patterns}
+- Active violations: ${stats.violations}
+
 This file is auto-updated by \`drift watch\`.
 Run \`drift export --format ai-context\` for full pattern details.
 
@@ -143,6 +444,7 @@ Run \`drift export --format ai-context\` for full pattern details.
 - \`drift where <pattern>\` - Find pattern locations
 - \`drift files <path>\` - See patterns in a specific file
 - \`drift status\` - View pattern summary
+- \`drift dashboard\` - Open web UI
 `;
         fs.writeFileSync(contextPath, content);
     }
@@ -150,17 +452,18 @@ Run \`drift export --format ai-context\` for full pattern details.
         // Silently fail context updates
     }
 }
-/**
- * Watch command implementation
- */
+// ============================================================================
+// Watch Command Implementation
+// ============================================================================
 async function watchCommand(options) {
-    const cwd = process.cwd();
+    const rootDir = process.cwd();
     const verbose = options.verbose ?? false;
     const contextPath = options.context;
     const debounceMs = parseInt(options.debounce ?? '300', 10);
     const categories = options.categories?.split(',').map(c => c.trim()) ?? null;
+    const persist = options.persist !== false; // Default to true
     console.log(chalk.cyan('\n🔍 Drift Watch Mode\n'));
-    console.log(`  Watching: ${chalk.white(cwd)}`);
+    console.log(`  Watching: ${chalk.white(rootDir)}`);
     if (categories) {
         console.log(`  Categories: ${chalk.white(categories.join(', '))}`);
     }
@@ -168,33 +471,72 @@ async function watchCommand(options) {
         console.log(`  Context file: ${chalk.white(contextPath)}`);
     }
     console.log(`  Debounce: ${chalk.white(`${debounceMs}ms`)}`);
+    console.log(`  Persistence: ${chalk.white(persist ? 'enabled' : 'disabled')}`);
     console.log(chalk.gray('\n  Press Ctrl+C to stop\n'));
     console.log(chalk.gray('─'.repeat(50)));
+    // Initialize pattern store
+    let store = null;
+    let fileMap = null;
+    if (persist) {
+        try {
+            store = new PatternStore({ rootDir });
+            await store.initialize();
+            fileMap = await loadFileMap(rootDir);
+            const stats = store.getStats();
+            console.log(`${timestamp()} Loaded ${chalk.cyan(String(stats.totalPatterns))} existing patterns`);
+        }
+        catch (error) {
+            console.log(`${timestamp()} ${chalk.yellow('Warning: Could not initialize store, running without persistence')}`);
+            console.log(chalk.gray(`  ${error.message}`));
+            store = null;
+        }
+    }
     // Load detectors
     const detectors = createAllDetectorsArray();
     console.log(`${timestamp()} Loaded ${chalk.cyan(String(detectors.length))} detectors`);
     // Track pending scans (for debouncing)
     const pendingScans = new Map();
-    // Ignore patterns
-    const ignorePatterns = [
-        'node_modules',
-        '.git',
-        'dist',
-        'build',
-        'coverage',
-        '.turbo',
-    ];
+    // Track save debounce
+    let saveTimeout = null;
+    const SAVE_DEBOUNCE_MS = 1000;
+    function scheduleSave() {
+        if (!store || !fileMap)
+            return;
+        if (saveTimeout) {
+            clearTimeout(saveTimeout);
+        }
+        saveTimeout = setTimeout(async () => {
+            try {
+                // Use file locking for concurrent write protection (Phase 4)
+                await withLock(rootDir, 'drift-watch', async () => {
+                    await store.saveAll();
+                    await saveFileMap(rootDir, fileMap);
+                });
+                if (verbose) {
+                    console.log(`${timestamp()} ${chalk.gray('Saved patterns to disk')}`);
+                }
+            }
+            catch (error) {
+                console.log(`${timestamp()} ${chalk.red('Failed to save:')} ${error.message}`);
+            }
+        }, SAVE_DEBOUNCE_MS);
+    }
     /**
      * Handle file change
      */
-    function handleFileChange(filePath) {
+    async function handleFileChange(filePath) {
+        const relativePath = path.relative(rootDir, filePath);
         // Check if file should be ignored
-        const relativePath = path.relative(cwd, filePath);
-        for (const pattern of ignorePatterns) {
+        for (const pattern of IGNORE_PATTERNS) {
             if (relativePath.includes(pattern)) {
                 return;
             }
         }
+        // Check extension
+        const ext = path.extname(filePath).toLowerCase();
+        if (!SUPPORTED_EXTENSIONS.includes(ext)) {
+            return;
+        }
         // Debounce
         const existing = pendingScans.get(filePath);
         if (existing) {
@@ -202,31 +544,100 @@ async function watchCommand(options) {
         }
         pendingScans.set(filePath, setTimeout(async () => {
             pendingScans.delete(filePath);
-            const violations = await scanFile(filePath, detectors, categories);
-            printViolations(filePath, violations, verbose);
-            // Update context file if specified
-            if (contextPath) {
-                updateContextFile(contextPath);
+            try {
+                // Check if file still exists
+                if (!fs.existsSync(filePath)) {
+                    // File was deleted
+                    if (store && fileMap) {
+                        removeFileFromStore(store, relativePath);
+                        delete fileMap.files[relativePath];
+                        scheduleSave();
+                    }
+                    console.log(`${timestamp()} ${chalk.gray('Deleted:')} ${relativePath}`);
+                    return;
+                }
+                // Read file content
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const fileHash = generateFileHash(content);
+                // Check if file actually changed (Phase 3)
+                if (fileMap && fileMap.files[relativePath]?.hash === fileHash) {
+                    if (verbose) {
+                        console.log(`${timestamp()} ${chalk.gray('Unchanged:')} ${relativePath}`);
+                    }
+                    return;
+                }
+                // Detect patterns
+                const { patterns, violations } = await detectPatternsInFile(filePath, content, detectors, categories, rootDir);
+                // Update store (Phase 1 & 2)
+                let patternsUpdated = 0;
+                const patternIds = [];
+                if (store) {
+                    // First, remove old data for this file
+                    removeFileFromStore(store, relativePath);
+                    // Then add new patterns
+                    for (const detected of patterns) {
+                        const patternId = mergePatternIntoStore(store, detected, violations, relativePath);
+                        patternIds.push(patternId);
+                        patternsUpdated++;
+                    }
+                    // Update file map
+                    if (fileMap) {
+                        fileMap.files[relativePath] = {
+                            lastScanned: new Date().toISOString(),
+                            hash: fileHash,
+                            patterns: patternIds,
+                        };
+                    }
+                    scheduleSave();
+                }
+                // Print results
+                printViolations(filePath, violations, patternsUpdated, verbose);
+                // Update context file
+                if (contextPath && store) {
+                    const stats = store.getStats();
+                    updateContextFile(contextPath, {
+                        patterns: stats.totalPatterns,
+                        violations: stats.totalOutliers,
+                    });
+                }
+            }
+            catch (error) {
+                console.log(`${timestamp()} ${chalk.red('Error processing')} ${relativePath}: ${error.message}`);
             }
         }, debounceMs));
     }
-    // Watch for file changes using fs.watch recursively
+    /**
+     * Handle file deletion
+     */
+    function handleFileDelete(filePath) {
+        const relativePath = path.relative(rootDir, filePath);
+        if (store && fileMap) {
+            removeFileFromStore(store, relativePath);
+            delete fileMap.files[relativePath];
+            scheduleSave();
+        }
+        console.log(`${timestamp()} ${chalk.gray('Removed:')} ${relativePath}`);
+    }
+    // Watch for file changes
     const watchers = [];
     function watchDirectory(dir) {
         try {
-            const watcher = fs.watch(dir, { recursive: true }, (_eventType, filename) => {
+            const watcher = fs.watch(dir, { recursive: true }, (eventType, filename) => {
                 if (!filename)
                     return;
                 const fullPath = path.join(dir, filename);
-                // Only watch supported file types
-                const ext = path.extname(filename).toLowerCase();
-                const supportedExts = ['.ts', '.tsx', '.js', '.jsx', '.py', '.css', '.scss', '.json', '.md'];
-                if (!supportedExts.includes(ext))
-                    return;
-                // Check if file exists (might be deleted)
-                if (!fs.existsSync(fullPath))
-                    return;
-                handleFileChange(fullPath);
+                if (eventType === 'rename') {
+                    // Could be create or delete
+                    if (fs.existsSync(fullPath)) {
+                        handleFileChange(fullPath);
+                    }
+                    else {
+                        handleFileDelete(fullPath);
+                    }
+                }
+                else {
+                    handleFileChange(fullPath);
+                }
             });
             watchers.push(watcher);
         }
@@ -235,30 +646,48 @@ async function watchCommand(options) {
         }
     }
     // Start watching
-    watchDirectory(cwd);
+    watchDirectory(rootDir);
     console.log(`${timestamp()} ${chalk.green('Watching for changes...')}\n`);
     // Handle shutdown
-    process.on('SIGINT', () => {
+    process.on('SIGINT', async () => {
         console.log(chalk.gray('\n\nStopping watch mode...'));
+        // Clear pending operations
         for (const watcher of watchers) {
             watcher.close();
         }
         for (const timeout of pendingScans.values()) {
             clearTimeout(timeout);
         }
+        if (saveTimeout) {
+            clearTimeout(saveTimeout);
+        }
+        // Final save
+        if (store && fileMap) {
+            try {
+                await withLock(rootDir, 'drift-watch-exit', async () => {
+                    await store.saveAll();
+                    await saveFileMap(rootDir, fileMap);
+                });
+                console.log(chalk.green('Saved patterns before exit'));
+            }
+            catch (error) {
+                console.log(chalk.red('Failed to save on exit:'), error.message);
+            }
+        }
         process.exit(0);
     });
     // Keep process alive
     await new Promise(() => { });
 }
-/**
- * Create the watch command
- */
+// ============================================================================
+// Command Definition
+// ============================================================================
 export const watchCommandDef = new Command('watch')
-    .description('Watch for file changes and report violations in real-time')
-    .option('--verbose', 'Show detailed violation information')
+    .description('Watch for file changes and detect patterns in real-time')
+    .option('--verbose', 'Show detailed output')
     .option('--context <file>', 'Auto-update AI context file on changes')
     .option('-c, --categories <categories>', 'Filter by categories (comma-separated)')
     .option('--debounce <ms>', 'Debounce delay in milliseconds', '300')
+    .option('--no-persist', 'Disable pattern persistence (only show violations)')
     .action(watchCommand);
 //# sourceMappingURL=watch.js.map