@juspay/yama 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## [1.5.1](https://github.com/juspay/yama/compare/v1.5.0...v1.5.1) (2025-09-24)
+
+### Bug Fixes
+
+- **allocation:** Added fix for batch token allocation ([11f7192](https://github.com/juspay/yama/commit/11f719257a75ba946c45612e336db69a17cf278d))
+
 # [1.5.0](https://github.com/juspay/yama/compare/v1.4.1...v1.5.0) (2025-09-19)
 
 ### Features

package/dist/core/providers/BitbucketProvider.js

@@ -5,6 +5,7 @@
 import { ProviderError, } from "../../types/index.js";
 import { logger } from "../../utils/Logger.js";
 import { cache, Cache } from "../../utils/Cache.js";
+import { RetryManager } from "../../utils/RetryManager.js";
 export class BitbucketProvider {
     apiClient;
     branchHandlers;
@@ -85,14 +86,14 @@ export class BitbucketProvider {
             throw new ProviderError("Branch name is required");
         }
         const cacheKey = Cache.keys.branchInfo(workspace, repository, branch);
-        return cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSetResilient(cacheKey, async () => {
             logger.debug(`Finding PR for branch: ${workspace}/${repository}@${branch}`);
-            const rawBranchData = await this.branchHandlers.handleGetBranch({
+            const rawBranchData = await RetryManager.withRetry(() => this.branchHandlers.handleGetBranch({
                 workspace,
                 repository,
                 branch_name: branch,
                 include_merged_prs: false,
-            });
+            }), `Find PR for branch ${workspace}/${repository}@${branch}`);
             const branchData = this.parseMCPResponse(rawBranchData);
             // Direct data extraction
             if (branchData.open_pull_requests &&
@@ -131,13 +132,13 @@ export class BitbucketProvider {
             throw new ProviderError("Pull request ID is required");
         }
         const cacheKey = Cache.keys.prInfo(workspace, repository, pullRequestId);
-        return cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSetResilient(cacheKey, async () => {
             logger.debug(`Getting PR details: ${workspace}/${repository}#${pullRequestId}`);
-            const rawPRDetails = await this.pullRequestHandlers.handleGetPullRequest({
+            const rawPRDetails = await RetryManager.withRetry(() => this.pullRequestHandlers.handleGetPullRequest({
                 workspace,
                 repository,
                 pull_request_id: pullRequestId,
-            });
+            }), `Get PR details ${workspace}/${repository}#${pullRequestId}`);
             const prData = this.parseMCPResponse(rawPRDetails);
             // Debug author data structure
             logger.debug(`PR Details author data structure: ${JSON.stringify(prData.author, null, 2)}`);
@@ -175,7 +176,7 @@ export class BitbucketProvider {
         const cacheKey = includePatterns && includePatterns.length === 1
             ? `file-diff:${workspace}:${repository}:${pullRequestId}:${includePatterns[0]}`
             : Cache.keys.prDiff(workspace, repository, pullRequestId);
-        return cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSetResilient(cacheKey, async () => {
             logger.debug(`Getting PR diff: ${workspace}/${repository}#${pullRequestId}`);
             if (includePatterns) {
                 logger.debug(`Include patterns: ${includePatterns.join(", ")}`);
@@ -191,7 +192,7 @@ export class BitbucketProvider {
             if (includePatterns) {
                 args.include_patterns = includePatterns;
             }
-            const rawDiff = await this.reviewHandlers.handleGetPullRequestDiff(args);
+            const rawDiff = await RetryManager.withRetry(() => this.reviewHandlers.handleGetPullRequestDiff(args), `Get PR diff ${workspace}/${repository}#${pullRequestId}`);
             const diffData = this.parseMCPResponse(rawDiff);
             return {
                 diff: diffData.diff || "",
@@ -207,18 +208,28 @@ export class BitbucketProvider {
     async getFileContent(workspace, repository, filePath, branch) {
         await this.initialize();
         const cacheKey = Cache.keys.fileContent(workspace, repository, filePath, branch);
-        return cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSetResilient(cacheKey, async () => {
             logger.debug(`Getting file content: ${workspace}/${repository}/${filePath}@${branch}`);
-            const result = await this.fileHandlers.handleGetFileContent({
+            const result = await RetryManager.withRetry(() => this.fileHandlers.handleGetFileContent({
                 workspace,
                 repository,
                 file_path: filePath,
                 branch,
-            });
-            // Handle file content response directly (don't JSON parse)
-            if (result.content && result.content[0] && result.content[0].text) {
-                const fileResponse = JSON.parse(result.content[0].text);
-                return fileResponse.content || "";
+            }), `Get file content ${workspace}/${repository}/${filePath}@${branch}`);
+            // Handle file content response with proper error handling for plain text files
+            if (result.content &&
+                result.content[0] &&
+                result.content[0].text) {
+                try {
+                    const fileResponse = JSON.parse(result.content[0].text);
+                    return fileResponse.content || "";
+                }
+                catch (parseError) {
+                    // If JSON parsing fails, the content might be plain text (like .clinerules)
+                    // Return the text content directly
+                    logger.debug(`JSON parsing failed for ${filePath}, treating as plain text: ${parseError.message}`);
+                    return result.content[0].text || "";
+                }
             }
             // Handle direct response format
             return result.content || "";
@@ -230,14 +241,14 @@ export class BitbucketProvider {
     async listDirectoryContent(workspace, repository, path, branch) {
         await this.initialize();
         const cacheKey = Cache.keys.directoryContent(workspace, repository, path, branch);
-        return cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSetResilient(cacheKey, async () => {
             logger.debug(`Listing directory: ${workspace}/${repository}/${path}@${branch}`);
-            const result = await this.fileHandlers.handleListDirectoryContent({
+            const result = await RetryManager.withRetry(() => this.fileHandlers.handleListDirectoryContent({
                 workspace,
                 repository,
                 path,
                 branch,
-            });
+            }), `List directory ${workspace}/${repository}/${path}@${branch}`);
             const dirData = this.parseMCPResponse(result);
             return dirData.contents || [];
         }, 3600);
@@ -254,12 +265,12 @@ export class BitbucketProvider {
         try {
             logger.debug(`Updating PR description: ${workspace}/${repository}#${pullRequestId}`);
             logger.debug(`Description length: ${description.length} characters`);
-            const result = await this.pullRequestHandlers.handleUpdatePullRequest({
+            const result = await RetryManager.withRetry(() => this.pullRequestHandlers.handleUpdatePullRequest({
                 workspace,
                 repository,
                 pull_request_id: pullRequestId,
                 description: description,
-            });
+            }), `Update PR description ${workspace}/${repository}#${pullRequestId}`);
             // Log the raw MCP response
             logger.debug(`Raw MCP update response: ${JSON.stringify(result, null, 2)}`);
             const updateData = this.parseMCPResponse(result);
@@ -335,10 +346,12 @@ export class BitbucketProvider {
                 logger.debug(`   Type: ${options.lineType || "CONTEXT"}`);
             }
             logger.debug(`🔍 MCP addComment args: ${JSON.stringify(args, null, 2)}`);
-            const result = await this.pullRequestHandlers.handleAddComment(args);
+            const result = await RetryManager.withRetry(() => this.pullRequestHandlers.handleAddComment(args), `Add comment to PR ${workspace}/${repository}#${pullRequestId}`);
             // Parse response exactly like pr-police.js
             let commentData;
-            if (result.content && result.content[0] && result.content[0].text) {
+            if (result.content &&
+                result.content[0] &&
+                result.content[0].text) {
                 commentData = JSON.parse(result.content[0].text);
             }
             else {
@@ -361,7 +374,7 @@ export class BitbucketProvider {
                         pull_request_id: pullRequestId,
                         comment_text: `**File: ${options.filePath}**\n\n${commentText}`,
                     };
-                    const fallbackResult = await this.pullRequestHandlers.handleAddComment(fallbackArgs);
+                    const fallbackResult = await RetryManager.withRetry(() => this.pullRequestHandlers.handleAddComment(fallbackArgs), `Add fallback comment to PR ${workspace}/${repository}#${pullRequestId}`);
                     let fallbackData;
                     if (fallbackResult.content &&
                         fallbackResult.content[0] &&

package/dist/features/CodeReviewer.d.ts

@@ -108,6 +108,18 @@ export declare class CodeReviewer {
      * Process batches serially (original implementation)
      */
     private processSerially;
+    /**
+     * Pre-allocate tokens based on distribution strategy with proper integer arithmetic
+     */
+    private preAllocateTokens;
+    /**
+     * Try weighted allocation for batches
+     */
+    private tryWeightedAllocation;
+    /**
+     * Try equal allocation for batches
+     */
+    private tryEqualAllocation;
     /**
      * Process a single batch with concurrency control
      */

package/dist/features/CodeReviewer.js

@@ -922,7 +922,25 @@ ${recommendation}
         // Initialize concurrency control
         const semaphore = new Semaphore(optimalConcurrency);
         const tokenBudget = new TokenBudgetManager(this.getSafeTokenLimit() * 0.8); // 80% for safety
-        logger.info(`🎯 Parallel processing: ${optimalConcurrency} concurrent batches, ${tokenBudget.getTotalBudget()} token budget`);
+        // NEW: Pre-allocate tokens based on distribution strategy
+        const distributionStrategy = parallelConfig.tokenBudgetDistribution || "equal";
+        logger.info(`🎯 Using ${distributionStrategy} token distribution strategy for ${batches.length} batches`);
+        const tokenAllocations = this.preAllocateTokens(batches, tokenBudget, distributionStrategy);
+        if (!tokenAllocations) {
+            const totalRequired = batches.reduce((sum, b) => sum + b.estimatedTokens, 0);
+            const totalBudget = tokenBudget.getTotalBudget();
+            throw new Error(`Insufficient token budget: required ${totalRequired}, available ${totalBudget}. ` +
+                `Consider reducing batch count (current: ${batches.length}) or increasing token limit.`);
+        }
+        // Apply pre-allocated tokens to the budget manager
+        if (!tokenBudget.preAllocateAllBatches(tokenAllocations)) {
+            throw new Error("Failed to pre-allocate tokens for all batches");
+        }
+        logger.info(`🎯 Parallel processing: ${optimalConcurrency} concurrent batches, ${tokenBudget.getTotalBudget()} token budget (${distributionStrategy} distribution)`);
+        // Log allocation details
+        tokenAllocations.forEach((tokens, batchIndex) => {
+            logger.debug(`Batch ${batchIndex + 1}: ${tokens} tokens allocated`);
+        });
         const batchResults = new Array(batches.length);
         const allViolations = [];
         const processingPromises = [];
@@ -1006,6 +1024,149 @@ ${recommendation}
         logger.success(`🎯 Serial processing completed: ${allViolations.length} total violations from ${batches.length} batches in ${Math.round(totalTime / 1000)}s (avg ${avgBatchSize.toFixed(1)} files/batch)`);
         return { violations: allViolations, batchResults };
     }
+    /**
+     * Pre-allocate tokens based on distribution strategy with proper integer arithmetic
+     */
+    preAllocateTokens(batches, tokenBudget, strategy) {
+        // Ensure we're working with integer budget to avoid floating-point issues
+        const totalBudget = Math.floor(tokenBudget.getTotalBudget());
+        const allocations = new Map();
+        if (strategy === "equal") {
+            // Equal distribution: divide budget equally among all batches with proper remainder handling
+            const baseTokens = Math.floor(totalBudget / batches.length);
+            const remainder = totalBudget % batches.length;
+            if (baseTokens < 1000) {
+                // Minimum viable tokens per batch
+                logger.error(`Equal distribution would give ${baseTokens} tokens per batch, which is insufficient`);
+                return null;
+            }
+            let totalAllocated = 0;
+            for (let i = 0; i < batches.length; i++) {
+                // Distribute remainder to first few batches
+                const tokens = baseTokens + (i < remainder ? 1 : 0);
+                allocations.set(i, tokens);
+                totalAllocated += tokens;
+            }
+            // Double-check that we haven't exceeded budget due to any calculation errors
+            if (totalAllocated > totalBudget) {
+                logger.error(`Equal distribution calculation error: ${totalAllocated} > ${totalBudget}`);
+                // Adjust the last batch to fit within budget
+                const lastBatchIndex = batches.length - 1;
+                const lastBatchTokens = allocations.get(lastBatchIndex);
+                const adjustment = totalAllocated - totalBudget;
+                const newLastBatchTokens = lastBatchTokens - adjustment;
+                if (newLastBatchTokens < 1000) {
+                    logger.error(`Adjustment would result in last batch having ${newLastBatchTokens} tokens, which is below the minimum threshold (1000). Aborting allocation.`);
+                    return null;
+                }
+                allocations.set(lastBatchIndex, newLastBatchTokens);
+                totalAllocated = totalBudget;
+                logger.warn(`Adjusted last batch by -${adjustment} tokens to fit budget`);
+            }
+            logger.info(`Equal distribution: ${baseTokens} tokens per batch for ${batches.length} batches`);
+            logger.debug(`Pre-allocated ${totalAllocated} tokens across ${batches.length} batches (${totalBudget - totalAllocated} remaining)`);
+        }
+        else if (strategy === "weighted") {
+            // Weighted distribution: try weighted first, automatically fallback to equal if needed
+            logger.debug(`Attempting weighted distribution...`);
+            const weightedResult = this.tryWeightedAllocation(batches, totalBudget);
+            if (weightedResult) {
+                // Weighted allocation succeeded
+                weightedResult.forEach((tokens, batchIndex) => {
+                    allocations.set(batchIndex, tokens);
+                });
+                logger.info(`✅ Weighted distribution: optimal allocation successful`);
+                logger.debug(`Pre-allocated ${Array.from(weightedResult.values()).reduce((sum, tokens) => sum + tokens, 0)} tokens across ${batches.length} batches`);
+            }
+            else {
+                // Weighted allocation failed, automatically fallback to equal distribution
+                logger.warn(`⚠️ Weighted distribution: insufficient budget for optimal allocation, falling back to equal distribution`);
+                const equalResult = this.tryEqualAllocation(batches, totalBudget);
+                if (!equalResult) {
+                    logger.error(`Weighted distribution: both optimal and equal allocation failed`);
+                    return null;
+                }
+                equalResult.forEach((tokens, batchIndex) => {
+                    allocations.set(batchIndex, tokens);
+                });
+                logger.info(`✅ Weighted distribution: equal allocation fallback successful`);
+                logger.debug(`Pre-allocated ${Array.from(equalResult.values()).reduce((sum, tokens) => sum + tokens, 0)} tokens across ${batches.length} batches`);
+            }
+        }
+        // Final validation with strict integer checking
+        const totalAllocated = Array.from(allocations.values()).reduce((sum, tokens) => sum + tokens, 0);
+        if (totalAllocated > totalBudget) {
+            logger.error(`CRITICAL: Total allocation (${totalAllocated}) exceeds budget (${totalBudget}) - this should never happen`);
+            logger.error(`Budget type: ${typeof totalBudget}, Allocation type: ${typeof totalAllocated}`);
+            logger.error(`Individual allocations: ${Array.from(allocations.entries())
+                .map(([i, tokens]) => `batch${i}:${tokens}`)
+                .join(", ")}`);
+            throw new Error(`Total allocation (${totalAllocated}) exceeds budget (${totalBudget}) - this should never happen`);
+        }
+        return allocations;
+    }
+    /**
+     * Try weighted allocation for batches
+     */
+    tryWeightedAllocation(batches, totalBudget) {
+        const totalEstimated = batches.reduce((sum, batch) => sum + batch.estimatedTokens, 0);
+        if (totalEstimated > totalBudget) {
+            logger.debug(`Total estimated tokens (${totalEstimated}) exceed budget (${totalBudget})`);
+            return null;
+        }
+        let totalAllocated = 0;
+        const minTokensPerBatch = 1000;
+        const allocations = new Map();
+        for (let i = 0; i < batches.length; i++) {
+            const batch = batches[i];
+            const weight = batch.estimatedTokens / totalEstimated;
+            const allocation = Math.floor(weight * totalBudget);
+            const finalAllocation = Math.max(allocation, minTokensPerBatch);
+            allocations.set(i, finalAllocation);
+            totalAllocated += finalAllocation;
+        }
+        // Check if we exceeded budget due to minimum allocations
+        if (totalAllocated > totalBudget) {
+            logger.debug(`Weighted allocation with minimums (${totalAllocated}) exceeds budget (${totalBudget})`);
+            return null;
+        }
+        return allocations;
+    }
+    /**
+     * Try equal allocation for batches
+     */
+    tryEqualAllocation(batches, totalBudget) {
+        const baseTokens = Math.floor(totalBudget / batches.length);
+        const remainder = totalBudget % batches.length;
+        if (baseTokens < 1000) {
+            // Minimum viable tokens per batch
+            logger.debug(`Equal distribution would give ${baseTokens} tokens per batch, which is insufficient`);
+            return null;
+        }
+        const allocations = new Map();
+        let totalAllocated = 0;
+        for (let i = 0; i < batches.length; i++) {
+            // Distribute remainder to first few batches
+            const tokens = baseTokens + (i < remainder ? 1 : 0);
+            allocations.set(i, tokens);
+            totalAllocated += tokens;
+        }
+        // Double-check that we haven't exceeded budget due to any calculation errors
+        if (totalAllocated > totalBudget) {
+            logger.debug(`Equal distribution calculation error: ${totalAllocated} > ${totalBudget}`);
+            // Adjust the last batch to fit within budget
+            const lastBatchIndex = batches.length - 1;
+            const lastBatchTokens = allocations.get(lastBatchIndex);
+            const adjustment = totalAllocated - totalBudget;
+            const newLastBatchTokens = lastBatchTokens - adjustment;
+            if (newLastBatchTokens < 1000) {
+                logger.error(`Adjustment would result in last batch having ${newLastBatchTokens} tokens, which is below the minimum threshold (1000). Aborting allocation.`);
+                return null;
+            }
+            allocations.set(lastBatchIndex, newLastBatchTokens);
+        }
+        return allocations;
+    }
     /**
      * Process a single batch with concurrency control
      */
@@ -1013,9 +1174,22 @@ ${recommendation}
         // Acquire semaphore permit
         await semaphore.acquire();
         try {
-            // Check token budget
-            if (!tokenBudget.allocateForBatch(batchIndex, batch.estimatedTokens)) {
-                throw new Error(`Insufficient token budget for batch ${batchIndex + 1}`);
+            // NEW: In pre-allocation mode, tokens are already allocated, just verify and mark as processing
+            if (tokenBudget.isPreAllocationMode()) {
+                const batchState = tokenBudget.getBatchState(batchIndex);
+                if (batchState !== "pending") {
+                    throw new Error(`Batch ${batchIndex + 1} is not in pending state (current: ${batchState})`);
+                }
+                // Mark as processing (this is handled in allocateForBatch for pre-allocation mode)
+                if (!tokenBudget.allocateForBatch(batchIndex, batch.estimatedTokens)) {
+                    throw new Error(`Failed to mark batch ${batchIndex + 1} as processing`);
+                }
+            }
+            else {
+                // Legacy mode: allocate tokens dynamically
+                if (!tokenBudget.allocateForBatch(batchIndex, batch.estimatedTokens)) {
+                    throw new Error(`Insufficient token budget for batch ${batchIndex + 1}`);
+                }
             }
             logger.info(`🔄 Processing batch ${batchIndex + 1}/${totalBatches} (${batch.files.length} files, parallel)`);
             // Process the batch (existing logic)
@@ -1023,6 +1197,11 @@ ${recommendation}
             logger.info(`✅ Batch ${batchIndex + 1} completed: ${result.violations.length} violations in ${Math.round(result.processingTime / 1000)}s`);
             return result;
         }
+        catch (error) {
+            // Mark batch as failed in token budget
+            tokenBudget.markBatchFailed(batchIndex, error.message);
+            throw error;
+        }
         finally {
             // Always release resources
             tokenBudget.releaseBatch(batchIndex);

package/dist/features/MultiInstanceProcessor.js

@@ -237,8 +237,9 @@ export class MultiInstanceProcessor {
             minLimit = Math.min(minLimit, instanceLimit);
         }
         // Total budget is the sum of all instance limits, but with safety margin
-        const totalBudget = instances.length * minLimit * 0.8; // 80% safety margin
-        logger.debug(`Calculated total token budget: ${totalBudget} (${instances.length} instances × ${minLimit} × 0.8)`);
+        // Use Math.floor to ensure integer result and avoid floating-point precision issues
+        const totalBudget = Math.floor(instances.length * minLimit * 0.8); // 80% safety margin
+        logger.debug(`Calculated total token budget: ${totalBudget} (${instances.length} instances × ${minLimit} × 0.8, floored)`);
         return totalBudget;
     }
     /**

package/dist/types/index.d.ts

@@ -569,6 +569,7 @@ export interface TokenBudgetManagerInterface {
     getAvailableBudget(): number;
     getTotalBudget(): number;
     getUsedTokens(): number;
+    preAllocateAllBatches(allocations: Map<number, number>): boolean;
 }
 export declare class GuardianError extends Error {
     code: string;
@@ -584,4 +585,40 @@ export declare class ProviderError extends GuardianError {
 export declare class ValidationError extends GuardianError {
     constructor(message: string, context?: any);
 }
+export declare enum CacheErrorCode {
+    CACHE_SYSTEM_FAILURE = "CACHE_SYSTEM_FAILURE",
+    CACHE_MEMORY_EXHAUSTED = "CACHE_MEMORY_EXHAUSTED",
+    CACHE_INITIALIZATION_FAILED = "CACHE_INITIALIZATION_FAILED",
+    CACHE_STORAGE_FULL = "CACHE_STORAGE_FULL",
+    CACHE_STORAGE_PERMISSION = "CACHE_STORAGE_PERMISSION",
+    CACHE_STORAGE_CORRUPTION = "CACHE_STORAGE_CORRUPTION",
+    CACHE_NETWORK_CONNECTION = "CACHE_NETWORK_CONNECTION",
+    CACHE_NETWORK_TIMEOUT = "CACHE_NETWORK_TIMEOUT",
+    CACHE_NETWORK_AUTH = "CACHE_NETWORK_AUTH",
+    CACHE_CONFIG_INVALID = "CACHE_CONFIG_INVALID",
+    CACHE_CONFIG_MISSING = "CACHE_CONFIG_MISSING",
+    CACHE_OPERATION_FAILED = "CACHE_OPERATION_FAILED",
+    CACHE_SERIALIZATION_ERROR = "CACHE_SERIALIZATION_ERROR",
+    CACHE_KEY_INVALID = "CACHE_KEY_INVALID"
+}
+export declare abstract class CacheError extends GuardianError {
+    operation?: string | undefined;
+    key?: string | undefined;
+    constructor(code: CacheErrorCode, message: string, operation?: string | undefined, key?: string | undefined, context?: any);
+}
+export declare class CacheSystemError extends CacheError {
+    constructor(message: string, operation?: string, key?: string, context?: any);
+}
+export declare class CacheStorageError extends CacheError {
+    constructor(code: CacheErrorCode | undefined, message: string, operation?: string, key?: string, context?: any);
+}
+export declare class CacheNetworkError extends CacheError {
+    constructor(code: CacheErrorCode | undefined, message: string, operation?: string, key?: string, context?: any);
+}
+export declare class CacheConfigurationError extends CacheError {
+    constructor(code: CacheErrorCode | undefined, message: string, operation?: string, key?: string, context?: any);
+}
+export declare class CacheOperationError extends CacheError {
+    constructor(code: CacheErrorCode | undefined, message: string, operation?: string, key?: string, context?: any);
+}
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -34,6 +34,71 @@ export class ValidationError extends GuardianError {
     }
 }
 // ============================================================================
+// Cache Error Types
+// ============================================================================
+export var CacheErrorCode;
+(function (CacheErrorCode) {
+    // System-level cache errors
+    CacheErrorCode["CACHE_SYSTEM_FAILURE"] = "CACHE_SYSTEM_FAILURE";
+    CacheErrorCode["CACHE_MEMORY_EXHAUSTED"] = "CACHE_MEMORY_EXHAUSTED";
+    CacheErrorCode["CACHE_INITIALIZATION_FAILED"] = "CACHE_INITIALIZATION_FAILED";
+    // Storage-related errors
+    CacheErrorCode["CACHE_STORAGE_FULL"] = "CACHE_STORAGE_FULL";
+    CacheErrorCode["CACHE_STORAGE_PERMISSION"] = "CACHE_STORAGE_PERMISSION";
+    CacheErrorCode["CACHE_STORAGE_CORRUPTION"] = "CACHE_STORAGE_CORRUPTION";
+    // Network-related errors (for future Redis support)
+    CacheErrorCode["CACHE_NETWORK_CONNECTION"] = "CACHE_NETWORK_CONNECTION";
+    CacheErrorCode["CACHE_NETWORK_TIMEOUT"] = "CACHE_NETWORK_TIMEOUT";
+    CacheErrorCode["CACHE_NETWORK_AUTH"] = "CACHE_NETWORK_AUTH";
+    // Configuration errors
+    CacheErrorCode["CACHE_CONFIG_INVALID"] = "CACHE_CONFIG_INVALID";
+    CacheErrorCode["CACHE_CONFIG_MISSING"] = "CACHE_CONFIG_MISSING";
+    // Operation errors
+    CacheErrorCode["CACHE_OPERATION_FAILED"] = "CACHE_OPERATION_FAILED";
+    CacheErrorCode["CACHE_SERIALIZATION_ERROR"] = "CACHE_SERIALIZATION_ERROR";
+    CacheErrorCode["CACHE_KEY_INVALID"] = "CACHE_KEY_INVALID";
+})(CacheErrorCode || (CacheErrorCode = {}));
+export class CacheError extends GuardianError {
+    operation;
+    key;
+    constructor(code, message, operation, key, context) {
+        super(code, message, context);
+        this.operation = operation;
+        this.key = key;
+        this.name = "CacheError";
+    }
+}
+export class CacheSystemError extends CacheError {
+    constructor(message, operation, key, context) {
+        super(CacheErrorCode.CACHE_SYSTEM_FAILURE, message, operation, key, context);
+        this.name = "CacheSystemError";
+    }
+}
+export class CacheStorageError extends CacheError {
+    constructor(code = CacheErrorCode.CACHE_STORAGE_FULL, message, operation, key, context) {
+        super(code, message, operation, key, context);
+        this.name = "CacheStorageError";
+    }
+}
+export class CacheNetworkError extends CacheError {
+    constructor(code = CacheErrorCode.CACHE_NETWORK_CONNECTION, message, operation, key, context) {
+        super(code, message, operation, key, context);
+        this.name = "CacheNetworkError";
+    }
+}
+export class CacheConfigurationError extends CacheError {
+    constructor(code = CacheErrorCode.CACHE_CONFIG_INVALID, message, operation, key, context) {
+        super(code, message, operation, key, context);
+        this.name = "CacheConfigurationError";
+    }
+}
+export class CacheOperationError extends CacheError {
+    constructor(code = CacheErrorCode.CACHE_OPERATION_FAILED, message, operation, key, context) {
+        super(code, message, operation, key, context);
+        this.name = "CacheOperationError";
+    }
+}
+// ============================================================================
 // Export all types - Main file, no re-exports needed
 // ============================================================================
 //# sourceMappingURL=index.js.map

package/dist/utils/Cache.d.ts

@@ -8,7 +8,7 @@ export declare class Cache implements ICache {
     private statsData;
     constructor(options?: CacheOptions);
     /**
-     * Get value from cache
+     * Get value from cache with resilient error handling
      */
     get<T>(key: string): T | undefined;
     /**
@@ -39,15 +39,21 @@ export declare class Cache implements ICache {
         misses: number;
         keys: number;
         size: number;
+        cacheErrors: number;
+        nonCacheErrors: number;
     };
     /**
      * Get detailed cache statistics from node-cache
      */
     getDetailedStats(): any;
     /**
-     * Get or set pattern - common caching pattern
+     * Get or set pattern with automatic fallback on cache failures
      */
     getOrSet<T>(key: string, fetchFn: () => Promise<T>, ttl?: number): Promise<T>;
+    /**
+     * Resilient get or set pattern that bypasses cache entirely on cache system failures
+     */
+    getOrSetResilient<T>(key: string, fetchFn: () => Promise<T>, ttl?: number): Promise<T>;
     /**
      * Cache with tags for group invalidation
      */

package/dist/utils/Cache.js

@@ -3,12 +3,146 @@
  * Provides intelligent caching for PR data, file contents, and AI responses
  */
 import NodeCache from "node-cache";
+import { CacheError, } from "../types/index.js";
 import { logger } from "./Logger.js";
+/**
+ * Enhanced cache error detection utility
+ * Provides multi-layer error classification to avoid false positives
+ */
+class CacheErrorDetector {
+    /**
+     * Detect if an error is cache-related using multiple strategies
+     */
+    static isCacheError(error, operation, key) {
+        // Strategy 1: Check error type/class (most reliable)
+        if (error instanceof CacheError) {
+            return true;
+        }
+        // Strategy 2: Check for specific cache error patterns in NodeCache
+        if (error instanceof Error) {
+            const errorMessage = error.message.toLowerCase();
+            const stackTrace = error.stack?.toLowerCase() || "";
+            // Check for NodeCache-specific error patterns
+            const nodeCachePatterns = [
+                /node_modules\/node-cache/,
+                /cache\.js:\d+/,
+                /nodecache/,
+            ];
+            const isNodeCacheError = nodeCachePatterns.some((pattern) => pattern.test(stackTrace));
+            if (isNodeCacheError) {
+                return true;
+            }
+            // Strategy 3: Check for specific cache-related error messages (more targeted)
+            const cacheSpecificPatterns = [
+                /cache.*(?:full|exhausted|limit)/,
+                /memory.*(?:cache|allocation).*(?:failed|error)/,
+                /storage.*(?:cache|quota).*(?:exceeded|full)/,
+                /cache.*(?:initialization|setup).*(?:failed|error)/,
+                /ttl.*(?:invalid|expired)/,
+                /cache.*(?:key|value).*(?:invalid|malformed)/,
+            ];
+            const hasCacheSpecificError = cacheSpecificPatterns.some((pattern) => pattern.test(errorMessage));
+            if (hasCacheSpecificError) {
+                return true;
+            }
+            // Strategy 4: Context-aware detection
+            if (operation && key) {
+                // If we're in a cache operation and get memory/storage errors, likely cache-related
+                const cacheOperations = [
+                    "get",
+                    "set",
+                    "del",
+                    "clear",
+                    "has",
+                    "getorset",
+                    "getorsetresilient",
+                ];
+                const isCacheOperation = cacheOperations.includes(operation.toLowerCase());
+                const contextualPatterns = [
+                    /^out of memory$/,
+                    /storage quota exceeded/,
+                    /disk full/,
+                ];
+                if (isCacheOperation &&
+                    contextualPatterns.some((pattern) => pattern.test(errorMessage))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Classify cache error for better handling and logging
+     */
+    static classifyError(error, operation, key) {
+        if (!this.isCacheError(error, operation, key)) {
+            return {
+                isCache: false,
+                category: "unknown",
+                confidence: "high",
+                reason: "Not identified as cache-related error",
+            };
+        }
+        if (error instanceof CacheError) {
+            const category = error.code.includes("STORAGE")
+                ? "storage"
+                : error.code.includes("NETWORK")
+                    ? "network"
+                    : error.code.includes("SYSTEM")
+                        ? "system"
+                        : "operation";
+            return {
+                isCache: true,
+                category,
+                confidence: "high",
+                reason: `Explicit cache error: ${error.code}`,
+            };
+        }
+        if (error instanceof Error) {
+            const message = error.message.toLowerCase();
+            const stack = error.stack?.toLowerCase() || "";
+            // High confidence patterns
+            if (/node_modules\/node-cache/.test(stack)) {
+                return {
+                    isCache: true,
+                    category: "system",
+                    confidence: "high",
+                    reason: "NodeCache stack trace detected",
+                };
+            }
+            // Medium confidence patterns
+            if (/cache.*(?:full|exhausted)/.test(message)) {
+                return {
+                    isCache: true,
+                    category: "storage",
+                    confidence: "medium",
+                    reason: "Cache capacity error pattern",
+                };
+            }
+            if (/memory.*cache.*failed/.test(message)) {
+                return {
+                    isCache: true,
+                    category: "system",
+                    confidence: "medium",
+                    reason: "Memory allocation error in cache context",
+                };
+            }
+        }
+        return {
+            isCache: true,
+            category: "unknown",
+            confidence: "low",
+            reason: "Fallback detection",
+        };
+    }
+}
 export class Cache {
     cache;
     statsData = {
         hits: 0,
         misses: 0,
+        cacheErrors: 0,
+        nonCacheErrors: 0,
     };
     constructor(options = {}) {
         const { ttl = 3600, // 1 hour default
@@ -33,18 +167,25 @@ export class Cache {
         });
     }
     /**
-     * Get value from cache
+     * Get value from cache with resilient error handling
      */
     get(key) {
-        const value = this.cache.get(key);
-        if (value !== undefined) {
-            this.statsData.hits++;
-            logger.debug(`Cache HIT: ${key}`);
-            return value;
+        try {
+            const value = this.cache.get(key);
+            if (value !== undefined) {
+                this.statsData.hits++;
+                logger.debug(`Cache HIT: ${key}`);
+                return value;
+            }
+            else {
+                this.statsData.misses++;
+                logger.debug(`Cache MISS: ${key}`);
+                return undefined;
+            }
         }
-        else {
+        catch (error) {
             this.statsData.misses++;
-            logger.debug(`Cache MISS: ${key}`);
+            logger.warn(`Cache GET error for ${key}, treating as miss:`, error);
             return undefined;
         }
     }
@@ -105,6 +246,8 @@ export class Cache {
             misses: this.statsData.misses,
             keys: this.cache.keys().length,
             size: this.cache.getStats().keys,
+            cacheErrors: this.statsData.cacheErrors,
+            nonCacheErrors: this.statsData.nonCacheErrors,
         };
     }
     /**
@@ -114,9 +257,10 @@ export class Cache {
         return this.cache.getStats();
     }
     /**
-     * Get or set pattern - common caching pattern
+     * Get or set pattern with automatic fallback on cache failures
      */
     async getOrSet(key, fetchFn, ttl) {
+        // Try to get from cache with resilient error handling
         const cached = this.get(key);
         if (cached !== undefined) {
             return cached;
@@ -124,7 +268,13 @@ export class Cache {
         try {
             logger.debug(`Cache FETCH: ${key}`);
             const value = await fetchFn();
-            this.set(key, value, ttl);
+            // Try to cache the result, but don't fail if caching fails
+            try {
+                this.set(key, value, ttl);
+            }
+            catch (cacheError) {
+                logger.warn(`Cache SET failed for ${key}, continuing without cache:`, cacheError);
+            }
             return value;
         }
         catch (error) {
@@ -132,6 +282,36 @@ export class Cache {
             throw error;
         }
     }
+    /**
+     * Resilient get or set pattern that bypasses cache entirely on cache system failures
+     */
+    async getOrSetResilient(key, fetchFn, ttl) {
+        try {
+            // Try normal cache flow first
+            return await this.getOrSet(key, fetchFn, ttl);
+        }
+        catch (error) {
+            // Use enhanced error detection to determine if this is a cache-related error
+            const errorClassification = CacheErrorDetector.classifyError(error, "getOrSet", key);
+            if (errorClassification.isCache) {
+                // Track cache error statistics
+                this.statsData.cacheErrors++;
+                logger.warn(`Cache system error detected for ${key} (${errorClassification.confidence} confidence: ${errorClassification.reason}), bypassing cache entirely`, {
+                    error: error instanceof Error ? error.message : String(error),
+                    category: errorClassification.category,
+                    confidence: errorClassification.confidence,
+                    key,
+                    operation: "getOrSet",
+                });
+                // Bypass cache completely and just fetch the data
+                return await fetchFn();
+            }
+            // Track non-cache errors for debugging
+            this.statsData.nonCacheErrors++;
+            // Re-throw non-cache errors
+            throw error;
+        }
+    }
     /**
      * Cache with tags for group invalidation
      */

package/dist/utils/ParallelProcessing.d.ts

@@ -46,6 +46,9 @@ export declare class TokenBudgetManager implements TokenBudgetManagerInterface {
     private usedTokens;
     private batchAllocations;
     private reservedTokens;
+    private preAllocationMode;
+    private preAllocatedBatches;
+    private batchStates;
     constructor(totalBudget: number);
     /**
      * Allocate tokens for a specific batch
@@ -92,6 +95,31 @@ export declare class TokenBudgetManager implements TokenBudgetManagerInterface {
      * Reset the budget manager (for testing or reuse)
      */
     reset(): void;
+    /**
+     * Pre-allocate tokens for all batches upfront
+     * This ensures all batches have guaranteed token allocation before processing starts
+     */
+    preAllocateAllBatches(allocations: Map<number, number>): boolean;
+    /**
+     * Mark a batch as failed and handle cleanup
+     */
+    markBatchFailed(batchIndex: number, error?: string): void;
+    /**
+     * Get the current state of a batch
+     */
+    getBatchState(batchIndex: number): "pending" | "processing" | "completed" | "failed" | undefined;
+    /**
+     * Check if pre-allocation mode is active
+     */
+    isPreAllocationMode(): boolean;
+    /**
+     * Get all batch states for debugging
+     */
+    getAllBatchStates(): Map<number, "pending" | "processing" | "completed" | "failed">;
+    /**
+     * Disable pre-allocation mode and clean up
+     */
+    disablePreAllocationMode(): void;
     /**
      * Update the total budget (useful for dynamic adjustment)
      */

package/dist/utils/ParallelProcessing.js

@@ -77,12 +77,18 @@ export class TokenBudgetManager {
     usedTokens = 0;
     batchAllocations = new Map();
     reservedTokens = 0; // Tokens allocated but not yet used
+    // NEW: Pre-allocation mode tracking
+    preAllocationMode = false;
+    preAllocatedBatches = new Set();
+    batchStates = new Map();
     constructor(totalBudget) {
         if (totalBudget <= 0) {
             throw new Error("Token budget must be greater than 0");
         }
-        this.totalBudget = totalBudget;
-        logger.debug(`TokenBudgetManager created with budget of ${totalBudget} tokens`);
+        // Floor the budget to ensure integer arithmetic and avoid floating-point precision issues.
+        // The fractional part is discarded, so the budget is always rounded down.
+        this.totalBudget = Math.floor(totalBudget);
+        logger.debug(`TokenBudgetManager created with budget of ${this.totalBudget} tokens (original: ${totalBudget})`);
     }
     /**
      * Allocate tokens for a specific batch
@@ -93,8 +99,31 @@ export class TokenBudgetManager {
             logger.warn(`Invalid token estimate for batch ${batchIndex}: ${estimatedTokens}`);
             return false;
         }
-        // Check if we already have an allocation for this batch
+        // NEW: Handle pre-allocation mode
+        if (this.preAllocationMode && this.preAllocatedBatches.has(batchIndex)) {
+            // Check if batch is already being processed
+            const currentState = this.batchStates.get(batchIndex);
+            if (currentState === "processing") {
+                logger.warn(`Batch ${batchIndex} is already being processed`);
+                return false;
+            }
+            if (currentState !== "pending") {
+                logger.warn(`Batch ${batchIndex} is not in pending state (current: ${currentState})`);
+                return false;
+            }
+            // In pre-allocation mode, just mark batch as processing and return success
+            this.batchStates.set(batchIndex, "processing");
+            logger.debug(`Batch ${batchIndex} using pre-allocated tokens (${this.batchAllocations.get(batchIndex)} tokens)`);
+            return true;
+        }
+        // Check if we already have an allocation for this batch (non-pre-allocation mode)
         if (this.batchAllocations.has(batchIndex)) {
+            // Check if batch is already being processed
+            const currentState = this.batchStates.get(batchIndex);
+            if (currentState === "processing") {
+                logger.warn(`Batch ${batchIndex} is already being processed`);
+                return false;
+            }
             logger.warn(`Batch ${batchIndex} already has token allocation`);
             return false;
         }
@@ -108,6 +137,7 @@ export class TokenBudgetManager {
         // Allocate the tokens
         this.reservedTokens += estimatedTokens;
         this.batchAllocations.set(batchIndex, estimatedTokens);
+        this.batchStates.set(batchIndex, "processing");
         logger.debug(`Allocated ${estimatedTokens} tokens for batch ${batchIndex} ` +
             `(${this.getAvailableBudget()} remaining)`);
         return true;
@@ -122,10 +152,19 @@ export class TokenBudgetManager {
             logger.warn(`No token allocation found for batch ${batchIndex}`);
             return;
         }
+        // Update batch state to completed only if not already failed
+        const currentState = this.batchStates.get(batchIndex);
+        if (currentState !== "failed") {
+            this.batchStates.set(batchIndex, "completed");
+        }
         // Move from reserved to used (assuming the tokens were actually used)
         this.reservedTokens -= allocated;
         this.usedTokens += allocated;
         this.batchAllocations.delete(batchIndex);
+        // Clean up pre-allocation tracking
+        if (this.preAllocationMode) {
+            this.preAllocatedBatches.delete(batchIndex);
+        }
         logger.debug(`Released ${allocated} tokens from batch ${batchIndex} ` +
             `(${this.getAvailableBudget()} now available)`);
     }
@@ -182,6 +221,72 @@ export class TokenBudgetManager {
         this.batchAllocations.clear();
         logger.debug("TokenBudgetManager reset");
     }
+    /**
+     * Pre-allocate tokens for all batches upfront
+     * This ensures all batches have guaranteed token allocation before processing starts
+     */
+    preAllocateAllBatches(allocations) {
+        const totalRequired = Array.from(allocations.values()).reduce((sum, tokens) => sum + tokens, 0);
+        if (totalRequired > this.totalBudget) {
+            logger.error(`Pre-allocation failed: total required (${totalRequired}) exceeds budget (${this.totalBudget})`);
+            return false;
+        }
+        // Clear any existing allocations and reset state
+        this.batchAllocations.clear();
+        this.reservedTokens = 0;
+        this.batchStates.clear();
+        this.preAllocatedBatches.clear();
+        // Enable pre-allocation mode
+        this.preAllocationMode = true;
+        // Reserve all tokens upfront
+        allocations.forEach((tokens, batchIndex) => {
+            this.batchAllocations.set(batchIndex, tokens);
+            this.reservedTokens += tokens;
+            this.preAllocatedBatches.add(batchIndex);
+            this.batchStates.set(batchIndex, "pending");
+        });
+        logger.info(`Pre-allocated ${totalRequired} tokens across ${allocations.size} batches ` +
+            `(${this.getAvailableBudget()} remaining)`);
+        return true;
+    }
+    /**
+     * Mark a batch as failed and handle cleanup
+     */
+    markBatchFailed(batchIndex, error) {
+        this.batchStates.set(batchIndex, "failed");
+        if (error) {
+            logger.debug(`Batch ${batchIndex} marked as failed: ${error}`);
+        }
+        else {
+            logger.debug(`Batch ${batchIndex} marked as failed`);
+        }
+    }
+    /**
+     * Get the current state of a batch
+     */
+    getBatchState(batchIndex) {
+        return this.batchStates.get(batchIndex);
+    }
+    /**
+     * Check if pre-allocation mode is active
+     */
+    isPreAllocationMode() {
+        return this.preAllocationMode;
+    }
+    /**
+     * Get all batch states for debugging
+     */
+    getAllBatchStates() {
+        return new Map(this.batchStates);
+    }
+    /**
+     * Disable pre-allocation mode and clean up
+     */
+    disablePreAllocationMode() {
+        this.preAllocationMode = false;
+        this.preAllocatedBatches.clear();
+        logger.debug("Pre-allocation mode disabled");
+    }
     /**
      * Update the total budget (useful for dynamic adjustment)
      */

package/dist/utils/RetryManager.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Retry Manager for Yama
+ * Provides intelligent retry logic with exponential backoff for handling transient failures
+ */
+export interface RetryOptions {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    backoffMultiplier?: number;
+    jitterMs?: number;
+    retryableErrors?: string[];
+}
+export interface RetryContext {
+    operation: string;
+    attempt: number;
+    maxAttempts: number;
+    lastError?: Error;
+    totalElapsed: number;
+}
+export declare class RetryManager {
+    private static readonly DEFAULT_OPTIONS;
+    /**
+     * Execute an operation with retry logic
+     */
+    static withRetry<T>(operation: () => Promise<T>, context: string, options?: RetryOptions): Promise<T>;
+    /**
+     * Check if an error is retryable based on error patterns
+     */
+    private static isRetryableError;
+    /**
+     * Calculate delay with exponential backoff and jitter
+     */
+    private static calculateDelay;
+    /**
+     * Sleep for specified milliseconds
+     */
+    private static sleep;
+    /**
+     * Create a retry wrapper function for a specific operation
+     */
+    static createRetryWrapper<T extends any[], R>(fn: (...args: T) => Promise<R>, context: string, options?: RetryOptions): (...args: T) => Promise<R>;
+    /**
+     * Batch retry operations with individual retry logic
+     */
+    static batchWithRetry<T>(operations: Array<{
+        fn: () => Promise<T>;
+        context: string;
+    }>, options?: RetryOptions & {
+        continueOnError?: boolean;
+    }): Promise<Array<{
+        success: boolean;
+        data?: T;
+        error?: Error;
+        context: string;
+    }>>;
+    /**
+     * Get retry statistics for monitoring
+     */
+    static getRetryStats(results: Array<{
+        success: boolean;
+        context: string;
+    }>): {
+        total: number;
+        successful: number;
+        failed: number;
+        successRate: number;
+        failuresByContext: Record<string, number>;
+    };
+    /**
+     * Create a circuit breaker pattern (simple implementation)
+     */
+    static createCircuitBreaker<T extends any[], R>(fn: (...args: T) => Promise<R>, context: string, options?: {
+        failureThreshold?: number;
+        recoveryTimeoutMs?: number;
+        retryOptions?: RetryOptions;
+    }): (...args: T) => Promise<R>;
+}
+//# sourceMappingURL=RetryManager.d.ts.map

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.5.0",
+  "version": "1.5.1",
   "description": "Enterprise-grade Pull Request automation toolkit with AI-powered code review and description enhancement",
   "keywords": [
     "pr",