driftdetect-dashboard 0.8.1 → 0.8.3

package/dist/server/drift-data-reader.js

@@ -0,0 +1,1550 @@
+/**
+ * DriftDataReader
+ *
+ * Reads and parses data from the .drift/ folder structure.
+ * Provides methods for accessing patterns, violations, files, and configuration.
+ *
+ * OPTIMIZED: Uses DataLake for fast reads with pre-computed views.
+ * Falls back to direct file reading when lake data is unavailable.
+ *
+ * @requirements 1.6 - THE Dashboard_Server SHALL read pattern and violation data from the existing `.drift/` folder structure
+ * @requirements 8.1 - THE Dashboard_Server SHALL expose GET `/api/patterns` to list all patterns
+ * @requirements 8.2 - THE Dashboard_Server SHALL expose GET `/api/patterns/:id` to get pattern details with locations
+ * @requirements 8.6 - THE Dashboard_Server SHALL expose GET `/api/violations` to list all violations
+ * @requirements 8.7 - THE Dashboard_Server SHALL expose GET `/api/files` to get the file tree
+ * @requirements 8.8 - THE Dashboard_Server SHALL expose GET `/api/files/:path` to get patterns and violations for a specific file
+ * @requirements 8.9 - THE Dashboard_Server SHALL expose GET `/api/stats` to get overview statistics
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { createDataLake } from 'driftdetect-core';
+// ============================================================================
+// Constants
+// ============================================================================
+const PATTERNS_DIR = 'patterns';
+const STATUS_DIRS = ['discovered', 'approved', 'ignored'];
+const PATTERN_CATEGORIES = [
+    'structural',
+    'components',
+    'styling',
+    'api',
+    'auth',
+    'errors',
+    'data-access',
+    'testing',
+    'logging',
+    'security',
+    'config',
+    'types',
+    'performance',
+    'accessibility',
+    'documentation',
+];
+// ============================================================================
+// Helper Functions
+// ============================================================================
+/**
+ * Check if a file exists
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Convert a PatternLocation to SemanticLocation
+ */
+function toSemanticLocation(loc) {
+    return {
+        file: loc.file,
+        range: {
+            start: { line: loc.line, character: loc.column },
+            end: { line: loc.endLine ?? loc.line, character: loc.endColumn ?? loc.column },
+        },
+    };
+}
+/**
+ * Convert an OutlierLocation to OutlierWithDetails
+ */
+function toOutlierWithDetails(outlier) {
+    return {
+        file: outlier.file,
+        range: {
+            start: { line: outlier.line, character: outlier.column },
+            end: { line: outlier.endLine ?? outlier.line, character: outlier.endColumn ?? outlier.column },
+        },
+        reason: outlier.reason,
+        deviationScore: outlier.deviationScore,
+    };
+}
+/**
+ * Generate a unique violation ID from pattern and outlier
+ */
+function generateViolationId(patternId, outlier) {
+    return `${patternId}-${outlier.file}-${outlier.line}-${outlier.column}`;
+}
+// ============================================================================
+// DriftDataReader Class
+// ============================================================================
+export class DriftDataReader {
+    driftDir;
+    patternsDir;
+    dataLake;
+    lakeInitialized = false;
+    constructor(driftDir) {
+        this.driftDir = driftDir;
+        this.patternsDir = path.join(driftDir, PATTERNS_DIR);
+        // Initialize DataLake for optimized reads
+        // rootDir is the parent of .drift/
+        const rootDir = path.dirname(driftDir);
+        this.dataLake = createDataLake({ rootDir });
+    }
+    /**
+     * Get the drift directory path
+     */
+    get directory() {
+        return this.driftDir;
+    }
+    /**
+     * Initialize the data lake (lazy initialization)
+     */
+    async initializeLake() {
+        if (this.lakeInitialized)
+            return true;
+        try {
+            await this.dataLake.initialize();
+            this.lakeInitialized = true;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get all patterns, optionally filtered
+     * OPTIMIZED: Uses DataLake pattern shards for fast category-based queries
+     *
+     * @requirements 8.1 - List all patterns
+     */
+    async getPatterns(query) {
+        // OPTIMIZATION: Try DataLake first for fast reads
+        if (await this.initializeLake()) {
+            try {
+                const lakePatterns = await this.getPatternsFromLake(query);
+                if (lakePatterns && lakePatterns.length > 0) {
+                    return lakePatterns;
+                }
+            }
+            catch {
+                // Fall through to direct file reading
+            }
+        }
+        // Fallback: Read patterns from all status directories
+        const patterns = [];
+        for (const status of STATUS_DIRS) {
+            const statusDir = path.join(this.patternsDir, status);
+            if (!(await fileExists(statusDir))) {
+                continue;
+            }
+            // Dynamically read all JSON files in this status directory
+            try {
+                const files = await fs.readdir(statusDir);
+                const jsonFiles = files.filter(f => f.endsWith('.json'));
+                for (const jsonFile of jsonFiles) {
+                    const filePath = path.join(statusDir, jsonFile);
+                    const category = jsonFile.replace('.json', '');
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const patternFile = JSON.parse(content);
+                        for (const stored of patternFile.patterns) {
+                            const dashboardPattern = this.storedToDashboardPattern(stored, category, status);
+                            patterns.push(dashboardPattern);
+                        }
+                    }
+                    catch (error) {
+                        // Skip files that can't be parsed
+                        console.error(`Error reading pattern file ${filePath}:`, error);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error reading status directory ${statusDir}:`, error);
+            }
+        }
+        // Apply filters if provided
+        return this.filterPatterns(patterns, query);
+    }
+    /**
+     * Get patterns from DataLake (optimized path)
+     */
+    async getPatternsFromLake(query) {
+        try {
+            // Build query options for DataLake
+            const queryOptions = {
+                limit: 1000, // Get all patterns
+            };
+            if (query?.category) {
+                queryOptions.categories = [query.category];
+            }
+            if (query?.status && query.status !== 'all') {
+                queryOptions.status = query.status;
+            }
+            if (query?.minConfidence !== undefined) {
+                queryOptions.minConfidence = query.minConfidence;
+            }
+            if (query?.search) {
+                queryOptions.search = query.search;
+            }
+            const result = await this.dataLake.query.getPatterns(queryOptions);
+            if (result.items.length === 0 && result.total === 0) {
+                return null; // No data in lake, fall back to files
+            }
+            // Convert lake PatternSummary to DashboardPattern
+            return result.items.map(p => ({
+                id: p.id,
+                name: p.name,
+                category: p.category,
+                subcategory: p.subcategory,
+                status: p.status,
+                description: '', // PatternSummary doesn't include description
+                confidence: {
+                    score: p.confidence,
+                    level: p.confidenceLevel,
+                },
+                locationCount: p.locationCount,
+                outlierCount: p.outlierCount,
+                severity: p.severity || (p.outlierCount > 0 ? 'warning' : 'info'),
+                metadata: {
+                    firstSeen: new Date().toISOString(),
+                    lastSeen: new Date().toISOString(),
+                },
+            }));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get a single pattern by ID with all locations
+     *
+     * @requirements 8.2 - Get pattern details with locations
+     */
+    async getPattern(id) {
+        // Search through all status directories dynamically
+        for (const status of STATUS_DIRS) {
+            const statusDir = path.join(this.patternsDir, status);
+            if (!(await fileExists(statusDir))) {
+                continue;
+            }
+            try {
+                const files = await fs.readdir(statusDir);
+                const jsonFiles = files.filter(f => f.endsWith('.json'));
+                for (const jsonFile of jsonFiles) {
+                    const filePath = path.join(statusDir, jsonFile);
+                    const category = jsonFile.replace('.json', '');
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const patternFile = JSON.parse(content);
+                        const stored = patternFile.patterns.find((p) => p.id === id);
+                        if (stored) {
+                            return this.storedToDashboardPatternWithLocations(stored, category, status);
+                        }
+                    }
+                    catch (error) {
+                        // Skip files that can't be parsed
+                        console.error(`Error reading pattern file ${filePath}:`, error);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error reading status directory ${statusDir}:`, error);
+            }
+        }
+        return null;
+    }
+    /**
+     * Get all violations, optionally filtered
+     *
+     * Violations are derived from pattern outliers.
+     *
+     * @requirements 8.6 - List all violations
+     */
+    async getViolations(query) {
+        const violations = [];
+        // Read patterns from all status directories dynamically
+        for (const status of STATUS_DIRS) {
+            const statusDir = path.join(this.patternsDir, status);
+            if (!(await fileExists(statusDir))) {
+                continue;
+            }
+            try {
+                const files = await fs.readdir(statusDir);
+                const jsonFiles = files.filter(f => f.endsWith('.json'));
+                for (const jsonFile of jsonFiles) {
+                    const filePath = path.join(statusDir, jsonFile);
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const patternFile = JSON.parse(content);
+                        for (const stored of patternFile.patterns) {
+                            // Convert outliers to violations
+                            for (const outlier of stored.outliers) {
+                                const violation = this.outlierToViolation(stored, outlier);
+                                violations.push(violation);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        // Skip files that can't be parsed
+                        console.error(`Error reading pattern file ${filePath}:`, error);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error reading status directory ${statusDir}:`, error);
+            }
+        }
+        // Apply filters if provided
+        return this.filterViolations(violations, query);
+    }
+    /**
+     * Get dashboard statistics
+     * OPTIMIZED: Uses DataLake status view for instant response
+     * @requirements 8.9 - GET `/api/stats` to get overview statistics
+     */
+    async getStats() {
+        // OPTIMIZATION: Try DataLake status view first (instant)
+        if (await this.initializeLake()) {
+            try {
+                const statusView = await this.dataLake.query.getStatus();
+                if (statusView) {
+                    return this.statusViewToStats(statusView);
+                }
+            }
+            catch {
+                // Fall through to direct file reading
+            }
+        }
+        // Fallback: Compute from raw pattern files
+        const patterns = await this.getPatterns();
+        const violations = await this.getViolations();
+        // Count patterns by status
+        const byStatus = {
+            discovered: 0,
+            approved: 0,
+            ignored: 0,
+        };
+        for (const pattern of patterns) {
+            byStatus[pattern.status]++;
+        }
+        // Count patterns by category - dynamically from actual patterns
+        const byCategory = {};
+        for (const pattern of patterns) {
+            const category = pattern.category;
+            byCategory[category] = (byCategory[category] || 0) + 1;
+        }
+        // Count violations by severity
+        const bySeverity = {
+            error: 0,
+            warning: 0,
+            info: 0,
+            hint: 0,
+        };
+        for (const violation of violations) {
+            const severity = violation.severity;
+            if (severity in bySeverity) {
+                bySeverity[severity]++;
+            }
+        }
+        // Collect unique files from patterns and violations
+        const filesSet = new Set();
+        for (const pattern of patterns) {
+            // We need to get the full pattern to access locations
+            const fullPattern = await this.getPattern(pattern.id);
+            if (fullPattern) {
+                for (const loc of fullPattern.locations) {
+                    filesSet.add(loc.file);
+                }
+                for (const outlier of fullPattern.outliers) {
+                    filesSet.add(outlier.file);
+                }
+            }
+        }
+        // Calculate health score
+        const healthScore = this.calculateHealthScore(violations, patterns);
+        // Get last scan time from pattern metadata
+        let lastScan = null;
+        for (const pattern of patterns) {
+            if (pattern.metadata.lastSeen) {
+                if (!lastScan || pattern.metadata.lastSeen > lastScan) {
+                    lastScan = pattern.metadata.lastSeen;
+                }
+            }
+        }
+        return {
+            healthScore,
+            patterns: {
+                total: patterns.length,
+                byStatus,
+                byCategory: byCategory,
+            },
+            violations: {
+                total: violations.length,
+                bySeverity,
+            },
+            files: {
+                total: filesSet.size,
+                scanned: filesSet.size,
+            },
+            detectors: {
+                active: Object.keys(byCategory).length, // Count unique categories found
+                total: Object.keys(byCategory).length,
+            },
+            lastScan,
+        };
+    }
+    /**
+     * Convert StatusView from DataLake to DashboardStats
+     */
+    statusViewToStats(view) {
+        return {
+            healthScore: view.health.score,
+            patterns: {
+                total: view.patterns.total,
+                byStatus: {
+                    discovered: view.patterns.discovered,
+                    approved: view.patterns.approved,
+                    ignored: view.patterns.ignored,
+                },
+                byCategory: view.patterns.byCategory,
+            },
+            violations: {
+                total: view.issues.critical + view.issues.warnings,
+                bySeverity: {
+                    error: view.issues.critical,
+                    warning: view.issues.warnings,
+                    info: 0,
+                    hint: 0,
+                },
+            },
+            files: {
+                // StatusView doesn't track files, estimate from patterns
+                total: 0,
+                scanned: view.lastScan.filesScanned,
+            },
+            detectors: {
+                active: Object.keys(view.patterns.byCategory).length,
+                total: Object.keys(view.patterns.byCategory).length,
+            },
+            lastScan: view.lastScan.timestamp || null,
+        };
+    }
+    /**
+     * Get the file tree structure
+     * @requirements 8.7 - GET `/api/files` to get the file tree
+     */
+    async getFileTree() {
+        const patterns = await this.getPatterns();
+        const violations = await this.getViolations();
+        // Collect file information
+        const fileInfo = new Map();
+        // Count patterns per file
+        for (const pattern of patterns) {
+            const fullPattern = await this.getPattern(pattern.id);
+            if (fullPattern) {
+                for (const loc of fullPattern.locations) {
+                    const info = fileInfo.get(loc.file) || { patternCount: 0, violationCount: 0 };
+                    info.patternCount++;
+                    fileInfo.set(loc.file, info);
+                }
+            }
+        }
+        // Count violations per file and track highest severity
+        for (const violation of violations) {
+            const info = fileInfo.get(violation.file) || { patternCount: 0, violationCount: 0 };
+            info.violationCount++;
+            // Track highest severity
+            const violationSeverity = violation.severity;
+            if (!info.severity || this.compareSeverity(violationSeverity, info.severity) > 0) {
+                info.severity = violationSeverity;
+            }
+            fileInfo.set(violation.file, info);
+        }
+        // Build tree structure
+        return this.buildFileTree(fileInfo);
+    }
+    /**
+     * Get details for a specific file
+     * @requirements 8.8 - GET `/api/files/:path` to get patterns and violations for a specific file
+     */
+    async getFileDetails(filePath) {
+        const patterns = await this.getPatterns();
+        const violations = await this.getViolations();
+        // Find patterns that have locations in this file
+        const filePatterns = [];
+        for (const pattern of patterns) {
+            const fullPattern = await this.getPattern(pattern.id);
+            if (fullPattern) {
+                const locationsInFile = fullPattern.locations.filter((loc) => loc.file === filePath);
+                if (locationsInFile.length > 0) {
+                    filePatterns.push({
+                        id: pattern.id,
+                        name: pattern.name,
+                        category: pattern.category,
+                        locations: locationsInFile,
+                    });
+                }
+            }
+        }
+        // Find violations in this file
+        const fileViolations = violations.filter((v) => v.file === filePath);
+        // If no patterns or violations found, return null
+        if (filePatterns.length === 0 && fileViolations.length === 0) {
+            return null;
+        }
+        // Determine language from file extension
+        const language = this.getLanguageFromPath(filePath);
+        return {
+            path: filePath,
+            language,
+            lineCount: 0, // We don't have access to actual file content
+            patterns: filePatterns,
+            violations: fileViolations,
+        };
+    }
+    /**
+     * Get configuration
+     * @requirements 8.10 - GET `/api/config` to get configuration
+     */
+    async getConfig() {
+        const configPath = path.join(this.driftDir, 'config.json');
+        if (!(await fileExists(configPath))) {
+            // Return default config if none exists
+            return this.getDefaultConfig();
+        }
+        try {
+            const content = await fs.readFile(configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error('Error reading config:', error);
+            return this.getDefaultConfig();
+        }
+    }
+    /**
+     * Update configuration
+     * @requirements 8.11 - PUT `/api/config` to update configuration
+     */
+    async updateConfig(partial) {
+        const configPath = path.join(this.driftDir, 'config.json');
+        const currentConfig = await this.getConfig();
+        // Merge the partial config with current config
+        const newConfig = {
+            ...currentConfig,
+            ...partial,
+            detectors: partial.detectors ?? currentConfig.detectors,
+            severityOverrides: {
+                ...currentConfig.severityOverrides,
+                ...partial.severityOverrides,
+            },
+            ignorePatterns: partial.ignorePatterns ?? currentConfig.ignorePatterns,
+        };
+        await fs.writeFile(configPath, JSON.stringify(newConfig, null, 2));
+    }
+    /**
+     * Approve a pattern - changes status to 'approved'
+     * @requirements 4.4 - Approve pattern
+     * @requirements 8.3 - POST `/api/patterns/:id/approve` to approve a pattern
+     */
+    async approvePattern(id) {
+        await this.changePatternStatus(id, 'approved');
+    }
+    /**
+     * Ignore a pattern - changes status to 'ignored'
+     * @requirements 4.5 - Ignore pattern
+     * @requirements 8.4 - POST `/api/patterns/:id/ignore` to ignore a pattern
+     */
+    async ignorePattern(id) {
+        await this.changePatternStatus(id, 'ignored');
+    }
+    /**
+     * Delete a pattern - removes from storage
+     * @requirements 4.6 - Delete pattern
+     * @requirements 8.5 - DELETE `/api/patterns/:id` to delete a pattern
+     */
+    async deletePattern(id) {
+        // Find the pattern and its location
+        const location = await this.findPatternLocation(id);
+        if (!location) {
+            throw new Error(`Pattern not found: ${id}`);
+        }
+        const { filePath } = location;
+        // Read the pattern file
+        const content = await fs.readFile(filePath, 'utf-8');
+        const patternFile = JSON.parse(content);
+        // Remove the pattern
+        patternFile.patterns = patternFile.patterns.filter((p) => p.id !== id);
+        patternFile.lastUpdated = new Date().toISOString();
+        // Write back or delete file if empty
+        if (patternFile.patterns.length === 0) {
+            await fs.unlink(filePath);
+        }
+        else {
+            await fs.writeFile(filePath, JSON.stringify(patternFile, null, 2));
+        }
+    }
+    // ==========================================================================
+    // Private Helper Methods
+    // ==========================================================================
+    /**
+     * Convert a StoredPattern to DashboardPattern
+     */
+    storedToDashboardPattern(stored, category, status) {
+        return {
+            id: stored.id,
+            name: stored.name,
+            category,
+            subcategory: stored.subcategory,
+            status,
+            description: stored.description,
+            confidence: {
+                score: stored.confidence.score,
+                level: stored.confidence.level,
+            },
+            locationCount: stored.locations.length,
+            outlierCount: stored.outliers.length,
+            severity: stored.severity,
+            metadata: {
+                firstSeen: stored.metadata.firstSeen,
+                lastSeen: stored.metadata.lastSeen,
+                tags: stored.metadata.tags,
+            },
+        };
+    }
+    /**
+     * Convert a StoredPattern to DashboardPatternWithLocations
+     */
+    storedToDashboardPatternWithLocations(stored, category, status) {
+        const base = this.storedToDashboardPattern(stored, category, status);
+        return {
+            ...base,
+            locations: stored.locations.map(toSemanticLocation),
+            outliers: stored.outliers.map(toOutlierWithDetails),
+        };
+    }
+    /**
+     * Convert an outlier to a violation
+     */
+    outlierToViolation(pattern, outlier) {
+        return {
+            id: generateViolationId(pattern.id, outlier),
+            patternId: pattern.id,
+            patternName: pattern.name,
+            severity: pattern.severity,
+            file: outlier.file,
+            range: {
+                start: { line: outlier.line, character: outlier.column },
+                end: { line: outlier.endLine ?? outlier.line, character: outlier.endColumn ?? outlier.column },
+            },
+            message: outlier.reason,
+            expected: pattern.description,
+            actual: outlier.reason,
+        };
+    }
+    /**
+     * Filter patterns based on query
+     */
+    filterPatterns(patterns, query) {
+        if (!query) {
+            return patterns;
+        }
+        return patterns.filter((pattern) => {
+            // Filter by category
+            if (query.category && pattern.category !== query.category) {
+                return false;
+            }
+            // Filter by status
+            if (query.status && pattern.status !== query.status) {
+                return false;
+            }
+            // Filter by minimum confidence
+            if (query.minConfidence !== undefined && pattern.confidence.score < query.minConfidence) {
+                return false;
+            }
+            // Filter by search term (name or description)
+            if (query.search) {
+                const searchLower = query.search.toLowerCase();
+                const nameMatch = pattern.name.toLowerCase().includes(searchLower);
+                const descMatch = pattern.description.toLowerCase().includes(searchLower);
+                if (!nameMatch && !descMatch) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Filter violations based on query
+     */
+    filterViolations(violations, query) {
+        if (!query) {
+            return violations;
+        }
+        return violations.filter((violation) => {
+            // Filter by severity
+            if (query.severity && violation.severity !== query.severity) {
+                return false;
+            }
+            // Filter by file
+            if (query.file && violation.file !== query.file) {
+                return false;
+            }
+            // Filter by pattern ID
+            if (query.patternId && violation.patternId !== query.patternId) {
+                return false;
+            }
+            // Filter by search term (message or pattern name)
+            if (query.search) {
+                const searchLower = query.search.toLowerCase();
+                const messageMatch = violation.message.toLowerCase().includes(searchLower);
+                const nameMatch = violation.patternName.toLowerCase().includes(searchLower);
+                if (!messageMatch && !nameMatch) {
+                    return false;
+                }
+            }
+            return true;
+        });
+    }
+    /**
+     * Calculate health score based on violations and patterns
+     *
+     * Health score formula:
+     * - Base score starts at 100
+     * - Deduct for violations by severity (error: -10, warning: -3, info: -1, hint: 0)
+     * - Bonus for approved patterns (shows intentional architecture)
+     * - Clamp to 0-100
+     */
+    calculateHealthScore(violations, patterns) {
+        let score = 100;
+        // Deduct for violations by severity
+        for (const violation of violations) {
+            switch (violation.severity) {
+                case 'error':
+                    score -= 10;
+                    break;
+                case 'warning':
+                    score -= 3;
+                    break;
+                case 'info':
+                    score -= 1;
+                    break;
+                // hint doesn't deduct
+            }
+        }
+        // Bonus for approved patterns (shows intentional architecture)
+        if (patterns.length > 0) {
+            const approvedCount = patterns.filter((p) => p.status === 'approved').length;
+            const approvalRate = approvedCount / patterns.length;
+            score += approvalRate * 10;
+        }
+        // Clamp to 0-100
+        return Math.max(0, Math.min(100, Math.round(score)));
+    }
+    /**
+     * Build a hierarchical file tree from file information
+     */
+    buildFileTree(fileInfo) {
+        // First pass: collect all unique directory paths and files
+        const nodeMap = new Map();
+        for (const [filePath, info] of fileInfo) {
+            const parts = filePath.split('/').filter(Boolean);
+            if (parts.length === 0)
+                continue;
+            let currentPath = '';
+            // Create directory nodes
+            for (let i = 0; i < parts.length - 1; i++) {
+                const part = parts[i];
+                currentPath = currentPath ? `${currentPath}/${part}` : part;
+                if (!nodeMap.has(currentPath)) {
+                    nodeMap.set(currentPath, {
+                        name: part,
+                        path: currentPath,
+                        type: 'directory',
+                        children: [],
+                        patternCount: 0,
+                        violationCount: 0,
+                    });
+                }
+            }
+            // Create file node
+            const fileName = parts[parts.length - 1];
+            const fullPath = parts.join('/');
+            const fileNode = {
+                name: fileName,
+                path: fullPath,
+                type: 'file',
+                patternCount: info.patternCount,
+                violationCount: info.violationCount,
+            };
+            if (info.severity) {
+                fileNode.severity = info.severity;
+            }
+            nodeMap.set(fullPath, fileNode);
+        }
+        // Second pass: build parent-child relationships and aggregate counts
+        for (const [nodePath, node] of nodeMap) {
+            if (node.type === 'file') {
+                // Find parent directory
+                const parts = nodePath.split('/');
+                if (parts.length > 1) {
+                    const parentPath = parts.slice(0, -1).join('/');
+                    const parent = nodeMap.get(parentPath);
+                    if (parent && parent.children) {
+                        parent.children.push(node);
+                        // Aggregate counts to parent
+                        if (parent.patternCount !== undefined && node.patternCount !== undefined) {
+                            parent.patternCount += node.patternCount;
+                        }
+                        if (parent.violationCount !== undefined && node.violationCount !== undefined) {
+                            parent.violationCount += node.violationCount;
+                        }
+                        // Track highest severity
+                        if (node.severity) {
+                            if (!parent.severity || this.compareSeverity(node.severity, parent.severity) > 0) {
+                                parent.severity = node.severity;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Third pass: link directories to their parents
+        for (const [nodePath, node] of nodeMap) {
+            if (node.type === 'directory') {
+                const parts = nodePath.split('/');
+                if (parts.length > 1) {
+                    const parentPath = parts.slice(0, -1).join('/');
+                    const parent = nodeMap.get(parentPath);
+                    if (parent && parent.children) {
+                        // Check if not already added
+                        if (!parent.children.some(c => c.path === node.path)) {
+                            parent.children.push(node);
+                        }
+                        // Aggregate counts to parent
+                        if (parent.patternCount !== undefined && node.patternCount !== undefined) {
+                            parent.patternCount += node.patternCount;
+                        }
+                        if (parent.violationCount !== undefined && node.violationCount !== undefined) {
+                            parent.violationCount += node.violationCount;
+                        }
+                        // Track highest severity
+                        if (node.severity) {
+                            if (!parent.severity || this.compareSeverity(node.severity, parent.severity) > 0) {
+                                parent.severity = node.severity;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Get root nodes (nodes without parents)
+        const rootNodes = [];
+        for (const [nodePath, node] of nodeMap) {
+            const parts = nodePath.split('/');
+            if (parts.length === 1) {
+                rootNodes.push(node);
+            }
+        }
+        // Sort and return
+        return this.sortFileTree(rootNodes);
+    }
+    /**
+     * Sort file tree: directories first, then alphabetically
+     */
+    sortFileTree(nodes) {
+        return nodes
+            .map((node) => {
+            if (node.children && node.children.length > 0) {
+                return {
+                    ...node,
+                    children: this.sortFileTree(node.children),
+                };
+            }
+            return node;
+        })
+            .sort((a, b) => {
+            // Directories first
+            if (a.type !== b.type) {
+                return a.type === 'directory' ? -1 : 1;
+            }
+            // Then alphabetically
+            return a.name.localeCompare(b.name);
+        });
+    }
+    /**
+     * Compare severity levels
+     * Returns positive if a > b, negative if a < b, 0 if equal
+     */
+    compareSeverity(a, b) {
+        const order = {
+            error: 4,
+            warning: 3,
+            info: 2,
+            hint: 1,
+        };
+        return order[a] - order[b];
+    }
+    /**
+     * Get programming language from file path
+     */
+    getLanguageFromPath(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const languageMap = {
+            '.ts': 'typescript',
+            '.tsx': 'typescript',
+            '.js': 'javascript',
+            '.jsx': 'javascript',
+            '.py': 'python',
+            '.rb': 'ruby',
+            '.java': 'java',
+            '.go': 'go',
+            '.rs': 'rust',
+            '.c': 'c',
+            '.cpp': 'cpp',
+            '.h': 'c',
+            '.hpp': 'cpp',
+            '.cs': 'csharp',
+            '.php': 'php',
+            '.swift': 'swift',
+            '.kt': 'kotlin',
+            '.scala': 'scala',
+            '.vue': 'vue',
+            '.svelte': 'svelte',
+            '.html': 'html',
+            '.css': 'css',
+            '.scss': 'scss',
+            '.less': 'less',
+            '.json': 'json',
+            '.yaml': 'yaml',
+            '.yml': 'yaml',
+            '.xml': 'xml',
+            '.md': 'markdown',
+            '.sql': 'sql',
+            '.sh': 'bash',
+            '.bash': 'bash',
+            '.zsh': 'zsh',
+        };
+        return languageMap[ext] || 'plaintext';
+    }
+    /**
+     * Change pattern status (move between status directories)
+     */
+    async changePatternStatus(id, newStatus) {
+        // Find the pattern and its current location
+        const location = await this.findPatternLocation(id);
+        if (!location) {
+            throw new Error(`Pattern not found: ${id}`);
+        }
+        const { status: currentStatus, category, filePath, pattern } = location;
+        // If already in the target status, nothing to do
+        if (currentStatus === newStatus) {
+            return;
+        }
+        // Read the source pattern file
+        const sourceContent = await fs.readFile(filePath, 'utf-8');
+        const sourceFile = JSON.parse(sourceContent);
+        // Remove pattern from source file
+        sourceFile.patterns = sourceFile.patterns.filter((p) => p.id !== id);
+        sourceFile.lastUpdated = new Date().toISOString();
+        // Write back source file or delete if empty
+        if (sourceFile.patterns.length === 0) {
+            await fs.unlink(filePath);
+        }
+        else {
+            await fs.writeFile(filePath, JSON.stringify(sourceFile, null, 2));
+        }
+        // Add pattern to target status directory
+        const targetDir = path.join(this.patternsDir, newStatus);
+        const targetPath = path.join(targetDir, `${category}.json`);
+        // Ensure target directory exists
+        await fs.mkdir(targetDir, { recursive: true });
+        // Read or create target file
+        let targetFile;
+        if (await fileExists(targetPath)) {
+            const targetContent = await fs.readFile(targetPath, 'utf-8');
+            targetFile = JSON.parse(targetContent);
+        }
+        else {
+            targetFile = {
+                version: '1.0.0',
+                category,
+                patterns: [],
+                lastUpdated: new Date().toISOString(),
+            };
+        }
+        // Update pattern metadata if approving
+        const updatedPattern = { ...pattern };
+        if (newStatus === 'approved') {
+            updatedPattern.metadata = {
+                ...updatedPattern.metadata,
+                approvedAt: new Date().toISOString(),
+            };
+        }
+        // Add pattern to target file
+        targetFile.patterns.push(updatedPattern);
+        targetFile.lastUpdated = new Date().toISOString();
+        // Write target file
+        await fs.writeFile(targetPath, JSON.stringify(targetFile, null, 2));
+    }
+    /**
+     * Find a pattern's location in the file system
+     */
+    async findPatternLocation(id) {
+        for (const status of STATUS_DIRS) {
+            const statusDir = path.join(this.patternsDir, status);
+            if (!(await fileExists(statusDir))) {
+                continue;
+            }
+            try {
+                const files = await fs.readdir(statusDir);
+                const jsonFiles = files.filter(f => f.endsWith('.json'));
+                for (const jsonFile of jsonFiles) {
+                    const filePath = path.join(statusDir, jsonFile);
+                    const category = jsonFile.replace('.json', '');
+                    try {
+                        const content = await fs.readFile(filePath, 'utf-8');
+                        const patternFile = JSON.parse(content);
+                        const pattern = patternFile.patterns.find((p) => p.id === id);
+                        if (pattern) {
+                            return { status, category, filePath, pattern };
+                        }
+                    }
+                    catch (error) {
+                        // Skip files that can't be parsed
+                        console.error(`Error reading pattern file ${filePath}:`, error);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Error reading status directory ${statusDir}:`, error);
+            }
+        }
+        return null;
+    }
+    /**
+     * Get default configuration
+     */
+    getDefaultConfig() {
+        return {
+            version: '1.0.0',
+            detectors: PATTERN_CATEGORIES.map((category) => ({
+                id: category,
+                name: category.charAt(0).toUpperCase() + category.slice(1).replace(/-/g, ' '),
+                enabled: true,
+                category,
+            })),
+            severityOverrides: {},
+            ignorePatterns: ['node_modules/**', 'dist/**', '.git/**'],
+        };
+    }
+    /**
+     * Get code snippet from a file at a specific line with context
+     */
+    async getCodeSnippet(filePath, line, contextLines = 3) {
+        // driftDir is .drift/, so workspace root is the parent
+        const workspaceRoot = path.dirname(this.driftDir);
+        const fullPath = path.join(workspaceRoot, filePath);
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            const lines = content.split('\n');
+            const startLine = Math.max(1, line - contextLines);
+            const endLine = Math.min(lines.length, line + contextLines);
+            const snippetLines = lines.slice(startLine - 1, endLine);
+            const code = snippetLines.join('\n');
+            return {
+                code,
+                startLine,
+                endLine,
+                language: this.getLanguageFromPath(filePath),
+            };
+        }
+        catch (error) {
+            console.error(`Error reading file ${fullPath}:`, error);
+            return null;
+        }
+    }
+    // ==========================================================================
+    // Contract Methods (BE↔FE mismatch detection)
+    // ==========================================================================
+    /**
+     * Get all contracts, optionally filtered
+     */
+    async getContracts(query) {
+        const contracts = [];
+        const contractsDir = path.join(this.driftDir, 'contracts');
+        const statusDirs = ['discovered', 'verified', 'mismatch', 'ignored'];
+        for (const status of statusDirs) {
+            const statusDir = path.join(contractsDir, status);
+            if (!(await fileExists(statusDir))) {
+                continue;
+            }
+            const filePath = path.join(statusDir, 'contracts.json');
+            if (!(await fileExists(filePath))) {
+                continue;
+            }
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const contractFile = JSON.parse(content);
+                for (const stored of contractFile.contracts) {
+                    contracts.push({
+                        ...stored,
+                        status,
+                        mismatchCount: stored.mismatches?.length || 0,
+                    });
+                }
+            }
+            catch (error) {
+                console.error(`Error reading contract file ${filePath}:`, error);
+            }
+        }
+        // Apply filters
+        return this.filterContracts(contracts, query);
+    }
+    /**
+     * Get a single contract by ID
+     */
+    async getContract(id) {
+        const contractsDir = path.join(this.driftDir, 'contracts');
+        const statusDirs = ['discovered', 'verified', 'mismatch', 'ignored'];
+        for (const status of statusDirs) {
+            const filePath = path.join(contractsDir, status, 'contracts.json');
+            if (!(await fileExists(filePath))) {
+                continue;
+            }
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const contractFile = JSON.parse(content);
+                const contract = contractFile.contracts.find((c) => c.id === id);
+                if (contract) {
+                    return {
+                        ...contract,
+                        status,
+                        mismatchCount: contract.mismatches?.length || 0,
+                    };
+                }
+            }
+            catch (error) {
+                console.error(`Error reading contract file ${filePath}:`, error);
+            }
+        }
+        return null;
+    }
+    /**
+     * Get contract statistics
+     */
+    async getContractStats() {
+        const contracts = await this.getContracts();
+        const byStatus = {
+            discovered: 0,
+            verified: 0,
+            mismatch: 0,
+            ignored: 0,
+        };
+        const byMethod = {
+            GET: 0,
+            POST: 0,
+            PUT: 0,
+            PATCH: 0,
+            DELETE: 0,
+        };
+        let totalMismatches = 0;
+        const mismatchesByType = {};
+        for (const contract of contracts) {
+            const statusKey = contract.status;
+            const methodKey = contract.method;
+            if (statusKey in byStatus) {
+                byStatus[statusKey] = (byStatus[statusKey] || 0) + 1;
+            }
+            if (methodKey in byMethod) {
+                byMethod[methodKey] = (byMethod[methodKey] || 0) + 1;
+            }
+            totalMismatches += contract.mismatchCount;
+            for (const mismatch of contract.mismatches || []) {
+                mismatchesByType[mismatch.mismatchType] = (mismatchesByType[mismatch.mismatchType] || 0) + 1;
+            }
+        }
+        return {
+            totalContracts: contracts.length,
+            byStatus,
+            byMethod,
+            totalMismatches,
+            mismatchesByType,
+        };
+    }
+    /**
+     * Verify a contract
+     */
+    async verifyContract(id) {
+        await this.changeContractStatus(id, 'verified');
+    }
+    /**
+     * Ignore a contract
+     */
+    async ignoreContract(id) {
+        await this.changeContractStatus(id, 'ignored');
+    }
+    /**
+     * Change contract status
+     */
+    async changeContractStatus(id, newStatus) {
+        const contractsDir = path.join(this.driftDir, 'contracts');
+        const statusDirs = ['discovered', 'verified', 'mismatch', 'ignored'];
+        let foundContract = null;
+        // Find the contract
+        for (const status of statusDirs) {
+            const filePath = path.join(contractsDir, status, 'contracts.json');
+            if (!(await fileExists(filePath))) {
+                continue;
+            }
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const contractFile = JSON.parse(content);
+                const contractIndex = contractFile.contracts.findIndex((c) => c.id === id);
+                if (contractIndex !== -1) {
+                    foundContract = contractFile.contracts[contractIndex];
+                    // Remove from current file
+                    contractFile.contracts.splice(contractIndex, 1);
+                    contractFile.lastUpdated = new Date().toISOString();
+                    if (contractFile.contracts.length === 0) {
+                        await fs.unlink(filePath);
+                    }
+                    else {
+                        await fs.writeFile(filePath, JSON.stringify(contractFile, null, 2));
+                    }
+                    break;
+                }
+            }
+            catch (error) {
+                console.error(`Error reading contract file ${filePath}:`, error);
+            }
+        }
+        if (!foundContract) {
+            throw new Error(`Contract not found: ${id}`);
+        }
+        // Add to new status directory
+        const targetDir = path.join(contractsDir, newStatus);
+        const targetPath = path.join(targetDir, 'contracts.json');
+        await fs.mkdir(targetDir, { recursive: true });
+        let targetFile;
+        if (await fileExists(targetPath)) {
+            const content = await fs.readFile(targetPath, 'utf-8');
+            targetFile = JSON.parse(content);
+        }
+        else {
+            targetFile = {
+                version: '1.0.0',
+                status: newStatus,
+                contracts: [],
+                lastUpdated: new Date().toISOString(),
+            };
+        }
+        // Update metadata
+        foundContract.metadata = {
+            ...foundContract.metadata,
+            lastSeen: new Date().toISOString(),
+        };
+        if (newStatus === 'verified') {
+            foundContract.metadata.verifiedAt = new Date().toISOString();
+        }
+        targetFile.contracts.push(foundContract);
+        targetFile.lastUpdated = new Date().toISOString();
+        await fs.writeFile(targetPath, JSON.stringify(targetFile, null, 2));
+    }
+    /**
+     * Filter contracts based on query
+     */
+    filterContracts(contracts, query) {
+        if (!query)
+            return contracts;
+        return contracts.filter((contract) => {
+            if (query.status && contract.status !== query.status)
+                return false;
+            if (query.method && contract.method !== query.method)
+                return false;
+            if (query.hasMismatches !== undefined) {
+                const hasMismatches = contract.mismatchCount > 0;
+                if (query.hasMismatches !== hasMismatches)
+                    return false;
+            }
+            if (query.search && !contract.endpoint.toLowerCase().includes(query.search.toLowerCase())) {
+                return false;
+            }
+            return true;
+        });
+    }
+    // ==========================================================================
+    // Trend / History Methods
+    // ==========================================================================
+    /**
+     * Get trend summary for pattern regressions and improvements
+     * OPTIMIZED: Uses DataLake trends view for instant response
+     */
+    async getTrends(period = '7d') {
+        // OPTIMIZATION: Try DataLake trends view first
+        if (await this.initializeLake()) {
+            try {
+                const trendsView = await this.dataLake.views.getTrendsView();
+                if (trendsView) {
+                    return this.trendsViewToSummary(trendsView, period);
+                }
+            }
+            catch {
+                // Fall through to direct file reading
+            }
+        }
+        // Fallback: Read from history snapshots directly
+        const historyDir = path.join(this.driftDir, 'history', 'snapshots');
+        if (!(await fileExists(historyDir))) {
+            return null;
+        }
+        const days = period === '7d' ? 7 : period === '30d' ? 30 : 90;
+        const now = new Date();
+        const startDate = new Date(now);
+        startDate.setDate(startDate.getDate() - days);
+        // Get snapshots
+        const files = await fs.readdir(historyDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json')).sort();
+        if (jsonFiles.length < 2) {
+            return null; // Need at least 2 snapshots to calculate trends
+        }
+        // Get latest and comparison snapshot
+        const latestFile = jsonFiles[jsonFiles.length - 1];
+        const latestContent = await fs.readFile(path.join(historyDir, latestFile), 'utf-8');
+        const latestSnapshot = JSON.parse(latestContent);
+        // Find snapshot closest to start date
+        const startDateStr = startDate.toISOString().split('T')[0];
+        let comparisonFile = jsonFiles[0];
+        for (const file of jsonFiles) {
+            const fileDate = file.replace('.json', '');
+            if (fileDate <= startDateStr) {
+                comparisonFile = file;
+            }
+            else {
+                break;
+            }
+        }
+        const comparisonContent = await fs.readFile(path.join(historyDir, comparisonFile), 'utf-8');
+        const comparisonSnapshot = JSON.parse(comparisonContent);
+        // Calculate trends
+        return this.calculateTrendSummary(latestSnapshot, comparisonSnapshot, period);
+    }
+    /**
+     * Convert TrendsView from DataLake to TrendSummary
+     * TrendsView has: generatedAt, period, overallTrend, healthDelta, regressions, improvements, stableCount, categoryTrends
+     */
+    trendsViewToSummary(view, period) {
+        // Calculate date range from period
+        const now = new Date();
+        const days = period === '7d' ? 7 : period === '30d' ? 30 : 90;
+        const startDate = new Date(now);
+        startDate.setDate(startDate.getDate() - days);
+        // Convert TrendItem[] to PatternTrend[]
+        const regressions = (view.regressions || []).map(r => ({
+            patternId: r.patternId,
+            patternName: r.patternName,
+            category: r.category,
+            type: 'regression',
+            metric: r.metric,
+            previousValue: r.previousValue,
+            currentValue: r.currentValue,
+            change: r.change,
+            changePercent: r.previousValue > 0 ? (r.change / r.previousValue) * 100 : 0,
+            severity: r.severity,
+            firstSeen: view.generatedAt,
+            details: `${r.metric} changed from ${r.previousValue} to ${r.currentValue}`,
+        }));
+        const improvements = (view.improvements || []).map(i => ({
+            patternId: i.patternId,
+            patternName: i.patternName,
+            category: i.category,
+            type: 'improvement',
+            metric: i.metric,
+            previousValue: i.previousValue,
+            currentValue: i.currentValue,
+            change: i.change,
+            changePercent: i.previousValue > 0 ? (i.change / i.previousValue) * 100 : 0,
+            severity: i.severity,
+            firstSeen: view.generatedAt,
+            details: `${i.metric} improved from ${i.previousValue} to ${i.currentValue}`,
+        }));
+        // Convert CategoryTrend to TrendSummary format
+        const categoryTrends = {};
+        for (const [category, trend] of Object.entries(view.categoryTrends || {})) {
+            categoryTrends[category] = {
+                trend: trend.trend,
+                avgConfidenceChange: trend.avgConfidenceChange,
+                complianceChange: trend.complianceChange,
+            };
+        }
+        return {
+            period,
+            startDate: startDate.toISOString().split('T')[0],
+            endDate: now.toISOString().split('T')[0],
+            regressions,
+            improvements,
+            stable: view.stableCount || 0,
+            overallTrend: view.overallTrend,
+            healthDelta: view.healthDelta || 0,
+            categoryTrends,
+        };
+    }
+    /**
+     * Get historical snapshots for charting
+     */
+    async getSnapshots(limit = 30) {
+        const historyDir = path.join(this.driftDir, 'history', 'snapshots');
+        if (!(await fileExists(historyDir))) {
+            return [];
+        }
+        const files = await fs.readdir(historyDir);
+        const jsonFiles = files.filter(f => f.endsWith('.json')).sort().slice(-limit);
+        const snapshots = [];
+        for (const file of jsonFiles) {
+            try {
+                const content = await fs.readFile(path.join(historyDir, file), 'utf-8');
+                snapshots.push(JSON.parse(content));
+            }
+            catch (error) {
+                console.error(`Error reading snapshot ${file}:`, error);
+            }
+        }
+        return snapshots;
+    }
+    /**
+     * Calculate trend summary between two snapshots
+     */
+    calculateTrendSummary(current, previous, period) {
+        const regressions = [];
+        const improvements = [];
+        const previousMap = new Map(previous.patterns.map(p => [p.patternId, p]));
+        // Thresholds
+        const CONFIDENCE_THRESHOLD = 0.05;
+        const COMPLIANCE_THRESHOLD = 0.10;
+        const OUTLIER_THRESHOLD = 3;
+        for (const currentPattern of current.patterns) {
+            const prevPattern = previousMap.get(currentPattern.patternId);
+            if (!prevPattern)
+                continue;
+            // Check confidence change
+            const confidenceChange = currentPattern.confidence - prevPattern.confidence;
+            if (Math.abs(confidenceChange) >= CONFIDENCE_THRESHOLD) {
+                const trend = {
+                    patternId: currentPattern.patternId,
+                    patternName: currentPattern.patternName,
+                    category: currentPattern.category,
+                    type: confidenceChange < 0 ? 'regression' : 'improvement',
+                    metric: 'confidence',
+                    previousValue: prevPattern.confidence,
+                    currentValue: currentPattern.confidence,
+                    change: confidenceChange,
+                    changePercent: (confidenceChange / prevPattern.confidence) * 100,
+                    severity: confidenceChange <= -0.15 ? 'critical' : confidenceChange < 0 ? 'warning' : 'info',
+                    firstSeen: previous.timestamp,
+                    details: `Confidence ${confidenceChange < 0 ? 'dropped' : 'improved'} from ${(prevPattern.confidence * 100).toFixed(0)}% to ${(currentPattern.confidence * 100).toFixed(0)}%`,
+                };
+                if (trend.type === 'regression') {
+                    regressions.push(trend);
+                }
+                else {
+                    improvements.push(trend);
+                }
+            }
+            // Check compliance change
+            const complianceChange = currentPattern.complianceRate - prevPattern.complianceRate;
+            if (Math.abs(complianceChange) >= COMPLIANCE_THRESHOLD) {
+                const trend = {
+                    patternId: currentPattern.patternId,
+                    patternName: currentPattern.patternName,
+                    category: currentPattern.category,
+                    type: complianceChange < 0 ? 'regression' : 'improvement',
+                    metric: 'compliance',
+                    previousValue: prevPattern.complianceRate,
+                    currentValue: currentPattern.complianceRate,
+                    change: complianceChange,
+                    changePercent: prevPattern.complianceRate > 0 ? (complianceChange / prevPattern.complianceRate) * 100 : 0,
+                    severity: complianceChange <= -0.20 ? 'critical' : complianceChange < 0 ? 'warning' : 'info',
+                    firstSeen: previous.timestamp,
+                    details: `Compliance ${complianceChange < 0 ? 'dropped' : 'improved'} from ${(prevPattern.complianceRate * 100).toFixed(0)}% to ${(currentPattern.complianceRate * 100).toFixed(0)}%`,
+                };
+                if (trend.type === 'regression') {
+                    regressions.push(trend);
+                }
+                else {
+                    improvements.push(trend);
+                }
+            }
+            // Check outlier increase
+            const outlierChange = currentPattern.outlierCount - prevPattern.outlierCount;
+            if (outlierChange >= OUTLIER_THRESHOLD) {
+                regressions.push({
+                    patternId: currentPattern.patternId,
+                    patternName: currentPattern.patternName,
+                    category: currentPattern.category,
+                    type: 'regression',
+                    metric: 'outliers',
+                    previousValue: prevPattern.outlierCount,
+                    currentValue: currentPattern.outlierCount,
+                    change: outlierChange,
+                    changePercent: prevPattern.outlierCount > 0 ? (outlierChange / prevPattern.outlierCount) * 100 : 100,
+                    severity: outlierChange >= 10 ? 'critical' : 'warning',
+                    firstSeen: previous.timestamp,
+                    details: `${outlierChange} new outliers (${prevPattern.outlierCount} → ${currentPattern.outlierCount})`,
+                });
+            }
+        }
+        // Calculate category trends
+        const categoryTrends = {};
+        const categories = new Set([
+            ...Object.keys(current.summary.byCategory),
+            ...Object.keys(previous.summary.byCategory),
+        ]);
+        for (const category of categories) {
+            const currentCat = current.summary.byCategory[category];
+            const prevCat = previous.summary.byCategory[category];
+            if (currentCat && prevCat) {
+                const avgConfidenceChange = currentCat.avgConfidence - prevCat.avgConfidence;
+                const complianceChange = currentCat.complianceRate - prevCat.complianceRate;
+                categoryTrends[category] = {
+                    trend: avgConfidenceChange > 0.02 ? 'improving'
+                        : avgConfidenceChange < -0.02 ? 'declining'
+                            : 'stable',
+                    avgConfidenceChange,
+                    complianceChange,
+                };
+            }
+        }
+        // Calculate overall trend
+        const healthDelta = current.summary.overallComplianceRate - previous.summary.overallComplianceRate;
+        const overallTrend = healthDelta > 0.02 ? 'improving'
+            : healthDelta < -0.02 ? 'declining'
+                : 'stable';
+        // Count stable patterns
+        const changedPatternIds = new Set([...regressions, ...improvements].map(t => t.patternId));
+        const stableCount = current.patterns.filter(p => !changedPatternIds.has(p.patternId)).length;
+        return {
+            period,
+            startDate: previous.date,
+            endDate: current.date,
+            regressions,
+            improvements,
+            stable: stableCount,
+            overallTrend,
+            healthDelta,
+            categoryTrends,
+        };
+    }
+}
+//# sourceMappingURL=drift-data-reader.js.map