claude-flow-novice 2.0.3 → 2.0.4

package/dist/src/swarm/error-recovery/recovery-monitoring.js

@@ -0,0 +1,772 @@
+/**
+ * Recovery Monitoring and Reporting System
+ * Comprehensive tracking, analysis, and reporting of recovery operations
+ */ function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+import { EventEmitter } from "node:events";
+import { createClient } from "redis";
+export class RecoveryMonitoring extends EventEmitter {
+    async start() {
+        if (this.isRunning) {
+            return;
+        }
+        try {
+            await this.redis.connect();
+            await this.loadHistoricalData();
+            this.logger.info('Recovery monitoring started', {
+                collectionInterval: this.config.metrics.collectionInterval,
+                reportingEnabled: this.config.reporting.enabled,
+                alertsEnabled: this.config.alerts.enabled
+            });
+            this.isRunning = true;
+            this.startMetricsCollection();
+            this.startReporting();
+            this.startAlertProcessing();
+            this.emit('started');
+        } catch (error) {
+            this.logger.error('Failed to start recovery monitoring', {
+                error
+            });
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this.isRunning) {
+            return;
+        }
+        this.isRunning = false;
+        if (this.monitoringTimer) {
+            clearInterval(this.monitoringTimer);
+        }
+        if (this.reportingTimer) {
+            clearInterval(this.reportingTimer);
+        }
+        await this.saveHistoricalData();
+        await this.redis.disconnect();
+        this.emit('stopped');
+        this.logger.info('Recovery monitoring stopped');
+    }
+    startMetricsCollection() {
+        this.monitoringTimer = setInterval(async ()=>{
+            try {
+                await this.collectMetrics();
+                await this.analyzeMetrics();
+                await this.checkAlerts();
+            } catch (error) {
+                this.logger.error('Error in metrics collection', {
+                    error
+                });
+            }
+        }, this.config.metrics.collectionInterval);
+    }
+    startReporting() {
+        if (!this.config.reporting.enabled) {
+            return;
+        }
+        this.reportingTimer = setInterval(async ()=>{
+            try {
+                await this.generateScheduledReports();
+            } catch (error) {
+                this.logger.error('Error in scheduled reporting', {
+                    error
+                });
+            }
+        }, 60 * 60 * 1000); // Check every hour
+    }
+    startAlertProcessing() {
+        if (!this.config.alerts.enabled) {
+            return;
+        }
+        this.alertProcessor.on('alert', (alert)=>{
+            this.handleAlert(alert);
+        });
+        this.alertProcessor.start();
+    }
+    async recordErrorDetection(error) {
+        const metrics = await this.getCurrentMetrics();
+        metrics.errorDetection.totalErrors++;
+        metrics.errorDetection.errorsBySeverity[error.severity] = (metrics.errorDetection.errorsBySeverity[error.severity] || 0) + 1;
+        metrics.errorDetection.errorsByCategory[error.category] = (metrics.errorDetection.errorsByCategory[error.category] || 0) + 1;
+        // Calculate detection latency
+        const detectionLatency = Date.now() - error.timestamp.getTime();
+        metrics.errorDetection.detectionLatency = (metrics.errorDetection.detectionLatency + detectionLatency) / 2;
+        // Update predictive accuracy
+        if ('predictive' in error && error.predictive) {
+            metrics.errorDetection.predictiveAccuracy = this.calculatePredictiveAccuracy(error);
+        }
+        await this.saveMetrics(metrics);
+        this.emit('errorDetected', {
+            error,
+            metrics
+        });
+    }
+    async recordRecoveryWorkflow(workflow) {
+        const metrics = await this.getCurrentMetrics();
+        metrics.recoveryWorkflows.totalWorkflows++;
+        if (workflow.success) {
+            const currentSuccessRate = metrics.recoveryWorkflows.successRate;
+            metrics.recoveryWorkflows.successRate = (currentSuccessRate * (metrics.recoveryWorkflows.totalWorkflows - 1) + 1) / metrics.recoveryWorkflows.totalWorkflows;
+        }
+        // Update average recovery time
+        if (workflow.actualDuration) {
+            metrics.recoveryWorkflows.averageRecoveryTime = (metrics.recoveryWorkflows.averageRecoveryTime + workflow.actualDuration) / 2;
+        }
+        // Update strategy usage
+        const strategyId = workflow.strategy.id;
+        metrics.recoveryWorkflows.workflowsByStrategy[strategyId] = (metrics.recoveryWorkflows.workflowsByStrategy[strategyId] || 0) + 1;
+        // Update average confidence
+        const avgConfidence = workflow.attempts.reduce((sum, attempt)=>sum + attempt.confidence, 0) / workflow.attempts.length;
+        metrics.recoveryWorkflows.averageConfidence = (metrics.recoveryWorkflows.averageConfidence + avgConfidence) / 2;
+        await this.saveMetrics(metrics);
+        // Create incident if critical
+        if (workflow.context.severity === 'critical') {
+            await this.createIncidentFromWorkflow(workflow);
+        }
+        this.emit('workflowCompleted', {
+            workflow,
+            metrics
+        });
+    }
+    async recordCircuitBreakerMetrics(breakerName, metrics) {
+        const currentMetrics = await this.getCurrentMetrics();
+        currentMetrics.circuitBreakers.totalBreakers = Math.max(currentMetrics.circuitBreakers.totalBreakers, this.circuitBreakerCount);
+        if (metrics.state === 'open') {
+            currentMetrics.circuitBreakers.openBreakers++;
+        }
+        currentMetrics.circuitBreakers.averageFailureRate = (currentMetrics.circuitBreakers.averageFailureRate + metrics.failureRate) / 2;
+        currentMetrics.circuitBreakers.averageResponseTime = (currentMetrics.circuitBreakers.averageResponseTime + metrics.averageResponseTime) / 2;
+        await this.saveMetrics(currentMetrics);
+        this.emit('circuitBreakerUpdate', {
+            breakerName,
+            metrics
+        });
+    }
+    async recordSystemHealth(health) {
+        const metrics = await this.getCurrentMetrics();
+        metrics.systemHealth.availability = health.availability;
+        metrics.systemHealth.uptime = health.uptime;
+        metrics.systemHealth.performanceScore = health.performanceScore;
+        metrics.systemHealth.resilienceScore = health.resilienceScore;
+        await this.saveMetrics(metrics);
+        this.emit('systemHealthUpdate', {
+            health,
+            metrics
+        });
+    }
+    async collectMetrics() {
+        const metrics = {
+            timestamp: new Date(),
+            errorDetection: {
+                totalErrors: 0,
+                errorsBySeverity: {},
+                errorsByCategory: {},
+                predictiveAccuracy: 0,
+                detectionLatency: 0
+            },
+            recoveryWorkflows: {
+                totalWorkflows: 0,
+                successRate: 0,
+                averageRecoveryTime: 0,
+                workflowsByStrategy: {},
+                averageConfidence: 0
+            },
+            systemHealth: {
+                availability: 0,
+                uptime: 0,
+                performanceScore: 0,
+                resilienceScore: 0
+            },
+            circuitBreakers: {
+                totalBreakers: 0,
+                openBreakers: 0,
+                averageFailureRate: 0,
+                averageResponseTime: 0
+            },
+            failover: {
+                failoverCount: 0,
+                failbackCount: 0,
+                averageFailoverTime: 0,
+                failoverSuccessRate: 0
+            }
+        };
+        // Collect from Redis
+        const errorMetrics = await this.redis.get('swarm:error-recovery-final:metrics:errors');
+        const workflowMetrics = await this.redis.get('swarm:error-recovery-final:metrics:workflows');
+        const systemMetrics = await this.redis.get('swarm:error-recovery-final:metrics:system');
+        if (errorMetrics) {
+            Object.assign(metrics.errorDetection, JSON.parse(errorMetrics));
+        }
+        if (workflowMetrics) {
+            Object.assign(metrics.recoveryWorkflows, JSON.parse(workflowMetrics));
+        }
+        if (systemMetrics) {
+            Object.assign(metrics.systemHealth, JSON.parse(systemMetrics));
+        }
+        this.metrics.push(metrics);
+        // Keep only recent metrics
+        const cutoff = Date.now() - this.config.metrics.retentionDays * 24 * 60 * 60 * 1000;
+        this.metrics = this.metrics.filter((m)=>m.timestamp.getTime() > cutoff);
+        // Store in Redis
+        await this.redis.setEx(`swarm:error-recovery-final:monitoring:metrics:${metrics.timestamp.getTime()}`, this.config.metrics.retentionDays * 24 * 60 * 60, JSON.stringify(metrics));
+    }
+    async analyzeMetrics() {
+        if (this.metrics.length < 10) {
+            return; // Need sufficient data for analysis
+        }
+        const recentMetrics = this.metrics.slice(-24); // Last 24 data points
+        const trends = this.trendAnalyzer.analyzeTrends(recentMetrics);
+        // Check for significant trends that might indicate issues
+        if (trends.errorTrend === 'degrading' && trends.errorRate > 0.1) {
+            await this.createAlert({
+                type: 'trend',
+                severity: 'high',
+                title: 'Error Rate Increasing',
+                description: `Error rate has increased by ${trends.errorRateChange.toFixed(1)}% in the last period`,
+                metrics: {
+                    errorRate: trends.errorRate,
+                    errorRateChange: trends.errorRateChange
+                }
+            });
+        }
+        if (trends.performanceTrend === 'degrading' && trends.performanceDegradation > 0.2) {
+            await this.createAlert({
+                type: 'trend',
+                severity: 'medium',
+                title: 'Performance Degradation',
+                description: `System performance has degraded by ${(trends.performanceDegradation * 100).toFixed(1)}%`,
+                metrics: {
+                    performanceScore: trends.currentPerformance,
+                    degradation: trends.performanceDegradation
+                }
+            });
+        }
+        if (trends.resilienceTrend === 'degrading' && trends.resilienceScore < 0.7) {
+            await this.createAlert({
+                type: 'trend',
+                severity: 'high',
+                title: 'Resilience Score Declining',
+                description: `System resilience has declined to ${(trends.resilienceScore * 100).toFixed(1)}%`,
+                metrics: {
+                    resilienceScore: trends.resilienceScore
+                }
+            });
+        }
+    }
+    async checkAlerts() {
+        if (!this.config.alerts.enabled) {
+            return;
+        }
+        const metrics = await this.getCurrentMetrics();
+        for (const rule of this.config.alerts.rules){
+            if (!rule.enabled) {
+                continue;
+            }
+            try {
+                const shouldAlert = await this.evaluateAlertRule(rule, metrics);
+                if (shouldAlert) {
+                    await this.createAlert({
+                        type: 'threshold',
+                        severity: rule.severity,
+                        title: rule.name,
+                        description: rule.description,
+                        thresholds: {
+                            [rule.condition]: rule.threshold
+                        },
+                        metrics: this.extractRelevantMetrics(rule.condition, metrics)
+                    });
+                }
+            } catch (error) {
+                this.logger.error('Error evaluating alert rule', {
+                    ruleId: rule.id,
+                    error
+                });
+            }
+        }
+    }
+    async evaluateAlertRule(rule, metrics) {
+        const value = this.getMetricValue(rule.condition, metrics);
+        return value > rule.threshold;
+    }
+    getMetricValue(condition, metrics) {
+        const mapping = {
+            'errorRate': (m)=>m.errorDetection.totalErrors / Math.max(m.recoveryWorkflows.totalWorkflows, 1),
+            'recoverySuccessRate': (m)=>m.recoveryWorkflows.successRate,
+            'systemAvailability': (m)=>m.systemHealth.availability,
+            'circuitBreakerFailureRate': (m)=>m.circuitBreakers.averageFailureRate,
+            'averageRecoveryTime': (m)=>m.recoveryWorkflows.averageRecoveryTime
+        };
+        const getter = mapping[condition];
+        return getter ? getter(metrics) : 0;
+    }
+    extractRelevantMetrics(condition, metrics) {
+        const relevant = {};
+        switch(condition){
+            case 'errorRate':
+                relevant.errorRate = this.getMetricValue(condition, metrics);
+                relevant.totalErrors = metrics.errorDetection.totalErrors;
+                break;
+            case 'recoverySuccessRate':
+                relevant.recoverySuccessRate = metrics.recoveryWorkflows.successRate;
+                relevant.totalWorkflows = metrics.recoveryWorkflows.totalWorkflows;
+                break;
+            case 'systemAvailability':
+                relevant.systemAvailability = metrics.systemHealth.availability;
+                relevant.uptime = metrics.systemHealth.uptime;
+                break;
+            case 'circuitBreakerFailureRate':
+                relevant.circuitBreakerFailureRate = metrics.circuitBreakers.averageFailureRate;
+                relevant.openBreakers = metrics.circuitBreakers.openBreakers;
+                break;
+            case 'averageRecoveryTime':
+                relevant.averageRecoveryTime = metrics.recoveryWorkflows.averageRecoveryTime;
+                break;
+        }
+        return relevant;
+    }
+    async createAlert(alertData) {
+        const alert = {
+            id: `alert-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            type: alertData.type || 'system',
+            severity: alertData.severity || 'medium',
+            title: alertData.title || 'System Alert',
+            description: alertData.description || 'System alert triggered',
+            timestamp: new Date(),
+            source: 'recovery-monitoring',
+            metrics: alertData.metrics || {},
+            thresholds: alertData.thresholds,
+            acknowledged: false,
+            resolved: false,
+            actions: []
+        };
+        this.alerts.push(alert);
+        // Store in Redis
+        await this.redis.setEx(`swarm:error-recovery-final:alerts:${alert.id}`, 7 * 24 * 60 * 60, JSON.stringify(alert));
+        // Process alert through alert processor
+        await this.alertProcessor.processAlert(alert);
+        this.emit('alertCreated', alert);
+    }
+    async handleAlert(alert) {
+        this.logger.warn('Alert triggered', {
+            id: alert.id,
+            type: alert.type,
+            severity: alert.severity,
+            title: alert.title
+        });
+        // Publish to swarm channel
+        await this.redis.publish('swarm:error-recovery-final', JSON.stringify({
+            type: 'ALERT',
+            data: alert,
+            timestamp: new Date().toISOString()
+        }));
+    }
+    async createIncidentFromWorkflow(workflow) {
+        const incident = {
+            id: `incident-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+            timestamp: workflow.createdAt,
+            severity: workflow.context.severity,
+            category: workflow.context.category,
+            title: `Recovery Incident: ${workflow.strategy.name}`,
+            description: `Recovery workflow executed for ${workflow.context.errorType}`,
+            detection: {
+                method: 'automated',
+                latency: 0,
+                confidence: workflow.attempts[0]?.confidence || 0
+            },
+            recovery: {
+                workflowId: workflow.id,
+                strategy: workflow.strategy.id,
+                duration: workflow.actualDuration || 0,
+                success: workflow.success,
+                attempts: workflow.attempts.length
+            },
+            impact: {
+                affectedComponents: workflow.context.affectedComponents,
+                downtime: workflow.actualDuration || 0,
+                userImpact: 'Service temporarily unavailable',
+                businessImpact: 'Reduced system availability'
+            },
+            lessons: [],
+            prevention: []
+        };
+        this.incidents.push(incident);
+        // Store in Redis
+        await this.redis.setEx(`swarm:error-recovery-final:incidents:${incident.id}`, 30 * 24 * 60 * 60, JSON.stringify(incident));
+        this.emit('incidentCreated', incident);
+    }
+    async generateScheduledReports() {
+        if (!this.config.reporting.enabled) {
+            return;
+        }
+        for (const schedule of this.config.reporting.schedules){
+            if (!schedule.enabled) {
+                continue;
+            }
+            if (this.shouldGenerateReport(schedule)) {
+                await this.generateReport(schedule.type, schedule.recipients);
+            }
+        }
+    }
+    shouldGenerateReport(schedule) {
+        const now = new Date();
+        const [hours, minutes] = schedule.time.split(':').map(Number);
+        const scheduledTime = new Date();
+        scheduledTime.setHours(hours, minutes, 0, 0);
+        // Check if we're within 1 minute of the scheduled time
+        const diffMinutes = Math.abs(now.getTime() - scheduledTime.getTime()) / (1000 * 60);
+        if (diffMinutes > 1) {
+            return false;
+        }
+        // Check frequency based on type
+        switch(schedule.type){
+            case 'daily':
+                return true;
+            case 'weekly':
+                return now.getDay() === 1; // Monday
+            case 'monthly':
+                return now.getDate() === 1; // First of month
+            default:
+                return false;
+        }
+    }
+    async generateReport(type, recipients) {
+        const now = new Date();
+        let start;
+        switch(type){
+            case 'daily':
+                start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+                break;
+            case 'weekly':
+                start = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+                break;
+            case 'monthly':
+                start = new Date(now.getFullYear(), now.getMonth(), 1);
+                break;
+        }
+        const report = await this.reportGenerator.generateReport(type, start, now);
+        // Send to recipients
+        for (const recipient of recipients){
+            await this.sendReport(report, recipient);
+        }
+        this.emit('reportGenerated', {
+            report,
+            type,
+            recipients
+        });
+    }
+    async sendReport(report, recipient) {
+        // Implementation would send report via appropriate channel
+        this.logger.info('Report sent', {
+            reportId: report.id,
+            type: report.type,
+            recipient
+        });
+    }
+    calculatePredictiveAccuracy(error) {
+        // Implementation would calculate predictive accuracy
+        // For now, return a placeholder
+        return 0.85;
+    }
+    get circuitBreakerCount() {
+        // Implementation would get actual circuit breaker count
+        return 5;
+    }
+    async getCurrentMetrics() {
+        if (this.metrics.length > 0) {
+            return {
+                ...this.metrics[this.metrics.length - 1]
+            };
+        }
+        // Return empty metrics if no data available
+        return {
+            timestamp: new Date(),
+            errorDetection: {
+                totalErrors: 0,
+                errorsBySeverity: {},
+                errorsByCategory: {},
+                predictiveAccuracy: 0,
+                detectionLatency: 0
+            },
+            recoveryWorkflows: {
+                totalWorkflows: 0,
+                successRate: 0,
+                averageRecoveryTime: 0,
+                workflowsByStrategy: {},
+                averageConfidence: 0
+            },
+            systemHealth: {
+                availability: 0,
+                uptime: 0,
+                performanceScore: 0,
+                resilienceScore: 0
+            },
+            circuitBreakers: {
+                totalBreakers: 0,
+                openBreakers: 0,
+                averageFailureRate: 0,
+                averageResponseTime: 0
+            },
+            failover: {
+                failoverCount: 0,
+                failbackCount: 0,
+                averageFailoverTime: 0,
+                failoverSuccessRate: 0
+            }
+        };
+    }
+    async saveMetrics(metrics) {
+        await this.redis.setEx(`swarm:error-recovery-final:monitoring:current-metrics`, 300, JSON.stringify(metrics));
+    }
+    async loadHistoricalData() {
+    // Implementation would load historical data from Redis
+    }
+    async saveHistoricalData() {
+    // Implementation would save historical data to Redis
+    }
+    // Public API methods
+    async getMetrics(limit = 100) {
+        return this.metrics.sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime()).slice(0, limit);
+    }
+    async getIncidents(limit = 50) {
+        return this.incidents.sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime()).slice(0, limit);
+    }
+    async getAlerts(activeOnly = false) {
+        let alerts = this.alerts.sort((a, b)=>b.timestamp.getTime() - a.timestamp.getTime());
+        if (activeOnly) {
+            alerts = alerts.filter((alert)=>!alert.resolved);
+        }
+        return alerts;
+    }
+    async acknowledgeAlert(alertId) {
+        const alert = this.alerts.find((a)=>a.id === alertId);
+        if (!alert) {
+            return false;
+        }
+        alert.acknowledged = true;
+        alert.actions.push({
+            type: 'notify',
+            description: 'Alert acknowledged',
+            executed: true,
+            executedAt: new Date()
+        });
+        await this.redis.setEx(`swarm:error-recovery-final:alerts:${alertId}`, 7 * 24 * 60 * 60, JSON.stringify(alert));
+        return true;
+    }
+    async resolveAlert(alertId) {
+        const alert = this.alerts.find((a)=>a.id === alertId);
+        if (!alert) {
+            return false;
+        }
+        alert.resolved = true;
+        alert.resolvedAt = new Date();
+        alert.actions.push({
+            type: 'notify',
+            description: 'Alert resolved',
+            executed: true,
+            executedAt: new Date()
+        });
+        await this.redis.setEx(`swarm:error-recovery-final:alerts:${alertId}`, 7 * 24 * 60 * 60, JSON.stringify(alert));
+        return true;
+    }
+    async generateCustomReport(type, start, end) {
+        return await this.reportGenerator.generateReport(type, start, end);
+    }
+    constructor(logger, config){
+        super(), _define_property(this, "redis", void 0), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "isRunning", false), _define_property(this, "metrics", []), _define_property(this, "incidents", []), _define_property(this, "alerts", []), _define_property(this, "monitoringTimer", void 0), _define_property(this, "reportingTimer", void 0), _define_property(this, "alertProcessor", void 0), _define_property(this, "reportGenerator", void 0), _define_property(this, "trendAnalyzer", void 0);
+        this.logger = logger;
+        this.config = config;
+        this.redis = createClient(config.redis);
+        this.alertProcessor = new AlertProcessor(logger, config.alerts);
+        this.reportGenerator = new ReportGenerator(logger, config.reporting);
+        this.trendAnalyzer = new TrendAnalyzer();
+    }
+}
+let AlertProcessor = class AlertProcessor extends EventEmitter {
+    start() {
+        this.isRunning = true;
+        this.logger.info('Alert processor started');
+    }
+    stop() {
+        this.isRunning = false;
+        this.logger.info('Alert processor stopped');
+    }
+    async processAlert(alert) {
+        if (!this.isRunning) {
+            return;
+        }
+        try {
+            // Execute configured actions
+            for (const actionId of this.getActionsForAlert(alert)){
+                await this.executeAlertAction(alert, actionId);
+            }
+            this.emit('alertProcessed', alert);
+        } catch (error) {
+            this.logger.error('Error processing alert', {
+                alertId: alert.id,
+                error
+            });
+        }
+    }
+    getActionsForAlert(alert) {
+        // Implementation would determine appropriate actions based on alert severity and type
+        const actions = [];
+        if (alert.severity === 'critical') {
+            actions.push('immediate_notification', 'escalation');
+        } else if (alert.severity === 'high') {
+            actions.push('notification', 'automated_recovery');
+        } else {
+            actions.push('log_only');
+        }
+        return actions;
+    }
+    async executeAlertAction(alert, actionId) {
+        // Implementation would execute the specific alert action
+        this.logger.info('Executing alert action', {
+            alertId: alert.id,
+            actionId
+        });
+    }
+    constructor(logger, config){
+        super(), _define_property(this, "logger", void 0), _define_property(this, "config", void 0), _define_property(this, "isRunning", false);
+        this.logger = logger;
+        this.config = config;
+    }
+};
+let ReportGenerator = class ReportGenerator {
+    async generateReport(type, start, end) {
+        const report = {
+            id: `report-${type}-${Date.now()}`,
+            type,
+            period: {
+                start,
+                end
+            },
+            summary: {
+                totalErrors: 0,
+                criticalIncidents: 0,
+                recoverySuccessRate: 0,
+                systemAvailability: 0,
+                mttr: 0,
+                mtbf: 0
+            },
+            trends: {
+                errorTrend: 'stable',
+                performanceTrend: 'stable',
+                resilienceTrend: 'stable'
+            },
+            recommendations: [],
+            detailedMetrics: await this.collectMetricsForPeriod(start, end),
+            incidents: []
+        };
+        return report;
+    }
+    async collectMetricsForPeriod(start, end) {
+        // Implementation would collect metrics for the specified period
+        return {
+            timestamp: new Date(),
+            errorDetection: {
+                totalErrors: 0,
+                errorsBySeverity: {},
+                errorsByCategory: {},
+                predictiveAccuracy: 0,
+                detectionLatency: 0
+            },
+            recoveryWorkflows: {
+                totalWorkflows: 0,
+                successRate: 0,
+                averageRecoveryTime: 0,
+                workflowsByStrategy: {},
+                averageConfidence: 0
+            },
+            systemHealth: {
+                availability: 0,
+                uptime: 0,
+                performanceScore: 0,
+                resilienceScore: 0
+            },
+            circuitBreakers: {
+                totalBreakers: 0,
+                openBreakers: 0,
+                averageFailureRate: 0,
+                averageResponseTime: 0
+            },
+            failover: {
+                failoverCount: 0,
+                failbackCount: 0,
+                averageFailoverTime: 0,
+                failoverSuccessRate: 0
+            }
+        };
+    }
+    constructor(logger, config){
+        _define_property(this, "logger", void 0);
+        _define_property(this, "config", void 0);
+        this.logger = logger;
+        this.config = config;
+    }
+};
+let TrendAnalyzer = class TrendAnalyzer {
+    analyzeTrends(metrics) {
+        if (metrics.length < 2) {
+            return {
+                errorTrend: 'stable',
+                performanceTrend: 'stable',
+                resilienceTrend: 'stable',
+                errorRate: 0,
+                errorRateChange: 0,
+                performanceDegradation: 0,
+                currentPerformance: 0,
+                resilienceScore: 0
+            };
+        }
+        const recent = metrics.slice(-12); // Last 12 data points
+        const older = metrics.slice(-24, -12); // Previous 12 data points
+        const recentErrorRate = this.calculateAverageErrorRate(recent);
+        const olderErrorRate = this.calculateAverageErrorRate(older);
+        const errorRateChange = (recentErrorRate - olderErrorRate) / olderErrorRate * 100;
+        const recentPerformance = this.calculateAveragePerformance(recent);
+        const olderPerformance = this.calculateAveragePerformance(older);
+        const performanceDegradation = (olderPerformance - recentPerformance) / olderPerformance;
+        const recentResilience = this.calculateAverageResilience(recent);
+        const olderResilience = this.calculateAverageResilience(older);
+        const resilienceChange = (recentResilience - olderResilience) / olderResilience;
+        return {
+            errorTrend: this.determineTrend(errorRateChange),
+            performanceTrend: this.determineTrend(-performanceDegradation),
+            resilienceTrend: this.determineTrend(resilienceChange),
+            errorRate: recentErrorRate,
+            errorRateChange,
+            performanceDegradation,
+            currentPerformance: recentPerformance,
+            resilienceScore: recentResilience
+        };
+    }
+    calculateAverageErrorRate(metrics) {
+        const total = metrics.reduce((sum, m)=>sum + m.errorDetection.totalErrors, 0);
+        const workflows = metrics.reduce((sum, m)=>sum + m.recoveryWorkflows.totalWorkflows, 0);
+        return workflows > 0 ? total / workflows : 0;
+    }
+    calculateAveragePerformance(metrics) {
+        const total = metrics.reduce((sum, m)=>sum + m.systemHealth.performanceScore, 0);
+        return total / metrics.length;
+    }
+    calculateAverageResilience(metrics) {
+        const total = metrics.reduce((sum, m)=>sum + m.systemHealth.resilienceScore, 0);
+        return total / metrics.length;
+    }
+    determineTrend(change) {
+        if (change > 5) return 'improving';
+        if (change < -5) return 'degrading';
+        return 'stable';
+    }
+};