@juspay/yama 1.1.0 → 1.2.0

package/dist/core/ContextGatherer.d.ts

@@ -2,8 +2,8 @@
  * Unified Context Gatherer - The foundation for all Yama operations
  * Gathers all necessary context once and reuses it across all operations
  */
-import { PRIdentifier, PRInfo, PRDiff, AIProviderConfig, DiffStrategyConfig } from '../types';
-import { BitbucketProvider } from './providers/BitbucketProvider';
+import { PRIdentifier, PRInfo, PRDiff, AIProviderConfig, DiffStrategyConfig, MemoryBankConfig } from "../types/index.js";
+import { BitbucketProvider } from "./providers/BitbucketProvider.js";
 export interface ProjectContext {
     memoryBank: {
         summary: string;
@@ -15,7 +15,7 @@ export interface ProjectContext {
     filesProcessed: number;
 }
 export interface DiffStrategy {
-    strategy: 'whole' | 'file-by-file';
+    strategy: "whole" | "file-by-file";
     reason: string;
     fileCount: number;
     estimatedSize: string;
@@ -36,8 +36,9 @@ export declare class ContextGatherer {
     private neurolink;
     private bitbucketProvider;
     private aiConfig;
+    private memoryBankManager;
     private startTime;
-    constructor(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig);
+    constructor(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig, memoryBankConfig: MemoryBankConfig);
     /**
      * Main context gathering method - used by all operations
      */
@@ -56,6 +57,10 @@ export declare class ContextGatherer {
      * Step 2: Gather project context (memory bank + clinerules)
      */
     private gatherProjectContext;
+    /**
+     * Get safe token limit based on AI provider using shared utility
+     */
+    private getSafeTokenLimit;
     /**
      * Parse project context with AI
      */
@@ -101,5 +106,5 @@ export declare class ContextGatherer {
      */
     getStats(): any;
 }
-export declare function createContextGatherer(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig): ContextGatherer;
+export declare function createContextGatherer(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig, memoryBankConfig: MemoryBankConfig): ContextGatherer;
 //# sourceMappingURL=ContextGatherer.d.ts.map

package/dist/core/ContextGatherer.js

@@ -1,20 +1,23 @@
-"use strict";
 /**
  * Unified Context Gatherer - The foundation for all Yama operations
  * Gathers all necessary context once and reuses it across all operations
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextGatherer = void 0;
-exports.createContextGatherer = createContextGatherer;
 // NeuroLink will be dynamically imported
-const types_1 = require("../types");
-const Logger_1 = require("../utils/Logger");
-const Cache_1 = require("../utils/Cache");
-class ContextGatherer {
-    constructor(bitbucketProvider, aiConfig) {
-        this.startTime = 0;
+import { ProviderError, } from "../types/index.js";
+import { logger } from "../utils/Logger.js";
+import { cache, Cache } from "../utils/Cache.js";
+import { createMemoryBankManager } from "../utils/MemoryBankManager.js";
+import { getProviderTokenLimit } from "../utils/ProviderLimits.js";
+export class ContextGatherer {
+    neurolink;
+    bitbucketProvider;
+    aiConfig;
+    memoryBankManager;
+    startTime = 0;
+    constructor(bitbucketProvider, aiConfig, memoryBankConfig) {
         this.bitbucketProvider = bitbucketProvider;
         this.aiConfig = aiConfig;
+        this.memoryBankManager = createMemoryBankManager(memoryBankConfig, bitbucketProvider);
     }
     /**
      * Main context gathering method - used by all operations
@@ -23,29 +26,29 @@ class ContextGatherer {
         this.startTime = Date.now();
         const contextId = this.generateContextId(identifier);
         const cacheHits = [];
-        Logger_1.logger.phase('🔍 Gathering unified context...');
-        Logger_1.logger.info(`Target: ${identifier.workspace}/${identifier.repository}`);
+        logger.phase("🔍 Gathering unified context...");
+        logger.info(`Target: ${identifier.workspace}/${identifier.repository}`);
         try {
             // Step 1: Find and get PR information
             const pr = await this.findAndGetPR(identifier, cacheHits, options.forceRefresh);
             const completeIdentifier = {
                 ...identifier,
-                pullRequestId: pr.id
+                pullRequestId: pr.id,
             };
             // Step 2: Gather project context (memory bank + clinerules)
             const projectContext = await this.gatherProjectContext(completeIdentifier, cacheHits, options.forceRefresh);
             // Step 3: Determine diff strategy based on file count and config
             const diffStrategy = this.determineDiffStrategy(pr.fileChanges || [], options.diffStrategyConfig);
-            Logger_1.logger.info(`Diff strategy: ${diffStrategy.strategy} (${diffStrategy.reason})`);
+            logger.info(`Diff strategy: ${diffStrategy.strategy} (${diffStrategy.reason})`);
             // Step 4: Get diff data based on strategy (if requested)
             let prDiff;
             let fileDiffs;
             if (options.includeDiff !== false) {
-                if (diffStrategy.strategy === 'whole') {
-                    prDiff = await this.getPRDiff(completeIdentifier, options.contextLines || 3, options.excludePatterns || ['*.lock', '*.svg'], cacheHits, options.forceRefresh);
+                if (diffStrategy.strategy === "whole") {
+                    prDiff = await this.getPRDiff(completeIdentifier, options.contextLines || 3, options.excludePatterns || ["*.lock", "*.svg"], cacheHits, options.forceRefresh);
                 }
                 else {
-                    fileDiffs = await this.getFileByFileDiffs(completeIdentifier, pr.fileChanges || [], options.contextLines || 3, options.excludePatterns || ['*.lock', '*.svg'], cacheHits, options.forceRefresh);
+                    fileDiffs = await this.getFileByFileDiffs(completeIdentifier, pr.fileChanges || [], options.contextLines || 3, options.excludePatterns || ["*.lock", "*.svg"], cacheHits, options.forceRefresh);
                 }
             }
             const gatheringDuration = Date.now() - this.startTime;
@@ -59,108 +62,99 @@ class ContextGatherer {
                 contextId,
                 gatheredAt: new Date().toISOString(),
                 cacheHits,
-                gatheringDuration
+                gatheringDuration,
             };
-            Logger_1.logger.success(`Context gathered in ${Math.round(gatheringDuration / 1000)}s ` +
+            logger.success(`Context gathered in ${Math.round(gatheringDuration / 1000)}s ` +
                 `(${cacheHits.length} cache hits, ${diffStrategy.fileCount} files, ${diffStrategy.estimatedSize})`);
             // Cache the complete context for reuse
             this.cacheContext(context);
             return context;
         }
         catch (error) {
-            Logger_1.logger.error(`Context gathering failed: ${error.message}`);
-            throw new types_1.ProviderError(`Failed to gather context: ${error.message}`);
+            logger.error(`Context gathering failed: ${error.message}`);
+            throw new ProviderError(`Failed to gather context: ${error.message}`);
         }
     }
     /**
      * Step 1: Find PR and get detailed information
      */
     async findAndGetPR(identifier, cacheHits, forceRefresh = false) {
-        Logger_1.logger.debug('Step 1: Finding and getting PR information...');
+        logger.debug("Step 1: Finding and getting PR information...");
         // If PR ID is provided, get details directly
         if (identifier.pullRequestId) {
-            const cacheKey = Cache_1.Cache.keys.prInfo(identifier.workspace, identifier.repository, identifier.pullRequestId);
-            if (!forceRefresh && Cache_1.cache.has(cacheKey)) {
-                cacheHits.push('pr-details');
+            const cacheKey = Cache.keys.prInfo(identifier.workspace, identifier.repository, identifier.pullRequestId);
+            if (!forceRefresh && cache.has(cacheKey)) {
+                cacheHits.push("pr-details");
             }
-            return Cache_1.cache.getOrSet(cacheKey, async () => {
-                Logger_1.logger.debug(`Getting PR details: ${identifier.workspace}/${identifier.repository}#${identifier.pullRequestId}`);
+            return cache.getOrSet(cacheKey, async () => {
+                logger.debug(`Getting PR details: ${identifier.workspace}/${identifier.repository}#${identifier.pullRequestId}`);
                 return await this.bitbucketProvider.getPRDetails(identifier);
-            }, 1800 // 30 minutes
-            );
+            }, 1800);
         }
         // If branch is provided, find PR first
         if (identifier.branch) {
-            const branchCacheKey = Cache_1.Cache.keys.branchInfo(identifier.workspace, identifier.repository, identifier.branch);
-            if (!forceRefresh && Cache_1.cache.has(branchCacheKey)) {
-                cacheHits.push('branch-pr-lookup');
+            const branchCacheKey = Cache.keys.branchInfo(identifier.workspace, identifier.repository, identifier.branch);
+            if (!forceRefresh && cache.has(branchCacheKey)) {
+                cacheHits.push("branch-pr-lookup");
             }
-            const prInfo = await Cache_1.cache.getOrSet(branchCacheKey, async () => {
-                Logger_1.logger.debug(`Finding PR for branch: ${identifier.workspace}/${identifier.repository}@${identifier.branch}`);
+            const prInfo = await cache.getOrSet(branchCacheKey, async () => {
+                logger.debug(`Finding PR for branch: ${identifier.workspace}/${identifier.repository}@${identifier.branch}`);
                 return await this.bitbucketProvider.findPRForBranch(identifier);
-            }, 3600 // 1 hour
-            );
+            }, 3600);
             // Now get full PR details
-            const detailsCacheKey = Cache_1.Cache.keys.prInfo(identifier.workspace, identifier.repository, prInfo.id);
-            if (!forceRefresh && Cache_1.cache.has(detailsCacheKey)) {
-                cacheHits.push('pr-details-from-branch');
+            const detailsCacheKey = Cache.keys.prInfo(identifier.workspace, identifier.repository, prInfo.id);
+            if (!forceRefresh && cache.has(detailsCacheKey)) {
+                cacheHits.push("pr-details-from-branch");
             }
-            return Cache_1.cache.getOrSet(detailsCacheKey, async () => {
+            return cache.getOrSet(detailsCacheKey, async () => {
                 return await this.bitbucketProvider.getPRDetails({
                     ...identifier,
-                    pullRequestId: prInfo.id
+                    pullRequestId: prInfo.id,
                 });
-            }, 1800 // 30 minutes
-            );
+            }, 1800);
         }
-        throw new types_1.ProviderError('Either pullRequestId or branch must be provided');
+        throw new ProviderError("Either pullRequestId or branch must be provided");
     }
     /**
      * Step 2: Gather project context (memory bank + clinerules)
      */
     async gatherProjectContext(identifier, cacheHits, forceRefresh = false) {
-        Logger_1.logger.debug('Step 2: Gathering project context...');
-        const cacheKey = Cache_1.Cache.keys.projectContext(identifier.workspace, identifier.repository, identifier.branch || 'main');
-        if (!forceRefresh && Cache_1.cache.has(cacheKey)) {
-            cacheHits.push('project-context');
+        logger.debug("Step 2: Gathering project context...");
+        const cacheKey = Cache.keys.projectContext(identifier.workspace, identifier.repository, identifier.branch || "main");
+        if (!forceRefresh && cache.has(cacheKey)) {
+            cacheHits.push("project-context");
         }
-        return Cache_1.cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSet(cacheKey, async () => {
             try {
-                // Get memory-bank directory listing
-                const memoryBankFiles = await this.bitbucketProvider.listDirectoryContent(identifier.workspace, identifier.repository, 'memory-bank', identifier.branch || 'main');
-                if (!memoryBankFiles.length) {
-                    Logger_1.logger.debug('No memory-bank directory found');
+                // Use MemoryBankManager to get memory bank files
+                const memoryBankResult = await this.memoryBankManager.getMemoryBankFiles(identifier, forceRefresh);
+                if (memoryBankResult.files.length === 0) {
+                    logger.debug("No memory bank files found");
                     return {
                         memoryBank: {
-                            summary: 'No project context available',
-                            projectContext: 'None',
-                            patterns: 'None',
-                            standards: 'None'
+                            summary: "No project context available",
+                            projectContext: "None",
+                            patterns: "None",
+                            standards: "None",
                         },
-                        clinerules: '',
-                        filesProcessed: 0
+                        clinerules: "",
+                        filesProcessed: 0,
                     };
                 }
-                // Get content of each memory bank file
+                // Convert MemoryBankFile[] to Record<string, string> for AI processing
                 const fileContents = {};
-                const files = memoryBankFiles.filter(f => f.type === 'file');
-                for (const file of files) {
-                    try {
-                        fileContents[file.name] = await this.bitbucketProvider.getFileContent(identifier.workspace, identifier.repository, `memory-bank/${file.name}`, identifier.branch || 'main');
-                        Logger_1.logger.debug(`✓ Got content for: ${file.name}`);
-                    }
-                    catch (error) {
-                        Logger_1.logger.debug(`Could not read file ${file.name}: ${error.message}`);
-                    }
-                }
+                memoryBankResult.files.forEach((file) => {
+                    fileContents[file.name] = file.content;
+                });
+                logger.debug(`✓ Loaded ${memoryBankResult.files.length} memory bank files from ${memoryBankResult.resolvedPath}${memoryBankResult.fallbackUsed ? " (fallback)" : ""}`);
                 // Get .clinerules file
-                let clinerules = '';
+                let clinerules = "";
                 try {
-                    clinerules = await this.bitbucketProvider.getFileContent(identifier.workspace, identifier.repository, '.clinerules', identifier.branch || 'main');
-                    Logger_1.logger.debug('✓ Got .clinerules content');
+                    clinerules = await this.bitbucketProvider.getFileContent(identifier.workspace, identifier.repository, ".clinerules", identifier.branch || "main");
+                    logger.debug("✓ Got .clinerules content");
                 }
                 catch (error) {
-                    Logger_1.logger.debug(`Could not read .clinerules: ${error.message}`);
+                    logger.debug(`Could not read .clinerules: ${error.message}`);
                 }
                 // Parse and summarize with AI
                 const contextData = await this.parseProjectContextWithAI(fileContents, clinerules);
@@ -171,27 +165,43 @@ Patterns: ${contextData.patterns}
 Standards: ${contextData.standards}`,
                         projectContext: contextData.projectContext,
                         patterns: contextData.patterns,
-                        standards: contextData.standards
+                        standards: contextData.standards,
                     },
                     clinerules,
-                    filesProcessed: Object.keys(fileContents).length
+                    filesProcessed: memoryBankResult.filesProcessed,
                 };
             }
             catch (error) {
-                Logger_1.logger.debug(`Failed to gather project context: ${error.message}`);
+                logger.debug(`Failed to gather project context: ${error.message}`);
                 return {
                     memoryBank: {
-                        summary: 'Context gathering failed',
-                        projectContext: 'Failed to load',
-                        patterns: 'Failed to load',
-                        standards: 'Failed to load'
+                        summary: "Context gathering failed",
+                        projectContext: "Failed to load",
+                        patterns: "Failed to load",
+                        standards: "Failed to load",
                     },
-                    clinerules: '',
-                    filesProcessed: 0
+                    clinerules: "",
+                    filesProcessed: 0,
                 };
             }
-        }, 7200 // 2 hours - project context changes less frequently
-        );
+        }, 7200);
+    }
+    /**
+     * Get safe token limit based on AI provider using shared utility
+     */
+    getSafeTokenLimit() {
+        const provider = this.aiConfig.provider || "auto";
+        const configuredTokens = this.aiConfig.maxTokens;
+        // Use conservative limits for ContextGatherer (safer for large context processing)
+        const providerLimit = getProviderTokenLimit(provider, true);
+        // Use the smaller of configured tokens or provider limit
+        if (configuredTokens && configuredTokens > 0) {
+            const safeLimit = Math.min(configuredTokens, providerLimit);
+            logger.debug(`Token limit: configured=${configuredTokens}, provider=${providerLimit}, using=${safeLimit}`);
+            return safeLimit;
+        }
+        logger.debug(`Token limit: using provider default=${providerLimit} for ${provider}`);
+        return providerLimit;
     }
     /**
      * Parse project context with AI
@@ -213,50 +223,54 @@ Extract and summarize the content and return ONLY this JSON format:
         try {
             // Initialize NeuroLink with eval-based dynamic import
             if (!this.neurolink) {
-                const dynamicImport = eval('(specifier) => import(specifier)');
-                const { NeuroLink } = await dynamicImport('@juspay/neurolink');
+                const { NeuroLink } = await import("@juspay/neurolink");
                 this.neurolink = new NeuroLink();
             }
             // Context for project analysis
             const aiContext = {
-                operation: 'project-context-analysis',
+                operation: "project-context-analysis",
                 fileCount: Object.keys(fileContents).length,
                 hasClinerules: !!clinerules,
-                analysisType: 'memory-bank-synthesis'
+                analysisType: "memory-bank-synthesis",
             };
+            // Get safe token limit based on provider
+            const safeMaxTokens = this.getSafeTokenLimit();
+            logger.debug(`Using AI provider: ${this.aiConfig.provider || "auto"}`);
+            logger.debug(`Configured maxTokens: ${this.aiConfig.maxTokens}`);
+            logger.debug(`Safe maxTokens limit: ${safeMaxTokens}`);
             const result = await this.neurolink.generate({
                 input: { text: prompt },
-                systemPrompt: 'You are an Expert Project Analyst. Synthesize project context from documentation and configuration files to help AI understand the codebase architecture, patterns, and business domain.',
+                systemPrompt: "You are an Expert Project Analyst. Synthesize project context from documentation and configuration files to help AI understand the codebase architecture, patterns, and business domain.",
                 provider: this.aiConfig.provider,
                 model: this.aiConfig.model,
                 temperature: 0.3,
-                maxTokens: Math.max(this.aiConfig.maxTokens || 0, 500000), // Quality first - always use higher limit
-                timeout: '10m', // Allow longer processing for quality
+                maxTokens: safeMaxTokens, // Use provider-aware safe token limit
+                timeout: "10m", // Allow longer processing for quality
                 context: aiContext,
                 enableAnalytics: this.aiConfig.enableAnalytics || true,
-                enableEvaluation: false // Not needed for context synthesis
+                enableEvaluation: false, // Not needed for context synthesis
             });
             // Log context analysis
             if (result.analytics) {
-                Logger_1.logger.debug(`Context Analysis - Files: ${Object.keys(fileContents).length}, Provider: ${result.provider}`);
+                logger.debug(`Context Analysis - Files: ${Object.keys(fileContents).length}, Provider: ${result.provider}`);
             }
             // Modern NeuroLink returns { content: string }
             const response = this.parseAIResponse(result);
             if (response.success) {
                 return {
-                    projectContext: response.projectContext || 'None',
-                    patterns: response.patterns || 'None',
-                    standards: response.standards || 'None'
+                    projectContext: response.projectContext || "None",
+                    patterns: response.patterns || "None",
+                    standards: response.standards || "None",
                 };
             }
-            throw new Error('AI parsing failed');
+            throw new Error("AI parsing failed");
         }
         catch (error) {
-            Logger_1.logger.warn(`AI context parsing failed, using fallback: ${error.message}`);
+            logger.warn(`AI context parsing failed, using fallback: ${error.message}`);
             return {
-                projectContext: 'AI parsing unavailable',
-                patterns: 'Standard patterns assumed',
-                standards: 'Standard quality requirements'
+                projectContext: "AI parsing unavailable",
+                patterns: "Standard patterns assumed",
+                standards: "Standard quality requirements",
             };
         }
     }
@@ -267,94 +281,96 @@ Extract and summarize the content and return ONLY this JSON format:
         const fileCount = fileChanges.length;
         // Get threshold values from config or use defaults
         const wholeDiffMaxFiles = config?.thresholds?.wholeDiffMaxFiles ?? 2;
-        // Note: fileByFileMinFiles is currently same as wholeDiffMaxFiles + 1 
+        // Note: fileByFileMinFiles is currently same as wholeDiffMaxFiles + 1
         // but kept separate for future flexibility
         // Check if force strategy is configured
-        if (config?.forceStrategy && config.forceStrategy !== 'auto') {
+        if (config?.forceStrategy && config.forceStrategy !== "auto") {
             return {
                 strategy: config.forceStrategy,
                 reason: `Forced by configuration`,
                 fileCount,
-                estimatedSize: this.estimateDiffSize(fileCount)
+                estimatedSize: this.estimateDiffSize(fileCount),
             };
         }
         // Determine strategy based on thresholds
-        let strategy = 'whole';
-        let reason = '';
+        let strategy = "whole";
+        let reason = "";
         if (fileCount === 0) {
-            strategy = 'whole';
-            reason = 'No files to analyze';
+            strategy = "whole";
+            reason = "No files to analyze";
         }
         else if (fileCount <= wholeDiffMaxFiles) {
-            strategy = 'whole';
+            strategy = "whole";
             reason = `${fileCount} file(s) ≤ ${wholeDiffMaxFiles} (threshold), using whole diff`;
         }
         else {
-            strategy = 'file-by-file';
+            strategy = "file-by-file";
             reason = `${fileCount} file(s) > ${wholeDiffMaxFiles} (threshold), using file-by-file`;
         }
         return {
             strategy,
             reason,
             fileCount,
-            estimatedSize: this.estimateDiffSize(fileCount)
+            estimatedSize: this.estimateDiffSize(fileCount),
         };
     }
     /**
      * Estimate diff size based on file count
      */
     estimateDiffSize(fileCount) {
-        if (fileCount === 0)
-            return '0 KB';
-        if (fileCount <= 2)
-            return 'Small (~5-20 KB)';
-        if (fileCount <= 5)
-            return 'Small (~10-50 KB)';
-        if (fileCount <= 20)
-            return 'Medium (~50-200 KB)';
-        if (fileCount <= 50)
-            return 'Large (~200-500 KB)';
-        return 'Very Large (>500 KB)';
+        if (fileCount === 0) {
+            return "0 KB";
+        }
+        if (fileCount <= 2) {
+            return "Small (~5-20 KB)";
+        }
+        if (fileCount <= 5) {
+            return "Small (~10-50 KB)";
+        }
+        if (fileCount <= 20) {
+            return "Medium (~50-200 KB)";
+        }
+        if (fileCount <= 50) {
+            return "Large (~200-500 KB)";
+        }
+        return "Very Large (>500 KB)";
     }
     /**
      * Get whole PR diff
      */
     async getPRDiff(identifier, contextLines, excludePatterns, cacheHits, forceRefresh = false) {
-        Logger_1.logger.debug('Getting whole PR diff...');
-        const cacheKey = Cache_1.Cache.keys.prDiff(identifier.workspace, identifier.repository, identifier.pullRequestId);
-        if (!forceRefresh && Cache_1.cache.has(cacheKey)) {
-            cacheHits.push('pr-diff');
+        logger.debug("Getting whole PR diff...");
+        const cacheKey = Cache.keys.prDiff(identifier.workspace, identifier.repository, identifier.pullRequestId);
+        if (!forceRefresh && cache.has(cacheKey)) {
+            cacheHits.push("pr-diff");
         }
-        return Cache_1.cache.getOrSet(cacheKey, async () => {
+        return cache.getOrSet(cacheKey, async () => {
             return await this.bitbucketProvider.getPRDiff(identifier, contextLines, excludePatterns);
-        }, 1800 // 30 minutes
-        );
+        }, 1800);
     }
     /**
      * Get file-by-file diffs for large changesets
      */
     async getFileByFileDiffs(identifier, fileChanges, contextLines, excludePatterns, cacheHits, forceRefresh = false) {
-        Logger_1.logger.debug(`Getting file-by-file diffs for ${fileChanges.length} files...`);
+        logger.debug(`Getting file-by-file diffs for ${fileChanges.length} files...`);
         const fileDiffs = new Map();
         // Filter out excluded files
-        const filteredFiles = fileChanges.filter(file => !excludePatterns.some(pattern => new RegExp(pattern.replace(/\*/g, '.*')).test(file)));
-        Logger_1.logger.debug(`Processing ${filteredFiles.length} files after exclusions`);
+        const filteredFiles = fileChanges.filter((file) => !excludePatterns.some((pattern) => new RegExp(pattern.replace(/\*/g, ".*")).test(file)));
+        logger.debug(`Processing ${filteredFiles.length} files after exclusions`);
         // Process files in batches for better performance
         const batchSize = 5;
         for (let i = 0; i < filteredFiles.length; i += batchSize) {
             const batch = filteredFiles.slice(i, i + batchSize);
             const batchPromises = batch.map(async (file) => {
                 const fileCacheKey = `file-diff:${identifier.workspace}:${identifier.repository}:${identifier.pullRequestId}:${file}`;
-                if (!forceRefresh && Cache_1.cache.has(fileCacheKey)) {
+                if (!forceRefresh && cache.has(fileCacheKey)) {
                     cacheHits.push(`file-diff-${file}`);
                 }
-                return Cache_1.cache.getOrSet(fileCacheKey, async () => {
+                return cache.getOrSet(fileCacheKey, async () => {
                     // Use include_patterns to get diff for just this file
-                    const fileDiff = await this.bitbucketProvider.getPRDiff(identifier, contextLines, excludePatterns, [file] // Include patterns with single file
-                    );
+                    const fileDiff = await this.bitbucketProvider.getPRDiff(identifier, contextLines, excludePatterns, [file]);
                     return fileDiff.diff;
-                }, 1800 // 30 minutes
-                );
+                }, 1800);
             });
             const batchResults = await Promise.all(batchPromises);
             batch.forEach((file, index) => {
@@ -362,10 +378,10 @@ Extract and summarize the content and return ONLY this JSON format:
             });
             // Small delay between batches to avoid overwhelming the API
             if (i + batchSize < filteredFiles.length) {
-                await new Promise(resolve => setTimeout(resolve, 500));
+                await new Promise((resolve) => setTimeout(resolve, 500));
             }
         }
-        Logger_1.logger.debug(`✓ Got diffs for ${fileDiffs.size} files`);
+        logger.debug(`✓ Got diffs for ${fileDiffs.size} files`);
         return fileDiffs;
     }
     /**
@@ -373,12 +389,12 @@ Extract and summarize the content and return ONLY this JSON format:
      */
     cacheContext(context) {
         const contextCacheKey = `context:${context.contextId}`;
-        Cache_1.cache.set(contextCacheKey, context, 1800); // 30 minutes
+        cache.set(contextCacheKey, context, 1800); // 30 minutes
         // Tag it for easy invalidation
-        Cache_1.cache.setWithTags(contextCacheKey, context, [
+        cache.setWithTags(contextCacheKey, context, [
             `workspace:${context.identifier.workspace}`,
             `repository:${context.identifier.repository}`,
-            `pr:${context.identifier.pullRequestId}`
+            `pr:${context.identifier.pullRequestId}`,
         ], 1800);
     }
     /**
@@ -387,9 +403,9 @@ Extract and summarize the content and return ONLY this JSON format:
     async getCachedContext(identifier) {
         const contextId = this.generateContextId(identifier);
         const contextCacheKey = `context:${contextId}`;
-        const cached = Cache_1.cache.get(contextCacheKey);
+        const cached = cache.get(contextCacheKey);
         if (cached) {
-            Logger_1.logger.debug(`✓ Using cached context: ${contextId}`);
+            logger.debug(`✓ Using cached context: ${contextId}`);
             return cached;
         }
         return null;
@@ -398,9 +414,9 @@ Extract and summarize the content and return ONLY this JSON format:
      * Invalidate context cache for a specific PR
      */
     invalidateContext(identifier) {
-        Cache_1.cache.invalidateTag(`pr:${identifier.pullRequestId}`);
-        Cache_1.cache.invalidateTag(`workspace:${identifier.workspace}`);
-        Logger_1.logger.debug(`Context cache invalidated for PR ${identifier.pullRequestId}`);
+        cache.invalidateTag(`pr:${identifier.pullRequestId}`);
+        cache.invalidateTag(`workspace:${identifier.workspace}`);
+        logger.debug(`Context cache invalidated for PR ${identifier.pullRequestId}`);
     }
     /**
      * Generate unique context ID
@@ -409,11 +425,11 @@ Extract and summarize the content and return ONLY this JSON format:
         const parts = [
             identifier.workspace,
             identifier.repository,
-            identifier.pullRequestId || identifier.branch || 'unknown'
+            identifier.pullRequestId || identifier.branch || "unknown",
         ];
-        return Buffer.from(parts.join(':'))
-            .toString('base64')
-            .replace(/[+/=]/g, '')
+        return Buffer.from(parts.join(":"))
+            .toString("base64")
+            .replace(/[+/=]/g, "")
             .substring(0, 16);
     }
     /**
@@ -421,16 +437,16 @@ Extract and summarize the content and return ONLY this JSON format:
      */
     parseAIResponse(result) {
         try {
-            const responseText = result.content || result.text || result.response || '';
+            const responseText = result.content || result.text || result.response || "";
             if (!responseText) {
-                return { success: false, error: 'Empty response' };
+                return { success: false, error: "Empty response" };
             }
             // Find JSON in response
             const jsonMatch = responseText.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
                 return JSON.parse(jsonMatch[0]);
             }
-            return { success: false, error: 'No JSON found' };
+            return { success: false, error: "No JSON found" };
         }
         catch (error) {
             return { success: false, error: error.message };
@@ -442,14 +458,13 @@ Extract and summarize the content and return ONLY this JSON format:
     getStats() {
         return {
             lastGatheringDuration: this.startTime ? Date.now() - this.startTime : 0,
-            cacheStats: Cache_1.cache.stats(),
-            cacheHitRatio: Cache_1.cache.getHitRatio()
+            cacheStats: cache.stats(),
+            cacheHitRatio: cache.getHitRatio(),
         };
     }
 }
-exports.ContextGatherer = ContextGatherer;
 // Export factory function
-function createContextGatherer(bitbucketProvider, aiConfig) {
-    return new ContextGatherer(bitbucketProvider, aiConfig);
+export function createContextGatherer(bitbucketProvider, aiConfig, memoryBankConfig) {
+    return new ContextGatherer(bitbucketProvider, aiConfig, memoryBankConfig);
 }
 //# sourceMappingURL=ContextGatherer.js.map