@juspay/yama 1.0.0

package/dist/utils/Cache.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * Enhanced Cache utility for Yama
+ * Provides intelligent caching for PR data, file contents, and AI responses
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cache = exports.Cache = void 0;
+exports.createCache = createCache;
+const node_cache_1 = __importDefault(require("node-cache"));
+const Logger_1 = require("./Logger");
+class Cache {
+    constructor(options = {}) {
+        this.statsData = {
+            hits: 0,
+            misses: 0,
+        };
+        /**
+         * Cache with tags for group invalidation
+         */
+        this.tags = new Map();
+        const { ttl = 3600, // 1 hour default
+        maxSize = 100, // 100 keys max
+        checkPeriod = 600, // Check every 10 minutes
+         } = options;
+        this.cache = new node_cache_1.default({
+            stdTTL: ttl,
+            maxKeys: maxSize,
+            checkperiod: checkPeriod,
+            useClones: false,
+            deleteOnExpire: true,
+        });
+        this.cache.on("set", (key, _value) => {
+            Logger_1.logger.debug(`Cache SET: ${key}`);
+        });
+        this.cache.on("expired", (key, _value) => {
+            Logger_1.logger.debug(`Cache EXPIRED: ${key}`);
+        });
+        this.cache.on("del", (key, _value) => {
+            Logger_1.logger.debug(`Cache DELETE: ${key}`);
+        });
+    }
+    /**
+     * Get value from cache
+     */
+    get(key) {
+        const value = this.cache.get(key);
+        if (value !== undefined) {
+            this.statsData.hits++;
+            Logger_1.logger.debug(`Cache HIT: ${key}`);
+            return value;
+        }
+        else {
+            this.statsData.misses++;
+            Logger_1.logger.debug(`Cache MISS: ${key}`);
+            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_1.logger.debug(`Cache SET successful: ${key}`);
+            }
+            else {
+                Logger_1.logger.warn(`Cache SET failed: ${key}`);
+            }
+            return success;
+        }
+        catch (error) {
+            Logger_1.logger.error(`Cache SET error: ${key}`, error);
+            return false;
+        }
+    }
+    /**
+     * Delete key from cache
+     */
+    del(key) {
+        const deleted = this.cache.del(key);
+        Logger_1.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_1.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,
+        };
+    }
+    /**
+     * Get detailed cache statistics from node-cache
+     */
+    getDetailedStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Get or set pattern - common caching pattern
+     */
+    async getOrSet(key, fetchFn, ttl) {
+        const cached = this.get(key);
+        if (cached !== undefined) {
+            return cached;
+        }
+        try {
+            Logger_1.logger.debug(`Cache FETCH: ${key}`);
+            const value = await fetchFn();
+            this.set(key, value, ttl);
+            return value;
+        }
+        catch (error) {
+            Logger_1.logger.error(`Cache FETCH error: ${key}`, error);
+            throw error;
+        }
+    }
+    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_1.logger.debug(`Invalidated tag "${tag}": ${deleted} keys`);
+        return deleted;
+    }
+    /**
+     * Smart cache warming for common patterns
+     */
+    async warmPRCache(workspace, repository, prId) {
+        Logger_1.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_1.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_1.logger.debug(`Cache cleanup: removed ${cleaned} expired entries`);
+        }
+        // Clean up tag associations for deleted keys
+        this.tags.forEach((keys, tag) => {
+            const validKeys = new Set([...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()),
+        };
+    }
+}
+exports.Cache = Cache;
+/**
+ * Cache key generators for common patterns
+ */
+Cache.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}`,
+};
+// Export singleton instance
+exports.cache = new Cache();
+// Export factory function
+function createCache(options) {
+    return new Cache(options);
+}
+//# sourceMappingURL=Cache.js.map

package/dist/utils/ConfigManager.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Enhanced Configuration Manager for Yama
+ * Handles configuration loading, validation, and merging from multiple sources
+ */
+import { GuardianConfig } from "../types";
+export declare class ConfigManager {
+    private config;
+    private configPaths;
+    /**
+     * Default configuration
+     */
+    private static readonly DEFAULT_CONFIG;
+    constructor();
+    /**
+     * Setup configuration file search paths
+     */
+    private setupConfigPaths;
+    /**
+     * Load configuration from files and environment
+     */
+    loadConfig(configPath?: string): Promise<GuardianConfig>;
+    /**
+     * Load configuration from a specific file
+     */
+    private loadConfigFile;
+    /**
+     * Apply environment variable overrides
+     */
+    private applyEnvironmentOverrides;
+    /**
+     * Validate configuration
+     */
+    private validateConfig;
+    /**
+     * Merge two configuration objects deeply
+     */
+    private mergeConfigs;
+    /**
+     * Deep merge utility
+     */
+    private deepMerge;
+    /**
+     * Deep clone utility
+     */
+    private deepClone;
+    /**
+     * Get current configuration
+     */
+    getConfig(): GuardianConfig;
+    /**
+     * Create default configuration file
+     */
+    createDefaultConfig(outputPath?: string): Promise<string>;
+    /**
+     * Add helpful comments to configuration file
+     */
+    private addConfigComments;
+    /**
+     * Validate specific configuration section
+     */
+    validateSection(section: keyof GuardianConfig, config: any): boolean;
+    private validateProviders;
+    private validateFeatures;
+    private validateCache;
+    /**
+     * Get configuration schema for validation
+     */
+    getSchema(): any;
+    /**
+     * Find the first available configuration file
+     */
+    private findConfigFile;
+    /**
+     * Watch configuration file for changes and reload automatically
+     */
+    watchConfig(callback?: (config: GuardianConfig) => void): () => void;
+    /**
+     * Enable hot-reload for configuration
+     */
+    enableHotReload(callback?: (config: GuardianConfig) => void): () => void;
+}
+export declare const configManager: ConfigManager;
+export declare function createConfigManager(): ConfigManager;
+//# sourceMappingURL=ConfigManager.d.ts.map