@mxf-dev/core 1.0.0

package/dist/services/ValidationAnalyticsService.js

@@ -0,0 +1,859 @@
+/**
+ * Copyright 2024 Brad Anderson
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @author Brad Anderson <BradA1878@pm.me>
+ * @repository https://github.com/mxf-dev/mxf
+ * @documentation https://mxf-dev.github.io/mxf/
+ */
+/**
+ * ValidationAnalyticsService - Phase 6 Advanced Analytics
+ *
+ * Core analytics functionality for validation system including:
+ * - Real-time metric aggregation
+ * - Trend analysis and forecasting
+ * - A/B testing framework
+ * - ROI calculation engine
+ * - Custom report generation
+ */
+import { EventEmitter } from 'events';
+import { Logger } from '../utils/Logger.js';
+import { EventBus } from '../events/EventBus.js';
+import { Events } from '../events/EventNames.js';
+import { ValidationPerformanceService } from './ValidationPerformanceService.js';
+import { PatternLearningService } from './PatternLearningService.js';
+import { ProactiveValidationService } from './ProactiveValidationService.js';
+import { AutoCorrectionService } from './AutoCorrectionService.js';
+import { v4 as uuidv4 } from 'uuid';
+import { createBaseEventPayload } from '../schemas/EventPayloadSchema.js';
+/**
+ * Analytics time ranges
+ */
+export var TimeRange;
+(function (TimeRange) {
+    TimeRange["HOUR"] = "hour";
+    TimeRange["DAY"] = "day";
+    TimeRange["WEEK"] = "week";
+    TimeRange["MONTH"] = "month";
+    TimeRange["QUARTER"] = "quarter";
+})(TimeRange || (TimeRange = {}));
+/**
+ * Metric aggregation types
+ */
+export var AggregationType;
+(function (AggregationType) {
+    AggregationType["SUM"] = "sum";
+    AggregationType["AVERAGE"] = "average";
+    AggregationType["MAX"] = "max";
+    AggregationType["MIN"] = "min";
+    AggregationType["COUNT"] = "count";
+    AggregationType["PERCENTILE"] = "percentile";
+})(AggregationType || (AggregationType = {}));
+/**
+ * Validation Analytics Service
+ */
+export class ValidationAnalyticsService extends EventEmitter {
+    logger;
+    // Service dependencies
+    validationPerformanceService;
+    patternLearningService;
+    proactiveValidationService;
+    autoCorrectionService;
+    // Metrics storage (in-memory for now, will be replaced with time-series DB)
+    metricsBuffer = [];
+    aggregatedMetrics = new Map();
+    // A/B testing
+    activeABTests = new Map();
+    abTestResults = new Map();
+    // Reports
+    customReports = new Map();
+    // Configuration
+    config = {
+        bufferSize: 10000,
+        aggregationInterval: 60000, // 1 minute
+        retentionPeriod: 90 * 24 * 60 * 60 * 1000, // 90 days
+        enableRealTimeStreaming: true
+    };
+    static instance;
+    constructor() {
+        super();
+        this.logger = new Logger('info', 'ValidationAnalyticsService', 'server');
+        // Initialize service dependencies
+        this.validationPerformanceService = ValidationPerformanceService.getInstance();
+        this.patternLearningService = PatternLearningService.getInstance();
+        this.proactiveValidationService = ProactiveValidationService.getInstance();
+        this.autoCorrectionService = AutoCorrectionService.getInstance();
+        this.setupEventListeners();
+        this.startAggregationWorker();
+    }
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!ValidationAnalyticsService.instance) {
+            ValidationAnalyticsService.instance = new ValidationAnalyticsService();
+        }
+        return ValidationAnalyticsService.instance;
+    }
+    // =============================================================================
+    // METRIC AGGREGATION
+    // =============================================================================
+    /**
+     * Record a metric
+     */
+    recordMetric(metric) {
+        // Add to buffer
+        this.metricsBuffer.push(metric);
+        // Trim buffer if needed
+        if (this.metricsBuffer.length > this.config.bufferSize) {
+            this.metricsBuffer.shift();
+        }
+        // Stream in real-time if enabled
+        if (this.config.enableRealTimeStreaming) {
+            this.emit('metric_recorded', metric);
+            const eventPayload = createBaseEventPayload(Events.Analytics.METRIC_UPDATE, 'system', 'system', {
+                agentId: 'system',
+                metricName: metric.name,
+                value: metric.value,
+                metadata: {
+                    ...metric.dimensions,
+                    ...metric.metadata
+                },
+                timestamp: new Date(metric.timestamp)
+            });
+            EventBus.server.emit(Events.Analytics.METRIC_UPDATE, eventPayload);
+        }
+    }
+    /**
+     * Aggregate validation metrics
+     */
+    async aggregateValidationMetrics(timeRange, dimensions) {
+        const startTime = this.getStartTime(timeRange);
+        const endTime = Date.now();
+        // Get metrics from all services
+        const [performanceMetrics, patternMetrics, proactiveMetrics, correctionMetrics] = await Promise.all([
+            this.validationPerformanceService.getValidationMetrics('default', 'default'),
+            this.getPatternMetrics(startTime, endTime),
+            this.getProactiveMetrics(startTime, endTime),
+            this.getCorrectionMetrics(startTime, endTime)
+        ]);
+        // Calculate derived metrics from ValidationMetrics
+        const totalErrors = performanceMetrics.totalValidationErrors || 0;
+        const totalSuccessful = Object.values(performanceMetrics.parameterPatterns.successfulPatterns)
+            .reduce((sum, patterns) => sum + patterns.length, 0);
+        const totalValidations = totalErrors + totalSuccessful;
+        const errorRate = totalValidations > 0 ? totalErrors / totalValidations : 0;
+        const successRate = totalValidations > 0 ? totalSuccessful / totalValidations : 0;
+        // Aggregate metrics
+        const aggregated = {
+            timeRange,
+            startTime,
+            endTime,
+            validation: {
+                totalValidations,
+                errorRate,
+                averageLatency: 0, // Will be calculated from actual latency tracking
+                successRate
+            },
+            patterns: {
+                patternsLearned: patternMetrics.totalPatterns || 0,
+                patternMatchRate: patternMetrics.matchRate || 0,
+                improvementRate: patternMetrics.improvementRate || 0
+            },
+            proactive: {
+                preventedErrors: proactiveMetrics.errorsBlocked || 0,
+                cacheHitRate: proactiveMetrics.cacheHitRate || 0,
+                hintsProvided: proactiveMetrics.hintsProvided || 0
+            },
+            corrections: {
+                autoCorrections: correctionMetrics.totalCorrections || 0,
+                correctionSuccessRate: correctionMetrics.successRate || 0,
+                averageCorrectionTime: correctionMetrics.averageTime || 0
+            }
+        };
+        // Apply dimension filters if provided
+        if (dimensions) {
+            // Filter metrics based on dimensions
+            // Implementation depends on data storage
+        }
+        // Cache aggregated result
+        const cacheKey = `${timeRange}_${JSON.stringify(dimensions || {})}`;
+        this.aggregatedMetrics.set(cacheKey, {
+            data: aggregated,
+            timestamp: Date.now()
+        });
+        return aggregated;
+    }
+    // =============================================================================
+    // TREND ANALYSIS
+    // =============================================================================
+    /**
+     * Analyze trends for a metric
+     */
+    async analyzeTrends(metricName, timeRange, options) {
+        const historicalData = await this.getHistoricalData(metricName, timeRange);
+        // Calculate trend
+        const trend = this.calculateTrend(historicalData);
+        const changeRate = this.calculateChangeRate(historicalData);
+        // Forecast next period
+        const forecast = this.forecastMetric(historicalData, options?.forecastPeriods || 1);
+        // Detect seasonality if requested
+        let seasonality;
+        if (options?.seasonalityDetection) {
+            seasonality = this.detectSeasonality(historicalData);
+        }
+        const analysis = {
+            metric: metricName,
+            timeRange,
+            trend,
+            changeRate,
+            forecast: {
+                nextPeriod: forecast.value,
+                confidence: forecast.confidence,
+                upperBound: forecast.upperBound,
+                lowerBound: forecast.lowerBound
+            },
+            seasonality
+        };
+        return analysis;
+    }
+    /**
+     * Calculate trend direction
+     */
+    calculateTrend(data) {
+        if (data.length < 2)
+            return 'stable';
+        // Calculate linear regression
+        const n = data.length;
+        const sumX = (n * (n - 1)) / 2;
+        const sumY = data.reduce((a, b) => a + b, 0);
+        const sumXY = data.reduce((sum, y, x) => sum + x * y, 0);
+        const sumX2 = (n * (n - 1) * (2 * n - 1)) / 6;
+        const slope = (n * sumXY - sumX * sumY) / (n * sumX2 - sumX * sumX);
+        const volatility = this.calculateVolatility(data);
+        if (volatility > 0.3)
+            return 'volatile';
+        if (Math.abs(slope) < 0.01)
+            return 'stable';
+        return slope > 0 ? 'increasing' : 'decreasing';
+    }
+    /**
+     * Calculate volatility
+     */
+    calculateVolatility(data) {
+        const mean = data.reduce((a, b) => a + b, 0) / data.length;
+        const variance = data.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / data.length;
+        const stdDev = Math.sqrt(variance);
+        return stdDev / mean; // Coefficient of variation
+    }
+    /**
+     * Calculate change rate
+     */
+    calculateChangeRate(data) {
+        if (data.length < 2)
+            return 0;
+        const first = data[0];
+        const last = data[data.length - 1];
+        return ((last - first) / first) * 100;
+    }
+    /**
+     * Forecast metric value
+     */
+    forecastMetric(data, periods) {
+        // Simple exponential smoothing for now
+        const alpha = 0.3;
+        let forecast = data[data.length - 1];
+        for (let i = data.length - 2; i >= 0; i--) {
+            forecast = alpha * data[i] + (1 - alpha) * forecast;
+        }
+        // Calculate confidence based on historical volatility
+        const volatility = this.calculateVolatility(data);
+        const confidence = Math.max(0, 1 - volatility);
+        // Calculate bounds
+        const stdDev = Math.sqrt(data.reduce((sum, val) => sum + Math.pow(val - forecast, 2), 0) / data.length);
+        return {
+            value: forecast,
+            confidence,
+            upperBound: forecast + 2 * stdDev,
+            lowerBound: Math.max(0, forecast - 2 * stdDev)
+        };
+    }
+    /**
+     * Detect seasonality
+     */
+    detectSeasonality(data) {
+        // Simplified seasonality detection
+        // In production, would use FFT or more sophisticated methods
+        if (data.length < 24) {
+            return undefined;
+        }
+        // Check for daily pattern (24 hour)
+        const dailyCorrelation = this.calculateAutocorrelation(data, 24);
+        // Check for weekly pattern (168 hours)
+        const weeklyCorrelation = this.calculateAutocorrelation(data, 168);
+        if (dailyCorrelation > 0.7) {
+            return {
+                detected: true,
+                pattern: 'daily',
+                strength: dailyCorrelation
+            };
+        }
+        if (weeklyCorrelation > 0.7) {
+            return {
+                detected: true,
+                pattern: 'weekly',
+                strength: weeklyCorrelation
+            };
+        }
+        return {
+            detected: false,
+            pattern: 'none',
+            strength: 0
+        };
+    }
+    /**
+     * Calculate autocorrelation
+     */
+    calculateAutocorrelation(data, lag) {
+        if (lag >= data.length)
+            return 0;
+        const mean = data.reduce((a, b) => a + b, 0) / data.length;
+        let numerator = 0;
+        let denominator = 0;
+        for (let i = 0; i < data.length - lag; i++) {
+            numerator += (data[i] - mean) * (data[i + lag] - mean);
+        }
+        for (let i = 0; i < data.length; i++) {
+            denominator += Math.pow(data[i] - mean, 2);
+        }
+        return numerator / denominator;
+    }
+    // =============================================================================
+    // A/B TESTING
+    // =============================================================================
+    /**
+     * Create A/B test
+     */
+    createABTest(config) {
+        const testId = uuidv4();
+        const test = {
+            ...config,
+            testId,
+            status: 'draft'
+        };
+        this.activeABTests.set(testId, test);
+        return test;
+    }
+    /**
+     * Start A/B test
+     */
+    startABTest(testId) {
+        const test = this.activeABTests.get(testId);
+        if (!test) {
+            throw new Error(`A/B test not found: ${testId}`);
+        }
+        if (test.status !== 'draft') {
+            throw new Error(`A/B test already ${test.status}: ${testId}`);
+        }
+        test.status = 'active';
+        test.startTime = Date.now();
+        // Initialize result tracking
+        this.abTestResults.set(testId, {
+            variants: new Map(test.variants.map(v => [v.id, {
+                    impressions: 0,
+                    conversions: 0,
+                    metrics: {}
+                }]))
+        });
+        // Configure variant routing
+        this.configureVariantRouting(test);
+        EventBus.server.emit(Events.Analytics.AB_TEST_STARTED, createBaseEventPayload(Events.Analytics.AB_TEST_STARTED, 'system', 'global', {
+            testId,
+            testName: test.name,
+            variants: test.variants.map(v => v.id),
+            parameters: {},
+            timestamp: new Date()
+        }));
+    }
+    /**
+     * Record A/B test event
+     */
+    recordABTestEvent(testId, variantId, eventType, data) {
+        const results = this.abTestResults.get(testId);
+        if (!results)
+            return;
+        const variantResults = results.variants.get(variantId);
+        if (!variantResults)
+            return;
+        switch (eventType) {
+            case 'impression':
+                variantResults.impressions++;
+                break;
+            case 'conversion':
+                variantResults.conversions++;
+                break;
+            case 'metric':
+                if (data?.metric && data?.value) {
+                    if (!variantResults.metrics[data.metric]) {
+                        variantResults.metrics[data.metric] = [];
+                    }
+                    variantResults.metrics[data.metric].push(data.value);
+                }
+                break;
+        }
+    }
+    /**
+     * Get A/B test results
+     */
+    getABTestResults(testId) {
+        const test = this.activeABTests.get(testId);
+        const results = this.abTestResults.get(testId);
+        if (!test || !results) {
+            return null;
+        }
+        const analysis = {
+            testId,
+            name: test.name,
+            status: test.status,
+            duration: test.endTime ? test.endTime - test.startTime : Date.now() - test.startTime,
+            variants: []
+        };
+        for (const [variantId, variantData] of results.variants) {
+            const variant = test.variants.find(v => v.id === variantId);
+            if (!variant)
+                continue;
+            const conversionRate = variantData.impressions > 0
+                ? variantData.conversions / variantData.impressions
+                : 0;
+            analysis.variants.push({
+                id: variantId,
+                name: variant.name,
+                allocation: variant.allocation,
+                impressions: variantData.impressions,
+                conversions: variantData.conversions,
+                conversionRate,
+                metrics: this.calculateMetricAverages(variantData.metrics),
+                confidence: this.calculateStatisticalSignificance(results.variants)
+            });
+        }
+        return analysis;
+    }
+    /**
+     * Calculate metric averages
+     */
+    calculateMetricAverages(metrics) {
+        const averages = {};
+        for (const [metric, values] of Object.entries(metrics)) {
+            if (values.length > 0) {
+                averages[metric] = values.reduce((a, b) => a + b, 0) / values.length;
+            }
+        }
+        return averages;
+    }
+    /**
+     * Calculate statistical significance
+     */
+    calculateStatisticalSignificance(variants) {
+        // Simplified significance calculation
+        // In production, would use proper statistical tests
+        const variantArray = Array.from(variants.values());
+        if (variantArray.length < 2)
+            return 0;
+        const rates = variantArray.map(v => v.impressions > 0 ? v.conversions / v.impressions : 0);
+        const maxRate = Math.max(...rates);
+        const minRate = Math.min(...rates);
+        return Math.min(0.99, (maxRate - minRate) / (minRate + 0.01));
+    }
+    // =============================================================================
+    // ROI CALCULATION
+    // =============================================================================
+    /**
+     * Calculate ROI
+     */
+    async calculateROI(metric, timeRange, investmentData) {
+        const aggregatedMetrics = await this.aggregateValidationMetrics(timeRange);
+        // Default investment estimates (in hours)
+        const investment = {
+            development: investmentData?.development || 500,
+            infrastructure: investmentData?.infrastructure || 100,
+            maintenance: investmentData?.maintenance || 50,
+            total: 0
+        };
+        investment.total = investment.development + investment.infrastructure + investment.maintenance;
+        // Calculate returns based on metrics
+        const hourlyRate = 150; // Average developer hourly rate
+        const returns = {
+            errorReduction: 0,
+            timesSaved: 0,
+            productivityGain: 0,
+            total: 0
+        };
+        // Error reduction value
+        const errorsPreventedPerDay = aggregatedMetrics.proactive.preventedErrors /
+            this.getDaysInTimeRange(timeRange);
+        const minutesPerError = 30; // Average time to fix an error
+        returns.errorReduction = errorsPreventedPerDay * minutesPerError *
+            (hourlyRate / 60) * 365; // Annual value
+        // Time saved through auto-correction
+        const correctionsPerDay = aggregatedMetrics.corrections.autoCorrections /
+            this.getDaysInTimeRange(timeRange);
+        const minutesPerCorrection = 15;
+        returns.timesSaved = correctionsPerDay * minutesPerCorrection *
+            (hourlyRate / 60) * 365;
+        // Productivity gain from reduced validation latency
+        const validationsPerDay = aggregatedMetrics.validation.totalValidations /
+            this.getDaysInTimeRange(timeRange);
+        const latencyReduction = 50; // ms saved per validation
+        returns.productivityGain = validationsPerDay * (latencyReduction / 1000 / 60) *
+            (hourlyRate / 60) * 365;
+        returns.total = returns.errorReduction + returns.timesSaved + returns.productivityGain;
+        // Calculate ROI
+        const roi = ((returns.total - investment.total * hourlyRate) /
+            (investment.total * hourlyRate)) * 100;
+        // Calculate payback period
+        const dailyReturn = returns.total / 365;
+        const paybackPeriod = (investment.total * hourlyRate) / dailyReturn;
+        const calculation = {
+            metric,
+            timeRange,
+            investment,
+            returns,
+            roi,
+            paybackPeriod,
+            breakEvenDate: Date.now() + paybackPeriod * 24 * 60 * 60 * 1000
+        };
+        return calculation;
+    }
+    // =============================================================================
+    // CUSTOM REPORTS
+    // =============================================================================
+    /**
+     * Create custom report
+     */
+    createCustomReport(config) {
+        const reportId = uuidv4();
+        const report = {
+            ...config,
+            reportId
+        };
+        this.customReports.set(reportId, report);
+        // Schedule if needed
+        if (report.schedule) {
+            this.scheduleReport(report);
+        }
+        return report;
+    }
+    /**
+     * Generate custom report
+     */
+    async generateCustomReport(reportId) {
+        const config = this.customReports.get(reportId);
+        if (!config) {
+            throw new Error(`Report not found: ${reportId}`);
+        }
+        const report = {
+            reportId,
+            name: config.name,
+            generatedAt: Date.now(),
+            sections: []
+        };
+        for (const section of config.sections) {
+            const sectionData = await this.generateReportSection(section, config.filters);
+            report.sections.push({
+                title: section.title,
+                type: section.type,
+                data: sectionData
+            });
+        }
+        return report;
+    }
+    /**
+     * Generate report section
+     */
+    async generateReportSection(section, filters) {
+        switch (section.type) {
+            case 'metrics':
+                return this.aggregateValidationMetrics(section.config.timeRange || TimeRange.DAY, filters);
+            case 'charts':
+                return this.generateChartData(section.config);
+            case 'table':
+                return this.generateTableData(section.config);
+            case 'text':
+                return section.config.content || '';
+            default:
+                return null;
+        }
+    }
+    // =============================================================================
+    // HELPER METHODS
+    // =============================================================================
+    /**
+     * Get start time for time range
+     */
+    getStartTime(timeRange) {
+        const now = Date.now();
+        switch (timeRange) {
+            case TimeRange.HOUR:
+                return now - 60 * 60 * 1000;
+            case TimeRange.DAY:
+                return now - 24 * 60 * 60 * 1000;
+            case TimeRange.WEEK:
+                return now - 7 * 24 * 60 * 60 * 1000;
+            case TimeRange.MONTH:
+                return now - 30 * 24 * 60 * 60 * 1000;
+            case TimeRange.QUARTER:
+                return now - 90 * 24 * 60 * 60 * 1000;
+            default:
+                return now - 24 * 60 * 60 * 1000;
+        }
+    }
+    /**
+     * Get days in time range
+     */
+    getDaysInTimeRange(timeRange) {
+        switch (timeRange) {
+            case TimeRange.HOUR:
+                return 1 / 24;
+            case TimeRange.DAY:
+                return 1;
+            case TimeRange.WEEK:
+                return 7;
+            case TimeRange.MONTH:
+                return 30;
+            case TimeRange.QUARTER:
+                return 90;
+            default:
+                return 1;
+        }
+    }
+    /**
+     * Get historical data for metric
+     */
+    async getHistoricalData(metricName, timeRange) {
+        // Simplified implementation - would query time-series DB
+        const data = [];
+        const points = 24; // Data points
+        for (let i = 0; i < points; i++) {
+            // Generate sample data with some noise
+            const baseValue = 100;
+            const trend = i * 2;
+            const noise = Math.random() * 20 - 10;
+            data.push(baseValue + trend + noise);
+        }
+        return data;
+    }
+    /**
+     * Get pattern metrics
+     */
+    async getPatternMetrics(startTime, endTime) {
+        // Would integrate with PatternLearningService
+        return {
+            totalPatterns: 150,
+            matchRate: 0.75,
+            improvementRate: 0.15
+        };
+    }
+    /**
+     * Get proactive metrics
+     */
+    async getProactiveMetrics(startTime, endTime) {
+        const metrics = this.proactiveValidationService.getPerformanceMetrics();
+        return {
+            errorsBlocked: metrics.errorsBlocked,
+            cacheHitRate: metrics.cacheHitRate,
+            hintsProvided: 1000 // Placeholder
+        };
+    }
+    /**
+     * Get correction metrics
+     */
+    async getCorrectionMetrics(startTime, endTime) {
+        const metrics = {
+            totalAttempts: 0,
+            successRate: 0,
+            averageTime: 0,
+            topCorrections: []
+        };
+        return {
+            totalCorrections: metrics.totalAttempts,
+            successRate: metrics.successRate,
+            averageTime: 250 // Placeholder
+        };
+    }
+    /**
+     * Generate chart data
+     */
+    async generateChartData(config) {
+        // Generate data based on chart config
+        return {
+            labels: ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun'],
+            datasets: [{
+                    label: config.metric || 'Validation Errors',
+                    data: [65, 59, 80, 81, 56, 55, 40]
+                }]
+        };
+    }
+    /**
+     * Generate table data
+     */
+    async generateTableData(config) {
+        // Generate table data based on config
+        return {
+            headers: ['Tool', 'Errors', 'Success Rate', 'Avg Latency'],
+            rows: [
+                ['calculator', 5, '95%', '25ms'],
+                ['file_read', 12, '88%', '45ms'],
+                ['web_search', 3, '97%', '30ms']
+            ]
+        };
+    }
+    /**
+     * Configure variant routing
+     */
+    configureVariantRouting(test) {
+        // Configure how traffic is routed to variants
+        // Would integrate with middleware to apply variant configs
+    }
+    /**
+     * Schedule report
+     */
+    scheduleReport(report) {
+        // Set up scheduled report generation
+        // Would use a job scheduler in production
+    }
+    /**
+     * Setup event listeners
+     */
+    setupEventListeners() {
+        // Listen to validation events
+        EventBus.server.on(Events.Mcp.TOOL_VALIDATION_ERROR, (event) => {
+            this.recordMetric({
+                name: 'validation_error',
+                value: 1,
+                timestamp: Date.now(),
+                dimensions: {
+                    tool: event.toolName,
+                    agent: event.agentId,
+                    errorType: event.errorType
+                }
+            });
+        });
+        EventBus.server.on(Events.Mcp.TOOL_RESULT, (event) => {
+            if (event.success) {
+                this.recordMetric({
+                    name: 'tool_success',
+                    value: 1,
+                    timestamp: Date.now(),
+                    dimensions: {
+                        tool: event.toolName,
+                        agent: event.agentId
+                    }
+                });
+            }
+        });
+        // Listen to correction events
+        EventBus.server.on(Events.Mcp.TOOL_RESULT, (event) => {
+            this.recordMetric({
+                name: 'auto_correction',
+                value: 1,
+                timestamp: Date.now(),
+                dimensions: {
+                    strategy: event.strategy,
+                    tool: event.toolName
+                }
+            });
+        });
+    }
+    /**
+     * Start aggregation worker
+     */
+    startAggregationWorker() {
+        setInterval(() => {
+            this.performAggregation();
+        }, this.config.aggregationInterval);
+    }
+    /**
+     * Perform metric aggregation
+     */
+    async performAggregation() {
+        try {
+            // Aggregate recent metrics
+            const recentMetrics = this.metricsBuffer.filter(m => m.timestamp > Date.now() - this.config.aggregationInterval);
+            if (recentMetrics.length === 0)
+                return;
+            // Group by metric name
+            const grouped = new Map();
+            for (const metric of recentMetrics) {
+                if (!grouped.has(metric.name)) {
+                    grouped.set(metric.name, []);
+                }
+                grouped.get(metric.name).push(metric);
+            }
+            // Aggregate each metric
+            for (const [name, metrics] of grouped) {
+                const aggregated = {
+                    name,
+                    count: metrics.length,
+                    sum: metrics.reduce((sum, m) => sum + m.value, 0),
+                    average: 0,
+                    min: Math.min(...metrics.map(m => m.value)),
+                    max: Math.max(...metrics.map(m => m.value)),
+                    timestamp: Date.now()
+                };
+                aggregated.average = aggregated.sum / aggregated.count;
+                // Emit aggregated metric
+                this.emit('metric_aggregated', aggregated);
+            }
+        }
+        catch (error) {
+            this.logger.error('Aggregation error:', error);
+        }
+    }
+    // =============================================================================
+    // PUBLIC API
+    // =============================================================================
+    /**
+     * Get configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+    }
+    /**
+     * Get active A/B tests
+     */
+    getActiveABTests() {
+        return Array.from(this.activeABTests.values())
+            .filter(test => test.status === 'active');
+    }
+    /**
+     * Get custom reports
+     */
+    getCustomReports() {
+        return Array.from(this.customReports.values());
+    }
+    /**
+     * Clear metrics (for testing)
+     */
+    clearMetrics() {
+        this.metricsBuffer.length = 0;
+        this.aggregatedMetrics.clear();
+    }
+}
+//# sourceMappingURL=ValidationAnalyticsService.js.map