@juspay/yama 1.5.1 → 2.0.0

package/dist/utils/ParallelProcessing.js

@@ -1,333 +0,0 @@
-/**
- * Parallel Processing Utilities for Batch Processing
- * Provides concurrency control and resource management for parallel batch execution
- */
-import { logger } from "./Logger.js";
-/**
- * Semaphore for controlling concurrent access to resources
- * Limits the number of concurrent operations that can run simultaneously
- */
-export class Semaphore {
-    permits;
-    waiting = [];
-    constructor(permits) {
-        if (permits <= 0) {
-            throw new Error("Semaphore permits must be greater than 0");
-        }
-        this.permits = permits;
-        logger.debug(`Semaphore created with ${permits} permits`);
-    }
-    /**
-     * Acquire a permit from the semaphore
-     * If no permits are available, the caller will wait until one becomes available
-     */
-    async acquire() {
-        if (this.permits > 0) {
-            this.permits--;
-            logger.debug(`Semaphore permit acquired, ${this.permits} remaining`);
-            return;
-        }
-        logger.debug(`Semaphore permit requested, waiting in queue (${this.waiting.length} waiting)`);
-        return new Promise((resolve) => {
-            this.waiting.push(resolve);
-        });
-    }
-    /**
-     * Release a permit back to the semaphore
-     * This will allow waiting operations to proceed
-     */
-    release() {
-        this.permits++;
-        logger.debug(`Semaphore permit released, ${this.permits} available`);
-        if (this.waiting.length > 0) {
-            const resolve = this.waiting.shift();
-            this.permits--;
-            logger.debug(`Semaphore permit granted to waiting operation, ${this.permits} remaining`);
-            resolve();
-        }
-    }
-    /**
-     * Get the number of available permits
-     */
-    getAvailablePermits() {
-        return this.permits;
-    }
-    /**
-     * Get the number of operations waiting for permits
-     */
-    getWaitingCount() {
-        return this.waiting.length;
-    }
-    /**
-     * Get semaphore status for debugging
-     */
-    getStatus() {
-        return {
-            available: this.permits,
-            waiting: this.waiting.length,
-        };
-    }
-}
-/**
- * Token Budget Manager for controlling AI token usage across parallel batches
- * Ensures that the total token usage doesn't exceed the configured limits
- */
-export class TokenBudgetManager {
-    totalBudget;
-    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");
-        }
-        // 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
-     * Returns true if allocation was successful, false if insufficient budget
-     */
-    allocateForBatch(batchIndex, estimatedTokens) {
-        if (estimatedTokens <= 0) {
-            logger.warn(`Invalid token estimate for batch ${batchIndex}: ${estimatedTokens}`);
-            return false;
-        }
-        // 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;
-        }
-        // Check if we have enough budget
-        const totalAllocated = this.usedTokens + this.reservedTokens + estimatedTokens;
-        if (totalAllocated > this.totalBudget) {
-            logger.debug(`Insufficient token budget for batch ${batchIndex}: ` +
-                `need ${estimatedTokens}, available ${this.getAvailableBudget()}`);
-            return false;
-        }
-        // 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;
-    }
-    /**
-     * Release tokens allocated to a batch
-     * This should be called when a batch completes (successfully or with error)
-     */
-    releaseBatch(batchIndex) {
-        const allocated = this.batchAllocations.get(batchIndex);
-        if (!allocated) {
-            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)`);
-    }
-    /**
-     * Get the available token budget (not yet allocated or used)
-     */
-    getAvailableBudget() {
-        return this.totalBudget - this.usedTokens - this.reservedTokens;
-    }
-    /**
-     * Get the total token budget
-     */
-    getTotalBudget() {
-        return this.totalBudget;
-    }
-    /**
-     * Get the number of tokens actually used (completed batches)
-     */
-    getUsedTokens() {
-        return this.usedTokens;
-    }
-    /**
-     * Get the number of tokens reserved (allocated but not yet used)
-     */
-    getReservedTokens() {
-        return this.reservedTokens;
-    }
-    /**
-     * Get the number of active batch allocations
-     */
-    getActiveBatches() {
-        return this.batchAllocations.size;
-    }
-    /**
-     * Get detailed budget status for monitoring
-     */
-    getBudgetStatus() {
-        const utilizationPercent = ((this.usedTokens + this.reservedTokens) / this.totalBudget) * 100;
-        return {
-            total: this.totalBudget,
-            used: this.usedTokens,
-            reserved: this.reservedTokens,
-            available: this.getAvailableBudget(),
-            activeBatches: this.batchAllocations.size,
-            utilizationPercent: Math.round(utilizationPercent * 100) / 100,
-        };
-    }
-    /**
-     * Reset the budget manager (for testing or reuse)
-     */
-    reset() {
-        this.usedTokens = 0;
-        this.reservedTokens = 0;
-        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)
-     */
-    updateBudget(newBudget) {
-        if (newBudget <= 0) {
-            throw new Error("Token budget must be greater than 0");
-        }
-        const oldBudget = this.totalBudget;
-        this.totalBudget = newBudget;
-        logger.debug(`Token budget updated from ${oldBudget} to ${newBudget}`);
-        // Log warning if new budget is less than current usage
-        if (newBudget < this.usedTokens + this.reservedTokens) {
-            logger.warn(`New budget (${newBudget}) is less than current usage (${this.usedTokens + this.reservedTokens})`);
-        }
-    }
-}
-/**
- * Factory function to create a Semaphore with validation
- */
-export function createSemaphore(permits) {
-    return new Semaphore(permits);
-}
-/**
- * Factory function to create a TokenBudgetManager with validation
- */
-export function createTokenBudgetManager(totalBudget) {
-    return new TokenBudgetManager(totalBudget);
-}
-/**
- * Utility function to calculate optimal concurrency based on available resources
- */
-export function calculateOptimalConcurrency(totalBatches, maxConcurrent, averageTokensPerBatch, totalTokenBudget) {
-    // Don't exceed the configured maximum
-    let optimal = Math.min(maxConcurrent, totalBatches);
-    // Don't exceed what the token budget can support
-    const tokenBasedLimit = Math.floor(totalTokenBudget / averageTokensPerBatch);
-    optimal = Math.min(optimal, tokenBasedLimit);
-    // Ensure at least 1
-    optimal = Math.max(1, optimal);
-    logger.debug(`Calculated optimal concurrency: ${optimal} ` +
-        `(max: ${maxConcurrent}, batches: ${totalBatches}, token-limited: ${tokenBasedLimit})`);
-    return optimal;
-}
-//# sourceMappingURL=ParallelProcessing.js.map

package/dist/utils/ProviderLimits.d.ts

@@ -1,58 +0,0 @@
-/**
- * Provider Token Limits Utility
- * Centralized management of AI provider token limits and validation
- */
-/**
- * AI Provider types supported by the system
- */
-export type AIProvider = 'vertex' | 'google-ai' | 'gemini' | 'openai' | 'gpt-4' | 'anthropic' | 'claude' | 'azure' | 'bedrock' | 'auto';
-/**
- * Provider token limits configuration
- * These limits are conservative values to avoid API errors
- */
-export declare const PROVIDER_TOKEN_LIMITS: Record<AIProvider, number>;
-/**
- * Conservative limits used by CodeReviewer for safety
- * These are slightly lower than the actual limits to provide buffer
- */
-export declare const CONSERVATIVE_PROVIDER_LIMITS: Record<AIProvider, number>;
-/**
- * Get the token limit for a specific provider
- * @param provider - The AI provider name
- * @param conservative - Whether to use conservative limits (default: false)
- * @returns The token limit for the provider
- */
-export declare function getProviderTokenLimit(provider: string, conservative?: boolean): number;
-/**
- * Validate and adjust token limit for a provider
- * @param provider - The AI provider name
- * @param configuredTokens - The configured token limit
- * @param conservative - Whether to use conservative limits (default: false)
- * @returns The validated and potentially adjusted token limit
- */
-export declare function validateProviderTokenLimit(provider: string, configuredTokens: number | undefined, conservative?: boolean): number;
-/**
- * Get all supported providers
- * @returns Array of supported provider names
- */
-export declare function getSupportedProviders(): AIProvider[];
-/**
- * Check if a provider is supported
- * @param provider - The provider name to check
- * @returns True if the provider is supported
- */
-export declare function isProviderSupported(provider: string): boolean;
-/**
- * Get provider information including limits and support status
- * @param provider - The provider name
- * @param conservative - Whether to use conservative limits
- * @returns Provider information object
- */
-export declare function getProviderInfo(provider: string, conservative?: boolean): {
-    provider: string;
-    isSupported: boolean;
-    tokenLimit: number;
-    conservativeLimit: number;
-    standardLimit: number;
-};
-//# sourceMappingURL=ProviderLimits.d.ts.map

package/dist/utils/ProviderLimits.js

@@ -1,143 +0,0 @@
-/**
- * Provider Token Limits Utility
- * Centralized management of AI provider token limits and validation
- */
-import { logger } from "./Logger.js";
-/**
- * Provider token limits configuration
- * These limits are conservative values to avoid API errors
- */
-export const PROVIDER_TOKEN_LIMITS = {
-    // Google/Vertex AI providers
-    'vertex': 65536, // Vertex AI limit is 65537 exclusive = 65536 max
-    'google-ai': 65536, // Google AI Studio limit
-    'gemini': 65536, // Gemini model limit
-    // OpenAI providers
-    'openai': 128000, // OpenAI GPT-4 and newer models
-    'gpt-4': 128000, // GPT-4 specific limit
-    // Anthropic providers
-    'anthropic': 200000, // Claude models limit
-    'claude': 200000, // Claude specific limit
-    // Microsoft Azure
-    'azure': 128000, // Azure OpenAI limit
-    // AWS Bedrock
-    'bedrock': 100000, // AWS Bedrock limit
-    // Auto-selection mode (conservative default)
-    'auto': 60000, // Conservative default for auto-selection
-};
-/**
- * Conservative limits used by CodeReviewer for safety
- * These are slightly lower than the actual limits to provide buffer
- */
-export const CONSERVATIVE_PROVIDER_LIMITS = {
-    'vertex': 65536,
-    'google-ai': 65536,
-    'gemini': 65536,
-    'openai': 120000, // Slightly lower for safety
-    'gpt-4': 120000,
-    'anthropic': 190000, // Slightly lower for safety
-    'claude': 190000,
-    'azure': 120000,
-    'bedrock': 95000, // Significantly lower for safety
-    'auto': 60000,
-};
-/**
- * Get the token limit for a specific provider
- * @param provider - The AI provider name
- * @param conservative - Whether to use conservative limits (default: false)
- * @returns The token limit for the provider
- */
-export function getProviderTokenLimit(provider, conservative = false) {
-    // Handle null, undefined, or empty string
-    if (!provider || typeof provider !== 'string') {
-        return conservative ? CONSERVATIVE_PROVIDER_LIMITS.auto : PROVIDER_TOKEN_LIMITS.auto;
-    }
-    const normalizedProvider = provider.toLowerCase();
-    const limits = conservative ? CONSERVATIVE_PROVIDER_LIMITS : PROVIDER_TOKEN_LIMITS;
-    // Handle empty string after normalization
-    if (normalizedProvider === '') {
-        return conservative ? CONSERVATIVE_PROVIDER_LIMITS.auto : PROVIDER_TOKEN_LIMITS.auto;
-    }
-    // Direct match
-    if (normalizedProvider in limits) {
-        return limits[normalizedProvider];
-    }
-    // Partial match - check if provider contains any known provider name
-    for (const [key, limit] of Object.entries(limits)) {
-        if (normalizedProvider.includes(key) || key.includes(normalizedProvider)) {
-            return limit;
-        }
-    }
-    // Default fallback
-    return conservative ? CONSERVATIVE_PROVIDER_LIMITS.auto : PROVIDER_TOKEN_LIMITS.auto;
-}
-/**
- * Validate and adjust token limit for a provider
- * @param provider - The AI provider name
- * @param configuredTokens - The configured token limit
- * @param conservative - Whether to use conservative limits (default: false)
- * @returns The validated and potentially adjusted token limit
- */
-export function validateProviderTokenLimit(provider, configuredTokens, conservative = false) {
-    const providerLimit = getProviderTokenLimit(provider, conservative);
-    if (!configuredTokens || configuredTokens <= 0) {
-        logger.debug(`No configured tokens for ${provider}, using provider default: ${providerLimit}`);
-        return providerLimit;
-    }
-    if (configuredTokens > providerLimit) {
-        logger.warn(`Configured maxTokens (${configuredTokens}) exceeds ${provider} limit (${providerLimit}). Adjusting to ${providerLimit}.`);
-        return providerLimit;
-    }
-    logger.debug(`Token limit validation passed: ${configuredTokens} <= ${providerLimit} for provider ${provider}`);
-    return configuredTokens;
-}
-/**
- * Get all supported providers
- * @returns Array of supported provider names
- */
-export function getSupportedProviders() {
-    return Object.keys(PROVIDER_TOKEN_LIMITS);
-}
-/**
- * Check if a provider is supported
- * @param provider - The provider name to check
- * @returns True if the provider is supported
- */
-export function isProviderSupported(provider) {
-    // Handle null, undefined, or empty string
-    if (!provider || typeof provider !== 'string') {
-        return false;
-    }
-    const normalizedProvider = provider.toLowerCase();
-    // Handle empty string after normalization
-    if (normalizedProvider === '') {
-        return false;
-    }
-    // Check direct match
-    if (normalizedProvider in PROVIDER_TOKEN_LIMITS) {
-        return true;
-    }
-    // Check partial match
-    for (const key of Object.keys(PROVIDER_TOKEN_LIMITS)) {
-        if (normalizedProvider.includes(key) || key.includes(normalizedProvider)) {
-            return true;
-        }
-    }
-    return false;
-}
-/**
- * Get provider information including limits and support status
- * @param provider - The provider name
- * @param conservative - Whether to use conservative limits
- * @returns Provider information object
- */
-export function getProviderInfo(provider, conservative = false) {
-    return {
-        provider,
-        isSupported: isProviderSupported(provider),
-        tokenLimit: getProviderTokenLimit(provider, conservative),
-        conservativeLimit: getProviderTokenLimit(provider, true),
-        standardLimit: getProviderTokenLimit(provider, false),
-    };
-}
-//# sourceMappingURL=ProviderLimits.js.map

package/dist/utils/RetryManager.d.ts

@@ -1,78 +0,0 @@
-/**
- * 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