@juspay/yama 1.6.0 → 2.1.0

package/dist/types/index.js

@@ -1,104 +0,0 @@
-/**
- * Core TypeScript types for Yama
- * Consolidates all interfaces and types used across the application
- */
-// ============================================================================
-// Error Types
-// ============================================================================
-export class GuardianError extends Error {
-    code;
-    context;
-    constructor(code, message, context) {
-        super(message);
-        this.code = code;
-        this.context = context;
-        this.name = "GuardianError";
-    }
-}
-export class ConfigurationError extends GuardianError {
-    constructor(message, context) {
-        super("CONFIGURATION_ERROR", message, context);
-        this.name = "ConfigurationError";
-    }
-}
-export class ProviderError extends GuardianError {
-    constructor(message, context) {
-        super("PROVIDER_ERROR", message, context);
-        this.name = "ProviderError";
-    }
-}
-export class ValidationError extends GuardianError {
-    constructor(message, context) {
-        super("VALIDATION_ERROR", message, context);
-        this.name = "ValidationError";
-    }
-}
-// ============================================================================
-// 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

@@ -1,103 +0,0 @@
-/**
- * Enhanced Cache utility for Yama
- * Provides intelligent caching for PR data, file contents, and AI responses
- */
-import { Cache as ICache, CacheOptions } from "../types/index.js";
-export declare class Cache implements ICache {
-    private cache;
-    private statsData;
-    constructor(options?: CacheOptions);
-    /**
-     * Get value from cache with resilient error handling
-     */
-    get<T>(key: string): T | undefined;
-    /**
-     * Set value in cache with optional TTL
-     */
-    set<T>(key: string, value: T, ttl?: number): boolean;
-    /**
-     * Delete key from cache
-     */
-    del(key: string): number;
-    /**
-     * Check if key exists in cache
-     */
-    has(key: string): boolean;
-    /**
-     * Clear all cache entries
-     */
-    clear(): void;
-    /**
-     * Get all cache keys
-     */
-    keys(): string[];
-    /**
-     * Get cache statistics
-     */
-    stats(): {
-        hits: number;
-        misses: number;
-        keys: number;
-        size: number;
-        cacheErrors: number;
-        nonCacheErrors: number;
-    };
-    /**
-     * Get detailed cache statistics from node-cache
-     */
-    getDetailedStats(): any;
-    /**
-     * 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
-     */
-    private tags;
-    setWithTags<T>(key: string, value: T, tags: string[], ttl?: number): boolean;
-    /**
-     * Invalidate all keys with a specific tag
-     */
-    invalidateTag(tag: string): number;
-    /**
-     * Invalidate all keys matching a pattern
-     */
-    invalidatePattern(pattern: string): number;
-    /**
-     * Cache key generators for common patterns
-     */
-    static keys: {
-        prInfo: (workspace: string, repository: string, prId: string | number) => string;
-        prDiff: (workspace: string, repository: string, prId: string | number) => string;
-        fileContent: (workspace: string, repository: string, filePath: string, branch: string) => string;
-        directoryContent: (workspace: string, repository: string, path: string, branch: string) => string;
-        branchInfo: (workspace: string, repository: string, branch: string) => string;
-        aiResponse: (prompt: string, provider: string, model: string) => string;
-        projectContext: (workspace: string, repository: string, branch: string) => string;
-        reviewResult: (workspace: string, repository: string, prId: string | number, configHash: string) => string;
-        memoryBankFiles: (workspace: string, repository: string, branch: string, path: string) => string;
-    };
-    /**
-     * Smart cache warming for common patterns
-     */
-    warmPRCache(workspace: string, repository: string, prId: string | number): Promise<void>;
-    /**
-     * Cleanup expired entries and optimize memory
-     */
-    cleanup(): void;
-    /**
-     * Get cache hit ratio
-     */
-    getHitRatio(): number;
-    /**
-     * Export cache state for debugging
-     */
-    debug(): any;
-}
-export declare const cache: Cache;
-export declare function createCache(options?: CacheOptions): Cache;
-//# sourceMappingURL=Cache.d.ts.map

package/dist/utils/Cache.js

@@ -1,444 +0,0 @@
-/**
- * Enhanced Cache utility for Yama
- * 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
-        maxSize = 100, // 100 keys max
-        checkPeriod = 600, // Check every 10 minutes
-         } = options;
-        this.cache = new NodeCache({
-            stdTTL: ttl,
-            maxKeys: maxSize,
-            checkperiod: checkPeriod,
-            useClones: false,
-            deleteOnExpire: true,
-        });
-        this.cache.on("set", (key, _value) => {
-            logger.debug(`Cache SET: ${key}`);
-        });
-        this.cache.on("expired", (key, _value) => {
-            logger.debug(`Cache EXPIRED: ${key}`);
-        });
-        this.cache.on("del", (key, _value) => {
-            logger.debug(`Cache DELETE: ${key}`);
-        });
-    }
-    /**
-     * Get value from cache with resilient error handling
-     */
-    get(key) {
-        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;
-            }
-        }
-        catch (error) {
-            this.statsData.misses++;
-            logger.warn(`Cache GET error for ${key}, treating as miss:`, error);
-            return undefined;
-        }
-    }
-    /**
-     * Set value in cache with optional TTL
-     */
-    set(key, value, ttl) {
-        try {
-            const success = this.cache.set(key, value, ttl || 0);
-            if (success) {
-                logger.debug(`Cache SET successful: ${key}`);
-            }
-            else {
-                logger.warn(`Cache SET failed: ${key}`);
-            }
-            return success;
-        }
-        catch (error) {
-            logger.error(`Cache SET error: ${key}`, error);
-            return false;
-        }
-    }
-    /**
-     * Delete key from cache
-     */
-    del(key) {
-        const deleted = this.cache.del(key);
-        logger.debug(`Cache DELETE: ${key}, deleted: ${deleted}`);
-        return deleted;
-    }
-    /**
-     * Check if key exists in cache
-     */
-    has(key) {
-        return this.cache.has(key);
-    }
-    /**
-     * Clear all cache entries
-     */
-    clear() {
-        this.cache.flushAll();
-        this.statsData.hits = 0;
-        this.statsData.misses = 0;
-        logger.debug("Cache cleared");
-    }
-    /**
-     * Get all cache keys
-     */
-    keys() {
-        return this.cache.keys();
-    }
-    /**
-     * Get cache statistics
-     */
-    stats() {
-        return {
-            hits: this.statsData.hits,
-            misses: this.statsData.misses,
-            keys: this.cache.keys().length,
-            size: this.cache.getStats().keys,
-            cacheErrors: this.statsData.cacheErrors,
-            nonCacheErrors: this.statsData.nonCacheErrors,
-        };
-    }
-    /**
-     * Get detailed cache statistics from node-cache
-     */
-    getDetailedStats() {
-        return this.cache.getStats();
-    }
-    /**
-     * 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;
-        }
-        try {
-            logger.debug(`Cache FETCH: ${key}`);
-            const value = await fetchFn();
-            // 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) {
-            logger.error(`Cache FETCH error: ${key}`, error);
-            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
-     */
-    tags = new Map();
-    setWithTags(key, value, tags, ttl) {
-        const success = this.set(key, value, ttl);
-        if (success) {
-            // Associate key with tags
-            tags.forEach((tag) => {
-                if (!this.tags.has(tag)) {
-                    this.tags.set(tag, new Set());
-                }
-                this.tags.get(tag).add(key);
-            });
-        }
-        return success;
-    }
-    /**
-     * Invalidate all keys with a specific tag
-     */
-    invalidateTag(tag) {
-        const keys = this.tags.get(tag);
-        if (!keys) {
-            return 0;
-        }
-        let deleted = 0;
-        keys.forEach((key) => {
-            deleted += this.del(key);
-        });
-        // Clean up tag associations
-        this.tags.delete(tag);
-        logger.debug(`Invalidated tag "${tag}": ${deleted} keys`);
-        return deleted;
-    }
-    /**
-     * Invalidate all keys matching a pattern
-     */
-    invalidatePattern(pattern) {
-        const regex = new RegExp(pattern.replace(/\*/g, ".*"));
-        const allKeys = this.keys();
-        let deleted = 0;
-        allKeys.forEach((key) => {
-            if (regex.test(key)) {
-                deleted += this.del(key);
-            }
-        });
-        logger.debug(`Invalidated pattern "${pattern}": ${deleted} keys`);
-        return deleted;
-    }
-    /**
-     * Cache key generators for common patterns
-     */
-    static keys = {
-        prInfo: (workspace, repository, prId) => `pr:${workspace}:${repository}:${prId}`,
-        prDiff: (workspace, repository, prId) => `diff:${workspace}:${repository}:${prId}`,
-        fileContent: (workspace, repository, filePath, branch) => `file:${workspace}:${repository}:${branch}:${filePath}`,
-        directoryContent: (workspace, repository, path, branch) => `dir:${workspace}:${repository}:${branch}:${path}`,
-        branchInfo: (workspace, repository, branch) => `branch:${workspace}:${repository}:${branch}`,
-        aiResponse: (prompt, provider, model) => {
-            // Create a hash of the prompt for consistent keys
-            const hash = Buffer.from(prompt).toString("base64").slice(0, 16);
-            return `ai:${provider}:${model}:${hash}`;
-        },
-        projectContext: (workspace, repository, branch) => `context:${workspace}:${repository}:${branch}`,
-        reviewResult: (workspace, repository, prId, configHash) => `review:${workspace}:${repository}:${prId}:${configHash}`,
-        memoryBankFiles: (workspace, repository, branch, path) => `memory-bank:${workspace}:${repository}:${branch}:${path}`,
-    };
-    /**
-     * Smart cache warming for common patterns
-     */
-    async warmPRCache(workspace, repository, prId) {
-        logger.debug(`Warming cache for PR ${workspace}/${repository}#${prId}`);
-        // Pre-generate cache keys that are likely to be needed
-        const keys = [
-            Cache.keys.prInfo(workspace, repository, prId),
-            Cache.keys.prDiff(workspace, repository, prId),
-        ];
-        // This would be implemented by the calling code to actually fetch the data
-        logger.debug(`Cache warming prepared for keys: ${keys.join(", ")}`);
-    }
-    /**
-     * Cleanup expired entries and optimize memory
-     */
-    cleanup() {
-        // Node-cache handles TTL cleanup automatically, but we can force it
-        const beforeKeys = this.cache.keys().length;
-        // Force check for expired keys
-        this.cache.keys().forEach((key) => {
-            this.cache.get(key); // This triggers expiry check
-        });
-        const afterKeys = this.cache.keys().length;
-        const cleaned = beforeKeys - afterKeys;
-        if (cleaned > 0) {
-            logger.debug(`Cache cleanup: removed ${cleaned} expired entries`);
-        }
-        // Clean up tag associations for deleted keys
-        this.tags.forEach((keys, tag) => {
-            const validKeys = new Set(Array.from(keys).filter((key) => this.cache.has(key)));
-            if (validKeys.size !== keys.size) {
-                this.tags.set(tag, validKeys);
-            }
-        });
-    }
-    /**
-     * Get cache hit ratio
-     */
-    getHitRatio() {
-        const total = this.statsData.hits + this.statsData.misses;
-        return total > 0 ? this.statsData.hits / total : 0;
-    }
-    /**
-     * Export cache state for debugging
-     */
-    debug() {
-        return {
-            stats: this.stats(),
-            hitRatio: this.getHitRatio(),
-            detailedStats: this.getDetailedStats(),
-            keys: this.keys(),
-            tags: Object.fromEntries(this.tags.entries()),
-        };
-    }
-}
-// Export singleton instance
-export const cache = new Cache();
-// Export factory function
-export function createCache(options) {
-    return new Cache(options);
-}
-//# sourceMappingURL=Cache.js.map