@juspay/yama 1.1.0

package/dist/core/ContextGatherer.js

@@ -0,0 +1,455 @@
+"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;
+        this.bitbucketProvider = bitbucketProvider;
+        this.aiConfig = aiConfig;
+    }
+    /**
+     * Main context gathering method - used by all operations
+     */
+    async gatherContext(identifier, options = {}) {
+        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}`);
+        try {
+            // Step 1: Find and get PR information
+            const pr = await this.findAndGetPR(identifier, cacheHits, options.forceRefresh);
+            const completeIdentifier = {
+                ...identifier,
+                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})`);
+            // 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);
+                }
+                else {
+                    fileDiffs = await this.getFileByFileDiffs(completeIdentifier, pr.fileChanges || [], options.contextLines || 3, options.excludePatterns || ['*.lock', '*.svg'], cacheHits, options.forceRefresh);
+                }
+            }
+            const gatheringDuration = Date.now() - this.startTime;
+            const context = {
+                pr,
+                identifier: completeIdentifier,
+                projectContext,
+                diffStrategy,
+                prDiff,
+                fileDiffs,
+                contextId,
+                gatheredAt: new Date().toISOString(),
+                cacheHits,
+                gatheringDuration
+            };
+            Logger_1.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}`);
+        }
+    }
+    /**
+     * 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...');
+        // 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');
+            }
+            return Cache_1.cache.getOrSet(cacheKey, async () => {
+                Logger_1.logger.debug(`Getting PR details: ${identifier.workspace}/${identifier.repository}#${identifier.pullRequestId}`);
+                return await this.bitbucketProvider.getPRDetails(identifier);
+            }, 1800 // 30 minutes
+            );
+        }
+        // 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 prInfo = await Cache_1.cache.getOrSet(branchCacheKey, async () => {
+                Logger_1.logger.debug(`Finding PR for branch: ${identifier.workspace}/${identifier.repository}@${identifier.branch}`);
+                return await this.bitbucketProvider.findPRForBranch(identifier);
+            }, 3600 // 1 hour
+            );
+            // 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');
+            }
+            return Cache_1.cache.getOrSet(detailsCacheKey, async () => {
+                return await this.bitbucketProvider.getPRDetails({
+                    ...identifier,
+                    pullRequestId: prInfo.id
+                });
+            }, 1800 // 30 minutes
+            );
+        }
+        throw new types_1.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');
+        }
+        return Cache_1.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');
+                    return {
+                        memoryBank: {
+                            summary: 'No project context available',
+                            projectContext: 'None',
+                            patterns: 'None',
+                            standards: 'None'
+                        },
+                        clinerules: '',
+                        filesProcessed: 0
+                    };
+                }
+                // Get content of each memory bank file
+                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}`);
+                    }
+                }
+                // Get .clinerules file
+                let clinerules = '';
+                try {
+                    clinerules = await this.bitbucketProvider.getFileContent(identifier.workspace, identifier.repository, '.clinerules', identifier.branch || 'main');
+                    Logger_1.logger.debug('✓ Got .clinerules content');
+                }
+                catch (error) {
+                    Logger_1.logger.debug(`Could not read .clinerules: ${error.message}`);
+                }
+                // Parse and summarize with AI
+                const contextData = await this.parseProjectContextWithAI(fileContents, clinerules);
+                return {
+                    memoryBank: {
+                        summary: `Project Context: ${contextData.projectContext}
+Patterns: ${contextData.patterns}
+Standards: ${contextData.standards}`,
+                        projectContext: contextData.projectContext,
+                        patterns: contextData.patterns,
+                        standards: contextData.standards
+                    },
+                    clinerules,
+                    filesProcessed: Object.keys(fileContents).length
+                };
+            }
+            catch (error) {
+                Logger_1.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'
+                    },
+                    clinerules: '',
+                    filesProcessed: 0
+                };
+            }
+        }, 7200 // 2 hours - project context changes less frequently
+        );
+    }
+    /**
+     * Parse project context with AI
+     */
+    async parseProjectContextWithAI(fileContents, clinerules) {
+        const prompt = `Parse and summarize these memory bank files and .clinerules:
+
+Memory Bank Files: ${JSON.stringify(fileContents, null, 2)}
+
+.clinerules Content: ${clinerules}
+
+Extract and summarize the content and return ONLY this JSON format:
+{
+  "success": true,
+  "projectContext": "Summary of project purpose, architecture, key components...",
+  "patterns": "Summary of coding patterns, best practices, conventions...",
+  "standards": "Summary of quality standards, review criteria..."
+}`;
+        try {
+            // Initialize NeuroLink with eval-based dynamic import
+            if (!this.neurolink) {
+                const dynamicImport = eval('(specifier) => import(specifier)');
+                const { NeuroLink } = await dynamicImport('@juspay/neurolink');
+                this.neurolink = new NeuroLink();
+            }
+            // Context for project analysis
+            const aiContext = {
+                operation: 'project-context-analysis',
+                fileCount: Object.keys(fileContents).length,
+                hasClinerules: !!clinerules,
+                analysisType: 'memory-bank-synthesis'
+            };
+            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.',
+                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
+                context: aiContext,
+                enableAnalytics: this.aiConfig.enableAnalytics || true,
+                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}`);
+            }
+            // 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'
+                };
+            }
+            throw new Error('AI parsing failed');
+        }
+        catch (error) {
+            Logger_1.logger.warn(`AI context parsing failed, using fallback: ${error.message}`);
+            return {
+                projectContext: 'AI parsing unavailable',
+                patterns: 'Standard patterns assumed',
+                standards: 'Standard quality requirements'
+            };
+        }
+    }
+    /**
+     * Step 3: Determine optimal diff strategy
+     */
+    determineDiffStrategy(fileChanges, config) {
+        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 
+        // but kept separate for future flexibility
+        // Check if force strategy is configured
+        if (config?.forceStrategy && config.forceStrategy !== 'auto') {
+            return {
+                strategy: config.forceStrategy,
+                reason: `Forced by configuration`,
+                fileCount,
+                estimatedSize: this.estimateDiffSize(fileCount)
+            };
+        }
+        // Determine strategy based on thresholds
+        let strategy = 'whole';
+        let reason = '';
+        if (fileCount === 0) {
+            strategy = 'whole';
+            reason = 'No files to analyze';
+        }
+        else if (fileCount <= wholeDiffMaxFiles) {
+            strategy = 'whole';
+            reason = `${fileCount} file(s) ≤ ${wholeDiffMaxFiles} (threshold), using whole diff`;
+        }
+        else {
+            strategy = 'file-by-file';
+            reason = `${fileCount} file(s) > ${wholeDiffMaxFiles} (threshold), using file-by-file`;
+        }
+        return {
+            strategy,
+            reason,
+            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)';
+    }
+    /**
+     * 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');
+        }
+        return Cache_1.cache.getOrSet(cacheKey, async () => {
+            return await this.bitbucketProvider.getPRDiff(identifier, contextLines, excludePatterns);
+        }, 1800 // 30 minutes
+        );
+    }
+    /**
+     * 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...`);
+        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`);
+        // 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)) {
+                    cacheHits.push(`file-diff-${file}`);
+                }
+                return Cache_1.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
+                    );
+                    return fileDiff.diff;
+                }, 1800 // 30 minutes
+                );
+            });
+            const batchResults = await Promise.all(batchPromises);
+            batch.forEach((file, index) => {
+                fileDiffs.set(file, batchResults[index]);
+            });
+            // Small delay between batches to avoid overwhelming the API
+            if (i + batchSize < filteredFiles.length) {
+                await new Promise(resolve => setTimeout(resolve, 500));
+            }
+        }
+        Logger_1.logger.debug(`✓ Got diffs for ${fileDiffs.size} files`);
+        return fileDiffs;
+    }
+    /**
+     * Cache the complete context for reuse
+     */
+    cacheContext(context) {
+        const contextCacheKey = `context:${context.contextId}`;
+        Cache_1.cache.set(contextCacheKey, context, 1800); // 30 minutes
+        // Tag it for easy invalidation
+        Cache_1.cache.setWithTags(contextCacheKey, context, [
+            `workspace:${context.identifier.workspace}`,
+            `repository:${context.identifier.repository}`,
+            `pr:${context.identifier.pullRequestId}`
+        ], 1800);
+    }
+    /**
+     * Get cached context if available
+     */
+    async getCachedContext(identifier) {
+        const contextId = this.generateContextId(identifier);
+        const contextCacheKey = `context:${contextId}`;
+        const cached = Cache_1.cache.get(contextCacheKey);
+        if (cached) {
+            Logger_1.logger.debug(`✓ Using cached context: ${contextId}`);
+            return cached;
+        }
+        return null;
+    }
+    /**
+     * 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}`);
+    }
+    /**
+     * Generate unique context ID
+     */
+    generateContextId(identifier) {
+        const parts = [
+            identifier.workspace,
+            identifier.repository,
+            identifier.pullRequestId || identifier.branch || 'unknown'
+        ];
+        return Buffer.from(parts.join(':'))
+            .toString('base64')
+            .replace(/[+/=]/g, '')
+            .substring(0, 16);
+    }
+    /**
+     * Parse AI response utility
+     */
+    parseAIResponse(result) {
+        try {
+            const responseText = result.content || result.text || result.response || '';
+            if (!responseText) {
+                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' };
+        }
+        catch (error) {
+            return { success: false, error: error.message };
+        }
+    }
+    /**
+     * Get gathering statistics
+     */
+    getStats() {
+        return {
+            lastGatheringDuration: this.startTime ? Date.now() - this.startTime : 0,
+            cacheStats: Cache_1.cache.stats(),
+            cacheHitRatio: Cache_1.cache.getHitRatio()
+        };
+    }
+}
+exports.ContextGatherer = ContextGatherer;
+// Export factory function
+function createContextGatherer(bitbucketProvider, aiConfig) {
+    return new ContextGatherer(bitbucketProvider, aiConfig);
+}
+//# sourceMappingURL=ContextGatherer.js.map

package/dist/core/Guardian.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Yama - Unified orchestrator class
+ * The main class that coordinates all operations using shared context
+ */
+import { GuardianConfig, OperationOptions, ProcessResult, StreamUpdate, StreamOptions, ReviewOptions, EnhancementOptions } from '../types';
+export declare class Guardian {
+    private config;
+    private bitbucketProvider;
+    private contextGatherer;
+    private codeReviewer;
+    private descriptionEnhancer;
+    private neurolink;
+    private initialized;
+    constructor(config?: Partial<GuardianConfig>);
+    /**
+     * Initialize Guardian with configuration
+     */
+    initialize(configPath?: string): Promise<void>;
+    /**
+     * Main method: Process PR with multiple operations using unified context
+     */
+    processPR(options: OperationOptions): Promise<ProcessResult>;
+    /**
+     * Streaming version of processPR for real-time updates
+     */
+    processPRStream(options: OperationOptions, _streamOptions?: StreamOptions): AsyncIterableIterator<StreamUpdate>;
+    /**
+     * Gather unified context (cached and reusable)
+     */
+    private gatherUnifiedContext;
+    /**
+     * Execute individual operation using shared context
+     */
+    private executeOperation;
+    /**
+     * Execute code review using shared context
+     */
+    private executeCodeReview;
+    /**
+     * Execute description enhancement using shared context
+     */
+    private executeDescriptionEnhancement;
+    /**
+     * Individual operation methods for backwards compatibility
+     */
+    /**
+     * Code review operation (standalone)
+     */
+    reviewCode(options: ReviewOptions): Promise<any>;
+    /**
+     * Description enhancement operation (standalone)
+     */
+    enhanceDescription(options: EnhancementOptions): Promise<any>;
+    /**
+     * Health check for all components
+     */
+    healthCheck(): Promise<{
+        healthy: boolean;
+        components: any;
+    }>;
+    /**
+     * Get comprehensive statistics
+     */
+    getStats(): any;
+    /**
+     * Clear all caches
+     */
+    clearCache(): void;
+    /**
+     * Ensure Guardian is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Shutdown Guardian gracefully
+     */
+    shutdown(): Promise<void>;
+}
+export declare function createGuardian(config?: Partial<GuardianConfig>): Guardian;
+export declare const guardian: Guardian;
+//# sourceMappingURL=Guardian.d.ts.map