agentic-qe 2.0.0 → 2.1.1

package/dist/core/recovery/CircuitBreaker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CircuitBreaker.js","sourceRoot":"","sources":["../../../src/core/recovery/CircuitBreaker.ts"],"names":[],"mappings":"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"}

package/dist/core/recovery/RecoveryOrchestrator.d.ts

@@ -0,0 +1,186 @@
+/**
+ * Recovery Orchestrator
+ * Coordinates error recovery across transport, memory, and orchestration systems
+ */
+import { EventEmitter } from 'events';
+import { CircuitState } from './CircuitBreaker.js';
+import { RetryConfig } from './RetryStrategy.js';
+/**
+ * Recovery strategy types
+ */
+export type RecoveryStrategyType = 'retry' | 'fallback' | 'circuit-break' | 'rollback' | 'graceful-degradation' | 'escalate';
+/**
+ * Component types that can be recovered
+ */
+export type RecoverableComponent = 'transport' | 'memory' | 'orchestration' | 'agent' | 'workflow' | 'database';
+/**
+ * Health status
+ */
+export type HealthStatus = 'healthy' | 'degraded' | 'unhealthy' | 'unknown';
+/**
+ * Recovery action result
+ */
+export interface RecoveryActionResult {
+    success: boolean;
+    strategy: RecoveryStrategyType;
+    component: RecoverableComponent;
+    action: string;
+    duration: number;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+/**
+ * Component health info
+ */
+export interface ComponentHealth {
+    component: RecoverableComponent;
+    status: HealthStatus;
+    lastCheck: Date;
+    errorRate: number;
+    latencyP95: number;
+    circuitState?: CircuitState;
+    details?: Record<string, any>;
+}
+/**
+ * Recovery policy configuration
+ */
+export interface RecoveryPolicy {
+    /** Maximum recovery attempts per minute */
+    maxRecoveryRate: number;
+    /** Time to wait between recovery attempts */
+    cooldownPeriod: number;
+    /** When to escalate to manual intervention */
+    escalationThreshold: number;
+    /** Strategies in order of preference */
+    strategyOrder: RecoveryStrategyType[];
+    /** Component-specific overrides */
+    componentOverrides?: Partial<Record<RecoverableComponent, Partial<RecoveryPolicy>>>;
+}
+/**
+ * Recovery event
+ */
+export interface RecoveryEvent {
+    timestamp: Date;
+    component: RecoverableComponent;
+    strategy: RecoveryStrategyType;
+    success: boolean;
+    error?: string;
+    duration: number;
+}
+/**
+ * Fallback handler type
+ */
+export type FallbackHandler<T> = () => Promise<T>;
+/**
+ * Health check function type
+ */
+export type HealthChecker = (component: RecoverableComponent) => Promise<ComponentHealth>;
+/**
+ * Recovery Orchestrator Implementation
+ */
+export declare class RecoveryOrchestrator extends EventEmitter {
+    private circuitBreakerManager;
+    private retryStrategies;
+    private fallbackHandlers;
+    private healthCheckers;
+    private recoveryHistory;
+    private componentHealth;
+    private policy;
+    private recoveryInProgress;
+    private lastRecoveryAttempts;
+    constructor(policy?: Partial<RecoveryPolicy>);
+    /**
+     * Execute operation with full recovery support
+     */
+    executeWithRecovery<T>(component: RecoverableComponent, operationId: string, operation: () => Promise<T>, options?: {
+        fallback?: FallbackHandler<T>;
+        retryConfig?: Partial<RetryConfig>;
+        bypassCircuitBreaker?: boolean;
+    }): Promise<T>;
+    /**
+     * Attempt automatic recovery for a component
+     */
+    attemptRecovery(component: RecoverableComponent, error: Error): Promise<RecoveryActionResult>;
+    /**
+     * Register fallback handler
+     */
+    registerFallback<T>(component: RecoverableComponent, operationId: string, handler: FallbackHandler<T>): void;
+    /**
+     * Register health checker
+     */
+    registerHealthChecker(component: RecoverableComponent, checker: HealthChecker): void;
+    /**
+     * Check health of all components
+     */
+    checkHealth(): Promise<Map<RecoverableComponent, ComponentHealth>>;
+    /**
+     * Get component health
+     */
+    getComponentHealth(component: RecoverableComponent): ComponentHealth | undefined;
+    /**
+     * Get recovery history
+     */
+    getRecoveryHistory(limit?: number): RecoveryEvent[];
+    /**
+     * Get recovery statistics
+     */
+    getStats(): {
+        totalRecoveries: number;
+        successfulRecoveries: number;
+        failedRecoveries: number;
+        successRate: number;
+        byComponent: Record<string, {
+            total: number;
+            successful: number;
+        }>;
+        byStrategy: Record<string, {
+            total: number;
+            successful: number;
+        }>;
+    };
+    /**
+     * Reset circuit breakers for a component
+     */
+    resetCircuitBreakers(component?: RecoverableComponent): void;
+    /**
+     * Initialize default retry strategies per component
+     */
+    private initializeDefaultStrategies;
+    /**
+     * Get retry strategy for component
+     */
+    private getRetryStrategy;
+    /**
+     * Get policy for component
+     */
+    private getComponentPolicy;
+    /**
+     * Execute a specific recovery strategy
+     */
+    private executeRecoveryStrategy;
+    /**
+     * Check if recovery can be attempted (rate limiting)
+     */
+    private canAttemptRecovery;
+    /**
+     * Record recovery attempt for rate limiting
+     */
+    private recordRecoveryAttempt;
+    /**
+     * Record recovery event
+     */
+    private recordRecoveryEvent;
+    /**
+     * Cleanup resources
+     */
+    destroy(): void;
+}
+/**
+ * Get default recovery orchestrator
+ */
+export declare function getRecoveryOrchestrator(policy?: Partial<RecoveryPolicy>): RecoveryOrchestrator;
+/**
+ * Reset default orchestrator (for testing)
+ */
+export declare function resetRecoveryOrchestrator(): void;
+//# sourceMappingURL=RecoveryOrchestrator.d.ts.map

package/dist/core/recovery/RecoveryOrchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecoveryOrchestrator.d.ts","sourceRoot":"","sources":["../../../src/core/recovery/RecoveryOrchestrator.ts"],"names":[],"mappings":"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"}

package/dist/core/recovery/RecoveryOrchestrator.js

@@ -0,0 +1,476 @@
+"use strict";
+/**
+ * Recovery Orchestrator
+ * Coordinates error recovery across transport, memory, and orchestration systems
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecoveryOrchestrator = void 0;
+exports.getRecoveryOrchestrator = getRecoveryOrchestrator;
+exports.resetRecoveryOrchestrator = resetRecoveryOrchestrator;
+const events_1 = require("events");
+const CircuitBreaker_js_1 = require("./CircuitBreaker.js");
+const RetryStrategy_js_1 = require("./RetryStrategy.js");
+/**
+ * Recovery Orchestrator Implementation
+ */
+class RecoveryOrchestrator extends events_1.EventEmitter {
+    constructor(policy) {
+        super();
+        this.retryStrategies = new Map();
+        this.fallbackHandlers = new Map();
+        this.healthCheckers = new Map();
+        this.recoveryHistory = [];
+        this.componentHealth = new Map();
+        this.recoveryInProgress = new Set();
+        this.lastRecoveryAttempts = new Map();
+        this.policy = {
+            maxRecoveryRate: 10,
+            cooldownPeriod: 5000,
+            escalationThreshold: 5,
+            strategyOrder: ['retry', 'fallback', 'circuit-break', 'graceful-degradation', 'rollback', 'escalate'],
+            ...policy,
+        };
+        this.circuitBreakerManager = (0, CircuitBreaker_js_1.getCircuitBreakerManager)();
+        this.initializeDefaultStrategies();
+    }
+    /**
+     * Execute operation with full recovery support
+     */
+    async executeWithRecovery(component, operationId, operation, options) {
+        const circuitName = `${component}:${operationId}`;
+        const breaker = this.circuitBreakerManager.getBreaker(circuitName);
+        // Check if circuit breaker allows execution
+        if (!options?.bypassCircuitBreaker && breaker.getState() === CircuitBreaker_js_1.CircuitState.OPEN) {
+            // Try fallback if available
+            const fallbackKey = `${component}:${operationId}`;
+            const fallback = options?.fallback || this.fallbackHandlers.get(fallbackKey);
+            if (fallback) {
+                this.emit('fallback-used', { component, operationId, reason: 'circuit-open' });
+                return fallback();
+            }
+            throw new Error(`Circuit breaker is OPEN for ${circuitName} and no fallback available`);
+        }
+        // Execute with retry and circuit breaker
+        const retryStrategy = this.getRetryStrategy(component, options?.retryConfig);
+        try {
+            const result = await retryStrategy.execute(async () => {
+                return breaker.execute(operation);
+            });
+            if (result.success) {
+                return result.result;
+            }
+            // Retry exhausted, try fallback
+            const fallbackKey = `${component}:${operationId}`;
+            const fallback = options?.fallback || this.fallbackHandlers.get(fallbackKey);
+            if (fallback) {
+                this.emit('fallback-used', {
+                    component,
+                    operationId,
+                    reason: 'retry-exhausted',
+                    attempts: result.attempts
+                });
+                return fallback();
+            }
+            throw result.error || new Error('Operation failed after all retries');
+        }
+        catch (error) {
+            // Record recovery event
+            this.recordRecoveryEvent({
+                timestamp: new Date(),
+                component,
+                strategy: 'retry',
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration: 0,
+            });
+            throw error;
+        }
+    }
+    /**
+     * Attempt automatic recovery for a component
+     */
+    async attemptRecovery(component, error) {
+        const recoveryKey = `${component}:recovery`;
+        // Check if recovery is already in progress
+        if (this.recoveryInProgress.has(recoveryKey)) {
+            return {
+                success: false,
+                strategy: 'retry',
+                component,
+                action: 'skipped',
+                duration: 0,
+                error: 'Recovery already in progress',
+            };
+        }
+        // Check recovery rate limit
+        if (!this.canAttemptRecovery(component)) {
+            return {
+                success: false,
+                strategy: 'escalate',
+                component,
+                action: 'rate-limited',
+                duration: 0,
+                error: 'Recovery rate limit exceeded',
+            };
+        }
+        this.recoveryInProgress.add(recoveryKey);
+        const startTime = Date.now();
+        try {
+            // Get policy for component
+            const policy = this.getComponentPolicy(component);
+            // Try strategies in order
+            for (const strategy of policy.strategyOrder) {
+                const result = await this.executeRecoveryStrategy(component, strategy, error);
+                if (result.success) {
+                    this.recordRecoveryEvent({
+                        timestamp: new Date(),
+                        component,
+                        strategy,
+                        success: true,
+                        duration: Date.now() - startTime,
+                    });
+                    this.emit('recovery-success', { component, strategy, duration: result.duration });
+                    return result;
+                }
+            }
+            // All strategies failed
+            const result = {
+                success: false,
+                strategy: 'escalate',
+                component,
+                action: 'all-strategies-failed',
+                duration: Date.now() - startTime,
+                error: 'All recovery strategies failed',
+            };
+            this.emit('recovery-failed', { component, error: error.message });
+            return result;
+        }
+        finally {
+            this.recoveryInProgress.delete(recoveryKey);
+            this.recordRecoveryAttempt(component);
+        }
+    }
+    /**
+     * Register fallback handler
+     */
+    registerFallback(component, operationId, handler) {
+        this.fallbackHandlers.set(`${component}:${operationId}`, handler);
+    }
+    /**
+     * Register health checker
+     */
+    registerHealthChecker(component, checker) {
+        this.healthCheckers.set(component, checker);
+    }
+    /**
+     * Check health of all components
+     */
+    async checkHealth() {
+        const components = [
+            'transport', 'memory', 'orchestration', 'agent', 'workflow', 'database'
+        ];
+        for (const component of components) {
+            const checker = this.healthCheckers.get(component);
+            if (checker) {
+                try {
+                    const health = await checker(component);
+                    this.componentHealth.set(component, health);
+                }
+                catch (error) {
+                    this.componentHealth.set(component, {
+                        component,
+                        status: 'unknown',
+                        lastCheck: new Date(),
+                        errorRate: 1,
+                        latencyP95: 0,
+                        details: { error: error instanceof Error ? error.message : String(error) },
+                    });
+                }
+            }
+        }
+        return new Map(this.componentHealth);
+    }
+    /**
+     * Get component health
+     */
+    getComponentHealth(component) {
+        return this.componentHealth.get(component);
+    }
+    /**
+     * Get recovery history
+     */
+    getRecoveryHistory(limit) {
+        const history = [...this.recoveryHistory].reverse();
+        return limit ? history.slice(0, limit) : history;
+    }
+    /**
+     * Get recovery statistics
+     */
+    getStats() {
+        const total = this.recoveryHistory.length;
+        const successful = this.recoveryHistory.filter(e => e.success).length;
+        const byComponent = {};
+        const byStrategy = {};
+        for (const event of this.recoveryHistory) {
+            // By component
+            if (!byComponent[event.component]) {
+                byComponent[event.component] = { total: 0, successful: 0 };
+            }
+            byComponent[event.component].total++;
+            if (event.success)
+                byComponent[event.component].successful++;
+            // By strategy
+            if (!byStrategy[event.strategy]) {
+                byStrategy[event.strategy] = { total: 0, successful: 0 };
+            }
+            byStrategy[event.strategy].total++;
+            if (event.success)
+                byStrategy[event.strategy].successful++;
+        }
+        return {
+            totalRecoveries: total,
+            successfulRecoveries: successful,
+            failedRecoveries: total - successful,
+            successRate: total > 0 ? successful / total : 0,
+            byComponent,
+            byStrategy,
+        };
+    }
+    /**
+     * Reset circuit breakers for a component
+     */
+    resetCircuitBreakers(component) {
+        if (component) {
+            const metrics = this.circuitBreakerManager.getAllMetrics();
+            for (const [name] of metrics) {
+                if (name.startsWith(component)) {
+                    this.circuitBreakerManager.getBreaker(name).reset();
+                }
+            }
+        }
+        else {
+            this.circuitBreakerManager.resetAll();
+        }
+    }
+    /**
+     * Initialize default retry strategies per component
+     */
+    initializeDefaultStrategies() {
+        this.retryStrategies.set('transport', new RetryStrategy_js_1.RetryStrategy({
+            maxAttempts: 4,
+            initialDelay: 1000,
+            backoffType: 'exponential',
+            retryableErrors: ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED'],
+        }));
+        this.retryStrategies.set('memory', new RetryStrategy_js_1.RetryStrategy({
+            maxAttempts: 3,
+            initialDelay: 500,
+            backoffType: 'exponential',
+            retryableErrors: ['SQLITE_BUSY', 'SQLITE_LOCKED'],
+        }));
+        this.retryStrategies.set('database', new RetryStrategy_js_1.RetryStrategy({
+            maxAttempts: 3,
+            initialDelay: 500,
+            backoffType: 'exponential',
+            retryableErrors: ['SQLITE_BUSY', 'connection', 'timeout'],
+        }));
+        this.retryStrategies.set('orchestration', new RetryStrategy_js_1.RetryStrategy({
+            maxAttempts: 2,
+            initialDelay: 2000,
+            backoffType: 'linear',
+        }));
+        this.retryStrategies.set('agent', new RetryStrategy_js_1.RetryStrategy({
+            maxAttempts: 2,
+            initialDelay: 1000,
+            backoffType: 'constant',
+        }));
+        this.retryStrategies.set('workflow', new RetryStrategy_js_1.RetryStrategy({
+            maxAttempts: 3,
+            initialDelay: 1000,
+            backoffType: 'exponential',
+        }));
+    }
+    /**
+     * Get retry strategy for component
+     */
+    getRetryStrategy(component, overrides) {
+        const baseStrategy = this.retryStrategies.get(component);
+        if (overrides && baseStrategy) {
+            return new RetryStrategy_js_1.RetryStrategy({
+                ...baseStrategy.getConfig(),
+                ...overrides,
+            });
+        }
+        return baseStrategy || new RetryStrategy_js_1.RetryStrategy();
+    }
+    /**
+     * Get policy for component
+     */
+    getComponentPolicy(component) {
+        const override = this.policy.componentOverrides?.[component];
+        if (override) {
+            return { ...this.policy, ...override };
+        }
+        return this.policy;
+    }
+    /**
+     * Execute a specific recovery strategy
+     */
+    async executeRecoveryStrategy(component, strategy, error) {
+        const startTime = Date.now();
+        try {
+            switch (strategy) {
+                case 'retry':
+                    // Already handled by executeWithRecovery
+                    return {
+                        success: false,
+                        strategy,
+                        component,
+                        action: 'no-op',
+                        duration: 0,
+                    };
+                case 'fallback':
+                    const fallback = this.fallbackHandlers.get(`${component}:default`);
+                    if (fallback) {
+                        await fallback();
+                        return {
+                            success: true,
+                            strategy,
+                            component,
+                            action: 'fallback-executed',
+                            duration: Date.now() - startTime,
+                        };
+                    }
+                    return {
+                        success: false,
+                        strategy,
+                        component,
+                        action: 'no-fallback-available',
+                        duration: 0,
+                    };
+                case 'circuit-break':
+                    // Reset circuit breakers for component
+                    this.resetCircuitBreakers(component);
+                    return {
+                        success: true,
+                        strategy,
+                        component,
+                        action: 'circuits-reset',
+                        duration: Date.now() - startTime,
+                    };
+                case 'graceful-degradation':
+                    this.emit('degradation-mode', { component, reason: error.message });
+                    return {
+                        success: true,
+                        strategy,
+                        component,
+                        action: 'degradation-activated',
+                        duration: Date.now() - startTime,
+                    };
+                case 'rollback':
+                    this.emit('rollback-requested', { component, error: error.message });
+                    return {
+                        success: false, // Rollback is async, can't confirm success
+                        strategy,
+                        component,
+                        action: 'rollback-requested',
+                        duration: Date.now() - startTime,
+                    };
+                case 'escalate':
+                    this.emit('escalation', { component, error: error.message });
+                    return {
+                        success: false,
+                        strategy,
+                        component,
+                        action: 'escalated',
+                        duration: Date.now() - startTime,
+                        metadata: { requiresManualIntervention: true },
+                    };
+                default:
+                    return {
+                        success: false,
+                        strategy,
+                        component,
+                        action: 'unknown-strategy',
+                        duration: 0,
+                    };
+            }
+        }
+        catch (strategyError) {
+            return {
+                success: false,
+                strategy,
+                component,
+                action: 'strategy-failed',
+                duration: Date.now() - startTime,
+                error: strategyError instanceof Error ? strategyError.message : String(strategyError),
+            };
+        }
+    }
+    /**
+     * Check if recovery can be attempted (rate limiting)
+     */
+    canAttemptRecovery(component) {
+        const key = `${component}:recovery`;
+        const attempts = this.lastRecoveryAttempts.get(key) || [];
+        const now = Date.now();
+        const oneMinuteAgo = now - 60000;
+        // Filter to last minute
+        const recentAttempts = attempts.filter(t => t > oneMinuteAgo);
+        this.lastRecoveryAttempts.set(key, recentAttempts);
+        return recentAttempts.length < this.policy.maxRecoveryRate;
+    }
+    /**
+     * Record recovery attempt for rate limiting
+     */
+    recordRecoveryAttempt(component) {
+        const key = `${component}:recovery`;
+        const attempts = this.lastRecoveryAttempts.get(key) || [];
+        attempts.push(Date.now());
+        this.lastRecoveryAttempts.set(key, attempts);
+    }
+    /**
+     * Record recovery event
+     */
+    recordRecoveryEvent(event) {
+        this.recoveryHistory.push(event);
+        // Keep only last 1000 events
+        if (this.recoveryHistory.length > 1000) {
+            this.recoveryHistory = this.recoveryHistory.slice(-1000);
+        }
+    }
+    /**
+     * Cleanup resources
+     */
+    destroy() {
+        this.removeAllListeners();
+        this.recoveryHistory = [];
+        this.componentHealth.clear();
+        this.fallbackHandlers.clear();
+        this.healthCheckers.clear();
+    }
+}
+exports.RecoveryOrchestrator = RecoveryOrchestrator;
+/**
+ * Default recovery orchestrator instance
+ */
+let defaultOrchestrator = null;
+/**
+ * Get default recovery orchestrator
+ */
+function getRecoveryOrchestrator(policy) {
+    if (!defaultOrchestrator) {
+        defaultOrchestrator = new RecoveryOrchestrator(policy);
+    }
+    return defaultOrchestrator;
+}
+/**
+ * Reset default orchestrator (for testing)
+ */
+function resetRecoveryOrchestrator() {
+    if (defaultOrchestrator) {
+        defaultOrchestrator.destroy();
+        defaultOrchestrator = null;
+    }
+}
+//# sourceMappingURL=RecoveryOrchestrator.js.map