@juspay/yama 1.4.1 → 1.5.1

package/dist/utils/RetryManager.js

@@ -0,0 +1,205 @@
+/**
+ * Retry Manager for Yama
+ * Provides intelligent retry logic with exponential backoff for handling transient failures
+ */
+import { logger } from "./Logger.js";
+export class RetryManager {
+    static DEFAULT_OPTIONS = {
+        maxAttempts: 3,
+        baseDelayMs: 1000,
+        maxDelayMs: 10000,
+        backoffMultiplier: 2.0,
+        jitterMs: 100,
+        retryableErrors: [
+            "provider_error",
+            "network",
+            "timeout",
+            "connection",
+            "econnreset",
+            "etimedout",
+            "enotfound",
+            "econnrefused",
+            "socket hang up",
+            "request timeout",
+            "service unavailable",
+            "bad gateway",
+            "gateway timeout",
+            "temporary failure",
+            "rate limit",
+        ],
+    };
+    /**
+     * Execute an operation with retry logic
+     */
+    static async withRetry(operation, context, options = {}) {
+        const opts = { ...RetryManager.DEFAULT_OPTIONS, ...options };
+        const startTime = Date.now();
+        let lastError;
+        for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
+            try {
+                const result = await operation();
+                if (attempt > 1) {
+                    const elapsed = Date.now() - startTime;
+                    logger.info(`${context} succeeded on attempt ${attempt} after ${elapsed}ms`);
+                }
+                return result;
+            }
+            catch (error) {
+                lastError = error;
+                const isLastAttempt = attempt === opts.maxAttempts;
+                const isRetryable = RetryManager.isRetryableError(lastError, opts.retryableErrors);
+                const elapsed = Date.now() - startTime;
+                const retryContext = {
+                    operation: context,
+                    attempt,
+                    maxAttempts: opts.maxAttempts,
+                    lastError,
+                    totalElapsed: elapsed,
+                };
+                if (isLastAttempt || !isRetryable) {
+                    if (isLastAttempt) {
+                        logger.error(`${context} failed after ${opts.maxAttempts} attempts (${elapsed}ms total):`, lastError);
+                    }
+                    else {
+                        logger.error(`${context} failed with non-retryable error:`, lastError);
+                    }
+                    throw lastError;
+                }
+                const delay = RetryManager.calculateDelay(attempt, opts);
+                logger.warn(`${context} failed (attempt ${attempt}/${opts.maxAttempts}), retrying in ${delay}ms:`, lastError.message);
+                await RetryManager.sleep(delay);
+            }
+        }
+        // This should never be reached, but TypeScript requires it
+        throw (lastError ||
+            new Error(`${context} failed after ${opts.maxAttempts} attempts`));
+    }
+    /**
+     * Check if an error is retryable based on error patterns
+     */
+    static isRetryableError(error, retryablePatterns) {
+        if (!error) {
+            return false;
+        }
+        const errorMessage = error.message?.toLowerCase() || "";
+        const errorCode = error.code?.toLowerCase() || "";
+        const errorName = error.name?.toLowerCase() || "";
+        // Check if any retryable pattern matches the error
+        return retryablePatterns.some((pattern) => {
+            const lowerPattern = pattern.toLowerCase();
+            return (errorMessage.includes(lowerPattern) ||
+                errorCode.includes(lowerPattern) ||
+                errorName.includes(lowerPattern));
+        });
+    }
+    /**
+     * Calculate delay with exponential backoff and jitter
+     */
+    static calculateDelay(attempt, options) {
+        // Exponential backoff: baseDelay * (multiplier ^ (attempt - 1))
+        const exponentialDelay = options.baseDelayMs * Math.pow(options.backoffMultiplier, attempt - 1);
+        // Apply maximum delay cap
+        const cappedDelay = Math.min(exponentialDelay, options.maxDelayMs);
+        // Add jitter to prevent thundering herd
+        const jitter = Math.random() * options.jitterMs;
+        return Math.floor(cappedDelay + jitter);
+    }
+    /**
+     * Sleep for specified milliseconds
+     */
+    static sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Create a retry wrapper function for a specific operation
+     */
+    static createRetryWrapper(fn, context, options = {}) {
+        return async (...args) => {
+            return RetryManager.withRetry(() => fn(...args), context, options);
+        };
+    }
+    /**
+     * Batch retry operations with individual retry logic
+     */
+    static async batchWithRetry(operations, options = {}) {
+        const { continueOnError = true, ...retryOptions } = options;
+        const results = [];
+        for (const { fn, context } of operations) {
+            try {
+                const data = await RetryManager.withRetry(fn, context, retryOptions);
+                results.push({ success: true, data, context });
+            }
+            catch (error) {
+                const err = error;
+                results.push({ success: false, error: err, context });
+                if (!continueOnError) {
+                    throw error;
+                }
+            }
+        }
+        return results;
+    }
+    /**
+     * Get retry statistics for monitoring
+     */
+    static getRetryStats(results) {
+        const total = results.length;
+        const successful = results.filter((r) => r.success).length;
+        const failed = total - successful;
+        const successRate = total > 0 ? successful / total : 0;
+        const failuresByContext = {};
+        results
+            .filter((r) => !r.success)
+            .forEach((r) => {
+            failuresByContext[r.context] = (failuresByContext[r.context] || 0) + 1;
+        });
+        return {
+            total,
+            successful,
+            failed,
+            successRate,
+            failuresByContext,
+        };
+    }
+    /**
+     * Create a circuit breaker pattern (simple implementation)
+     */
+    static createCircuitBreaker(fn, context, options = {}) {
+        const { failureThreshold = 5, recoveryTimeoutMs = 30000, retryOptions = {}, } = options;
+        let failureCount = 0;
+        let lastFailureTime = 0;
+        let state = "CLOSED";
+        return async (...args) => {
+            const now = Date.now();
+            // Check if we should attempt recovery
+            if (state === "OPEN" && now - lastFailureTime > recoveryTimeoutMs) {
+                state = "HALF_OPEN";
+                logger.debug(`Circuit breaker for ${context} entering HALF_OPEN state`);
+            }
+            // Reject immediately if circuit is open
+            if (state === "OPEN") {
+                throw new Error(`Circuit breaker OPEN for ${context} (${failureCount} failures)`);
+            }
+            try {
+                const result = await RetryManager.withRetry(() => fn(...args), context, retryOptions);
+                // Success - reset circuit breaker
+                if (state === "HALF_OPEN") {
+                    state = "CLOSED";
+                    failureCount = 0;
+                    logger.info(`Circuit breaker for ${context} recovered to CLOSED state`);
+                }
+                return result;
+            }
+            catch (error) {
+                failureCount++;
+                lastFailureTime = now;
+                if (failureCount >= failureThreshold) {
+                    state = "OPEN";
+                    logger.error(`Circuit breaker OPEN for ${context} after ${failureCount} failures`);
+                }
+                throw error;
+            }
+        };
+    }
+}
+//# sourceMappingURL=RetryManager.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/yama",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "Enterprise-grade Pull Request automation toolkit with AI-powered code review and description enhancement",
   "keywords": [
     "pr",

package/yama.config.example.yaml

@@ -29,6 +29,7 @@ features:
   # Code Review Configuration
   codeReview:
     enabled: true
+    postSummaryComment: true # Post summary comment at the end of review (default: true)
     severityLevels: ["CRITICAL", "MAJOR", "MINOR", "SUGGESTION"]
     categories:
       [