@juspay/yama 1.1.0 → 1.2.0

package/dist/types/index.d.ts

@@ -3,7 +3,7 @@
  * Consolidates all interfaces and types used across the application
  */
 export interface AIProviderConfig {
-    provider?: 'auto' | 'google-ai' | 'openai' | 'anthropic' | 'azure' | 'bedrock';
+    provider?: "auto" | "google-ai" | "openai" | "anthropic" | "azure" | "bedrock";
     model?: string;
     enableFallback?: boolean;
     enableAnalytics?: boolean;
@@ -47,7 +47,7 @@ export interface EvaluationData {
     };
     confidence: number;
 }
-export type GitPlatform = 'bitbucket' | 'github' | 'gitlab' | 'azure-devops';
+export type GitPlatform = "bitbucket" | "github" | "gitlab" | "azure-devops";
 export interface GitCredentials {
     username: string;
     token: string;
@@ -69,7 +69,7 @@ export interface PRInfo {
     title: string;
     description: string;
     author: string;
-    state: 'OPEN' | 'MERGED' | 'DECLINED' | 'CLOSED';
+    state: "OPEN" | "MERGED" | "DECLINED" | "CLOSED";
     sourceRef: string;
     targetRef: string;
     createdDate: string;
@@ -85,7 +85,7 @@ export interface PRReviewer {
         displayName: string;
     };
     approved: boolean;
-    status: 'APPROVED' | 'UNAPPROVED' | 'NEEDS_WORK';
+    status: "APPROVED" | "UNAPPROVED" | "NEEDS_WORK";
 }
 export interface PRComment {
     id: number;
@@ -100,7 +100,7 @@ export interface PRComment {
         filePath: string;
         lineFrom: number;
         lineTo: number;
-        lineType: 'ADDED' | 'REMOVED' | 'CONTEXT';
+        lineType: "ADDED" | "REMOVED" | "CONTEXT";
     };
 }
 export interface PRDiff {
@@ -111,7 +111,7 @@ export interface PRDiff {
 }
 export interface FileChange {
     path: string;
-    changeType: 'ADDED' | 'MODIFIED' | 'DELETED' | 'RENAMED';
+    changeType: "ADDED" | "MODIFIED" | "DELETED" | "RENAMED";
     additions: number;
     deletions: number;
     hunks: DiffHunk[];
@@ -124,14 +124,14 @@ export interface DiffHunk {
     lines: DiffLine[];
 }
 export interface DiffLine {
-    type: 'added' | 'removed' | 'context';
+    type: "added" | "removed" | "context";
     content: string;
     oldLineNumber?: number;
     newLineNumber?: number;
 }
-export type ViolationSeverity = 'CRITICAL' | 'MAJOR' | 'MINOR' | 'SUGGESTION';
-export type ViolationType = 'inline' | 'general';
-export type ViolationCategory = 'security' | 'performance' | 'maintainability' | 'functionality' | 'error_handling' | 'testing' | 'general';
+export type ViolationSeverity = "CRITICAL" | "MAJOR" | "MINOR" | "SUGGESTION";
+export type ViolationType = "inline" | "general";
+export type ViolationCategory = "security" | "performance" | "maintainability" | "functionality" | "error_handling" | "testing" | "general";
 export interface Violation {
     type: ViolationType;
     file?: string;
@@ -140,7 +140,7 @@ export interface Violation {
         before: string[];
         after: string[];
     };
-    line_type?: 'ADDED' | 'REMOVED' | 'CONTEXT';
+    line_type?: "ADDED" | "REMOVED" | "CONTEXT";
     severity: ViolationSeverity;
     category: ViolationCategory;
     issue: string;
@@ -233,6 +233,7 @@ export interface GuardianConfig {
         securityScan?: SecurityScanConfig;
         analytics?: AnalyticsConfig;
     };
+    memoryBank?: MemoryBankConfig;
     cache?: CacheConfig;
     performance?: PerformanceConfig;
     rules?: CustomRulesConfig;
@@ -265,23 +266,28 @@ export interface DiffStrategyConfig {
         wholeDiffMaxFiles: number;
         fileByFileMinFiles: number;
     };
-    forceStrategy?: 'whole' | 'file-by-file' | 'auto';
+    forceStrategy?: "whole" | "file-by-file" | "auto";
 }
 export interface SecurityScanConfig {
     enabled: boolean;
-    level: 'strict' | 'moderate' | 'basic';
+    level: "strict" | "moderate" | "basic";
     scanTypes: string[];
 }
 export interface AnalyticsConfig {
     enabled: boolean;
     trackMetrics: boolean;
-    exportFormat: 'json' | 'csv' | 'yaml';
+    exportFormat: "json" | "csv" | "yaml";
+}
+export interface MemoryBankConfig {
+    enabled: boolean;
+    path: string;
+    fallbackPaths?: string[];
 }
 export interface CacheConfig {
     enabled: boolean;
     ttl: string;
     maxSize: string;
-    storage: 'memory' | 'redis' | 'file';
+    storage: "memory" | "redis" | "file";
 }
 export interface PerformanceConfig {
     batch: {
@@ -314,11 +320,11 @@ export interface ReportingConfig {
 export interface MonitoringConfig {
     enabled: boolean;
     metrics: string[];
-    exportFormat?: 'json' | 'prometheus' | 'csv';
+    exportFormat?: "json" | "prometheus" | "csv";
     endpoint?: string;
     interval?: string;
 }
-export type OperationType = 'review' | 'enhance-description' | 'security-scan' | 'analytics' | 'all';
+export type OperationType = "review" | "enhance-description" | "security-scan" | "analytics" | "all";
 export interface OperationOptions {
     workspace: string;
     repository: string;
@@ -331,7 +337,7 @@ export interface OperationOptions {
 }
 export interface OperationResult {
     operation: OperationType;
-    status: 'success' | 'error' | 'skipped';
+    status: "success" | "error" | "skipped";
     data?: any;
     error?: string;
     duration: number;
@@ -350,7 +356,7 @@ export interface ProcessResult {
 }
 export interface StreamUpdate {
     operation: OperationType;
-    status: 'started' | 'progress' | 'completed' | 'error';
+    status: "started" | "progress" | "completed" | "error";
     progress?: number;
     message?: string;
     data?: any;
@@ -361,11 +367,11 @@ export interface StreamOptions {
     onError?: (error: Error) => void;
     onComplete?: (result: ProcessResult) => void;
 }
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export type LogLevel = "debug" | "info" | "warn" | "error";
 export interface LoggerOptions {
     level: LogLevel;
     verbose: boolean;
-    format: 'simple' | 'json' | 'detailed';
+    format: "simple" | "json" | "detailed";
     colors: boolean;
 }
 export interface Logger {

package/dist/types/index.js

@@ -1,43 +1,38 @@
-"use strict";
 /**
  * Core TypeScript types for Yama
  * Consolidates all interfaces and types used across the application
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = exports.ProviderError = exports.ConfigurationError = exports.GuardianError = void 0;
 // ============================================================================
 // Error Types
 // ============================================================================
-class GuardianError extends Error {
+export class GuardianError extends Error {
+    code;
+    context;
     constructor(code, message, context) {
         super(message);
         this.code = code;
         this.context = context;
-        this.name = 'GuardianError';
+        this.name = "GuardianError";
     }
 }
-exports.GuardianError = GuardianError;
-class ConfigurationError extends GuardianError {
+export class ConfigurationError extends GuardianError {
     constructor(message, context) {
-        super('CONFIGURATION_ERROR', message, context);
-        this.name = 'ConfigurationError';
+        super("CONFIGURATION_ERROR", message, context);
+        this.name = "ConfigurationError";
     }
 }
-exports.ConfigurationError = ConfigurationError;
-class ProviderError extends GuardianError {
+export class ProviderError extends GuardianError {
     constructor(message, context) {
-        super('PROVIDER_ERROR', message, context);
-        this.name = 'ProviderError';
+        super("PROVIDER_ERROR", message, context);
+        this.name = "ProviderError";
     }
 }
-exports.ProviderError = ProviderError;
-class ValidationError extends GuardianError {
+export class ValidationError extends GuardianError {
     constructor(message, context) {
-        super('VALIDATION_ERROR', message, context);
-        this.name = 'ValidationError';
+        super("VALIDATION_ERROR", message, context);
+        this.name = "ValidationError";
     }
 }
-exports.ValidationError = ValidationError;
 // ============================================================================
 // Export all types - Main file, no re-exports needed
 // ============================================================================

package/dist/utils/Cache.d.ts

@@ -2,7 +2,7 @@
  * Enhanced Cache utility for Yama
  * Provides intelligent caching for PR data, file contents, and AI responses
  */
-import { Cache as ICache, CacheOptions } from '../types';
+import { Cache as ICache, CacheOptions } from "../types/index.js";
 export declare class Cache implements ICache {
     private cache;
     private statsData;
@@ -57,6 +57,10 @@ export declare class Cache implements ICache {
      * 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
      */
@@ -69,6 +73,7 @@ export declare class Cache implements ICache {
         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

package/dist/utils/Cache.js

@@ -1,45 +1,35 @@
-"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 {
+import NodeCache from "node-cache";
+import { logger } from "./Logger.js";
+export class Cache {
+    cache;
+    statsData = {
+        hits: 0,
+        misses: 0,
+    };
     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
+        checkPeriod = 600, // Check every 10 minutes
          } = options;
-        this.cache = new node_cache_1.default({
+        this.cache = new NodeCache({
             stdTTL: ttl,
             maxKeys: maxSize,
             checkperiod: checkPeriod,
             useClones: false,
-            deleteOnExpire: true
+            deleteOnExpire: true,
         });
-        this.cache.on('set', (key, _value) => {
-            Logger_1.logger.debug(`Cache SET: ${key}`);
+        this.cache.on("set", (key, _value) => {
+            logger.debug(`Cache SET: ${key}`);
         });
-        this.cache.on('expired', (key, _value) => {
-            Logger_1.logger.debug(`Cache EXPIRED: ${key}`);
+        this.cache.on("expired", (key, _value) => {
+            logger.debug(`Cache EXPIRED: ${key}`);
         });
-        this.cache.on('del', (key, _value) => {
-            Logger_1.logger.debug(`Cache DELETE: ${key}`);
+        this.cache.on("del", (key, _value) => {
+            logger.debug(`Cache DELETE: ${key}`);
         });
     }
     /**
@@ -49,12 +39,12 @@ class Cache {
         const value = this.cache.get(key);
         if (value !== undefined) {
             this.statsData.hits++;
-            Logger_1.logger.debug(`Cache HIT: ${key}`);
+            logger.debug(`Cache HIT: ${key}`);
             return value;
         }
         else {
             this.statsData.misses++;
-            Logger_1.logger.debug(`Cache MISS: ${key}`);
+            logger.debug(`Cache MISS: ${key}`);
             return undefined;
         }
     }
@@ -65,15 +55,15 @@ class Cache {
         try {
             const success = this.cache.set(key, value, ttl || 0);
             if (success) {
-                Logger_1.logger.debug(`Cache SET successful: ${key}`);
+                logger.debug(`Cache SET successful: ${key}`);
             }
             else {
-                Logger_1.logger.warn(`Cache SET failed: ${key}`);
+                logger.warn(`Cache SET failed: ${key}`);
             }
             return success;
         }
         catch (error) {
-            Logger_1.logger.error(`Cache SET error: ${key}`, error);
+            logger.error(`Cache SET error: ${key}`, error);
             return false;
         }
     }
@@ -82,7 +72,7 @@ class Cache {
      */
     del(key) {
         const deleted = this.cache.del(key);
-        Logger_1.logger.debug(`Cache DELETE: ${key}, deleted: ${deleted}`);
+        logger.debug(`Cache DELETE: ${key}, deleted: ${deleted}`);
         return deleted;
     }
     /**
@@ -98,7 +88,7 @@ class Cache {
         this.cache.flushAll();
         this.statsData.hits = 0;
         this.statsData.misses = 0;
-        Logger_1.logger.debug('Cache cleared');
+        logger.debug("Cache cleared");
     }
     /**
      * Get all cache keys
@@ -114,7 +104,7 @@ class Cache {
             hits: this.statsData.hits,
             misses: this.statsData.misses,
             keys: this.cache.keys().length,
-            size: this.cache.getStats().keys
+            size: this.cache.getStats().keys,
         };
     }
     /**
@@ -132,21 +122,25 @@ class Cache {
             return cached;
         }
         try {
-            Logger_1.logger.debug(`Cache FETCH: ${key}`);
+            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);
+            logger.error(`Cache FETCH error: ${key}`, error);
             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 => {
+            tags.forEach((tag) => {
                 if (!this.tags.has(tag)) {
                     this.tags.set(tag, new Set());
                 }
@@ -160,29 +154,63 @@ class Cache {
      */
     invalidateTag(tag) {
         const keys = this.tags.get(tag);
-        if (!keys)
+        if (!keys) {
             return 0;
+        }
         let deleted = 0;
-        keys.forEach(key => {
+        keys.forEach((key) => {
             deleted += this.del(key);
         });
         // Clean up tag associations
         this.tags.delete(tag);
-        Logger_1.logger.debug(`Invalidated tag "${tag}": ${deleted} keys`);
+        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_1.logger.debug(`Warming cache for PR ${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)
+            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(', ')}`);
+        logger.debug(`Cache warming prepared for keys: ${keys.join(", ")}`);
     }
     /**
      * Cleanup expired entries and optimize memory
@@ -191,17 +219,17 @@ class Cache {
         // 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.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`);
+            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)));
+            const validKeys = new Set([...keys].filter((key) => this.cache.has(key)));
             if (validKeys.size !== keys.size) {
                 this.tags.set(tag, validKeys);
             }
@@ -223,32 +251,14 @@ class Cache {
             hitRatio: this.getHitRatio(),
             detailedStats: this.getDetailedStats(),
             keys: this.keys(),
-            tags: Object.fromEntries(this.tags.entries())
+            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 const cache = new Cache();
 // Export factory function
-function createCache(options) {
+export function createCache(options) {
     return new Cache(options);
 }
 //# sourceMappingURL=Cache.js.map

package/dist/utils/ConfigManager.d.ts

@@ -2,7 +2,7 @@
  * Enhanced Configuration Manager for Yama
  * Handles configuration loading, validation, and merging from multiple sources
  */
-import { GuardianConfig } from '../types';
+import { GuardianConfig } from "../types/index.js";
 export declare class ConfigManager {
     private config;
     private configPaths;
@@ -23,6 +23,10 @@ export declare class ConfigManager {
      * Load configuration from a specific file
      */
     private loadConfigFile;
+    /**
+     * Apply provider-aware token limits using shared utility
+     */
+    private applyProviderTokenLimits;
     /**
      * Apply environment variable overrides
      */