pumuki-ast-hooks 5.5.60 → 5.6.0

package/scripts/hooks-system/infrastructure/resilience/CircuitBreaker.js

@@ -0,0 +1,229 @@
+/**
+ * =============================================================================
+ * CircuitBreaker - Enterprise Resilience for AST Intelligence
+ * =============================================================================
+ * Implements Circuit Breaker pattern to prevent cascading failures
+ * States: CLOSED (normal) → OPEN (failing) → HALF_OPEN (testing)
+ */
+
+const STATES = {
+    CLOSED: 'CLOSED',
+    OPEN: 'OPEN',
+    HALF_OPEN: 'HALF_OPEN'
+};
+
+class CircuitBreaker {
+    constructor(options = {}) {
+        this.name = options.name || 'default';
+        this.failureThreshold = options.failureThreshold || 5;
+        this.successThreshold = options.successThreshold || 2;
+        this.timeout = options.timeout || 30000;
+        this.resetTimeout = options.resetTimeout || 60000;
+
+        this.state = STATES.CLOSED;
+        this.failures = 0;
+        this.successes = 0;
+        this.lastFailureTime = null;
+        this.nextAttempt = null;
+
+        this.listeners = {
+            stateChange: [],
+            failure: [],
+            success: [],
+            rejected: []
+        };
+    }
+
+    async execute(fn, fallback = null) {
+        if (this.state === STATES.OPEN) {
+            if (Date.now() < this.nextAttempt) {
+                this._emit('rejected', { reason: 'Circuit is OPEN' });
+                if (fallback) return fallback();
+                throw new CircuitBreakerError(`Circuit ${this.name} is OPEN`, this.state);
+            }
+            this._transition(STATES.HALF_OPEN);
+        }
+
+        try {
+            const result = await this._executeWithTimeout(fn);
+            this._onSuccess();
+            return result;
+        } catch (error) {
+            this._onFailure(error);
+            if (fallback) return fallback();
+            throw error;
+        }
+    }
+
+    async _executeWithTimeout(fn) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`Circuit ${this.name} timeout after ${this.timeout}ms`));
+            }, this.timeout);
+
+            Promise.resolve(fn())
+                .then(result => {
+                    clearTimeout(timer);
+                    resolve(result);
+                })
+                .catch(error => {
+                    clearTimeout(timer);
+                    reject(error);
+                });
+        });
+    }
+
+    _onSuccess() {
+        this.failures = 0;
+        this._emit('success', { state: this.state });
+
+        if (this.state === STATES.HALF_OPEN) {
+            this.successes++;
+            if (this.successes >= this.successThreshold) {
+                this._transition(STATES.CLOSED);
+            }
+        }
+    }
+
+    _onFailure(error) {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        this._emit('failure', { error, failures: this.failures, state: this.state });
+
+        if (this.state === STATES.HALF_OPEN) {
+            this._transition(STATES.OPEN);
+        } else if (this.failures >= this.failureThreshold) {
+            this._transition(STATES.OPEN);
+        }
+    }
+
+    _transition(newState) {
+        const oldState = this.state;
+        this.state = newState;
+
+        if (newState === STATES.OPEN) {
+            this.nextAttempt = Date.now() + this.resetTimeout;
+            this.successes = 0;
+        } else if (newState === STATES.CLOSED) {
+            this.failures = 0;
+            this.successes = 0;
+            this.nextAttempt = null;
+        } else if (newState === STATES.HALF_OPEN) {
+            this.successes = 0;
+        }
+
+        this._emit('stateChange', { from: oldState, to: newState });
+    }
+
+    on(event, callback) {
+        if (this.listeners[event]) {
+            this.listeners[event].push(callback);
+        }
+        return this;
+    }
+
+    _emit(event, data) {
+        if (this.listeners[event]) {
+            for (const callback of this.listeners[event]) {
+                try {
+                    callback({ ...data, circuitName: this.name, timestamp: Date.now() });
+                } catch (listenerError) {
+                    if (process.env.DEBUG) {
+                        process.stderr.write(`[CircuitBreaker] Listener error: ${listenerError.message}\n`);
+                    }
+                }
+            }
+        }
+    }
+
+    getState() {
+        return {
+            name: this.name,
+            state: this.state,
+            failures: this.failures,
+            successes: this.successes,
+            lastFailureTime: this.lastFailureTime,
+            nextAttempt: this.nextAttempt,
+            isOpen: this.state === STATES.OPEN,
+            isClosed: this.state === STATES.CLOSED,
+            isHalfOpen: this.state === STATES.HALF_OPEN
+        };
+    }
+
+    reset() {
+        this._transition(STATES.CLOSED);
+    }
+
+    forceOpen() {
+        this._transition(STATES.OPEN);
+    }
+}
+
+class CircuitBreakerError extends Error {
+    constructor(message, state) {
+        super(message);
+        this.name = 'CircuitBreakerError';
+        this.state = state;
+    }
+}
+
+class CircuitBreakerRegistry {
+    constructor() {
+        this.breakers = new Map();
+    }
+
+    get(name, options = {}) {
+        if (!this.breakers.has(name)) {
+            this.breakers.set(name, new CircuitBreaker({ name, ...options }));
+        }
+        return this.breakers.get(name);
+    }
+
+    getAll() {
+        const result = {};
+        for (const [name, breaker] of this.breakers) {
+            result[name] = breaker.getState();
+        }
+        return result;
+    }
+
+    resetAll() {
+        for (const [, breaker] of this.breakers) {
+            breaker.reset();
+        }
+    }
+}
+
+const globalRegistry = new CircuitBreakerRegistry();
+
+const mcpCircuit = globalRegistry.get('mcp', {
+    failureThreshold: 3,
+    successThreshold: 2,
+    timeout: 5000,
+    resetTimeout: 30000
+});
+
+const gitCircuit = globalRegistry.get('git', {
+    failureThreshold: 5,
+    successThreshold: 2,
+    timeout: 10000,
+    resetTimeout: 60000
+});
+
+const astCircuit = globalRegistry.get('ast', {
+    failureThreshold: 3,
+    successThreshold: 1,
+    timeout: 15000,
+    resetTimeout: 45000
+});
+
+module.exports = {
+    CircuitBreaker,
+    CircuitBreakerError,
+    CircuitBreakerRegistry,
+    globalRegistry,
+    mcpCircuit,
+    gitCircuit,
+    astCircuit,
+    STATES
+};

package/scripts/hooks-system/infrastructure/resilience/RetryPolicy.js

@@ -0,0 +1,141 @@
+/**
+ * =============================================================================
+ * RetryPolicy - Enterprise Resilience for AST Intelligence
+ * =============================================================================
+ * Configurable retry strategies with exponential backoff, jitter, and hooks
+ */
+
+class RetryPolicy {
+    constructor(options = {}) {
+        this.maxRetries = options.maxRetries ?? 3;
+        this.baseDelay = options.baseDelay ?? 1000;
+        this.maxDelay = options.maxDelay ?? 30000;
+        this.backoffMultiplier = options.backoffMultiplier ?? 2;
+        this.jitter = options.jitter ?? true;
+        this.retryOn = options.retryOn || this._defaultRetryOn;
+        this.onRetry = options.onRetry || (() => { });
+    }
+
+    _defaultRetryOn(error) {
+        if (error.name === 'CircuitBreakerError') return false;
+        if (error.code === 'ECONNREFUSED') return true;
+        if (error.code === 'ETIMEDOUT') return true;
+        if (error.code === 'ENOTFOUND') return true;
+        if (error.message?.includes('timeout')) return true;
+        if (error.message?.includes('rate limit')) return true;
+        return true;
+    }
+
+    _calculateDelay(attempt) {
+        let delay = this.baseDelay * Math.pow(this.backoffMultiplier, attempt);
+        delay = Math.min(delay, this.maxDelay);
+
+        if (this.jitter) {
+            const jitterRange = delay * 0.2;
+            delay = delay - jitterRange + (Math.random() * jitterRange * 2);
+        }
+
+        return Math.round(delay);
+    }
+
+    async execute(fn) {
+        let lastError;
+
+        for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+            try {
+                return await fn();
+            } catch (error) {
+                lastError = error;
+
+                if (attempt === this.maxRetries) {
+                    throw new RetryExhaustedError(
+                        `All ${this.maxRetries + 1} attempts failed`,
+                        lastError,
+                        attempt + 1
+                    );
+                }
+
+                const shouldRetry = typeof this.retryOn === 'function'
+                    ? this.retryOn(error, attempt)
+                    : true;
+
+                if (!shouldRetry) {
+                    throw error;
+                }
+
+                const delay = this._calculateDelay(attempt);
+
+                this.onRetry({
+                    attempt: attempt + 1,
+                    maxRetries: this.maxRetries,
+                    delay,
+                    error: error.message
+                });
+
+                await this._sleep(delay);
+            }
+        }
+
+        throw lastError;
+    }
+
+    _sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    static immediate(maxRetries = 3) {
+        return new RetryPolicy({
+            maxRetries,
+            baseDelay: 0,
+            jitter: false
+        });
+    }
+
+    static linear(maxRetries = 3, delay = 1000) {
+        return new RetryPolicy({
+            maxRetries,
+            baseDelay: delay,
+            backoffMultiplier: 1,
+            jitter: false
+        });
+    }
+
+    static exponential(maxRetries = 3, baseDelay = 1000) {
+        return new RetryPolicy({
+            maxRetries,
+            baseDelay,
+            backoffMultiplier: 2,
+            jitter: true
+        });
+    }
+
+    static aggressive(maxRetries = 5, baseDelay = 500) {
+        return new RetryPolicy({
+            maxRetries,
+            baseDelay,
+            backoffMultiplier: 1.5,
+            maxDelay: 10000,
+            jitter: true
+        });
+    }
+}
+
+class RetryExhaustedError extends Error {
+    constructor(message, lastError, attempts) {
+        super(message);
+        this.name = 'RetryExhaustedError';
+        this.lastError = lastError;
+        this.attempts = attempts;
+    }
+}
+
+async function withRetry(fn, options = {}) {
+    const policy = new RetryPolicy(options);
+    return policy.execute(fn);
+}
+
+module.exports = {
+    RetryPolicy,
+    RetryExhaustedError,
+    withRetry
+};

package/scripts/hooks-system/infrastructure/resilience/index.js

@@ -0,0 +1,34 @@
+/**
+ * Resilience Module - Circuit Breaker & Retry Policies
+ */
+
+const {
+    CircuitBreaker,
+    CircuitBreakerError,
+    CircuitBreakerRegistry,
+    globalRegistry,
+    mcpCircuit,
+    gitCircuit,
+    astCircuit,
+    STATES
+} = require('./CircuitBreaker');
+
+const {
+    RetryPolicy,
+    RetryExhaustedError,
+    withRetry
+} = require('./RetryPolicy');
+
+module.exports = {
+    CircuitBreaker,
+    CircuitBreakerError,
+    CircuitBreakerRegistry,
+    globalRegistry,
+    mcpCircuit,
+    gitCircuit,
+    astCircuit,
+    STATES,
+    RetryPolicy,
+    RetryExhaustedError,
+    withRetry
+};