@juspay/yama 1.1.0

package/dist/core/Guardian.js

@@ -0,0 +1,457 @@
+"use strict";
+/**
+ * Yama - Unified orchestrator class
+ * The main class that coordinates all operations using shared context
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guardian = exports.Guardian = void 0;
+exports.createGuardian = createGuardian;
+const types_1 = require("../types");
+const BitbucketProvider_1 = require("./providers/BitbucketProvider");
+const ContextGatherer_1 = require("./ContextGatherer");
+const CodeReviewer_1 = require("../features/CodeReviewer");
+const DescriptionEnhancer_1 = require("../features/DescriptionEnhancer");
+const Logger_1 = require("../utils/Logger");
+const ConfigManager_1 = require("../utils/ConfigManager");
+const Cache_1 = require("../utils/Cache");
+class Guardian {
+    constructor(config) {
+        this.initialized = false;
+        this.config = {};
+        if (config) {
+            this.config = { ...this.config, ...config };
+        }
+    }
+    /**
+     * Initialize Guardian with configuration
+     */
+    async initialize(configPath) {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            Logger_1.logger.badge();
+            Logger_1.logger.phase('🚀 Initializing Yama...');
+            // Load configuration
+            this.config = await ConfigManager_1.configManager.loadConfig(configPath);
+            // Initialize providers
+            this.bitbucketProvider = new BitbucketProvider_1.BitbucketProvider(this.config.providers.git.credentials);
+            await this.bitbucketProvider.initialize();
+            // Initialize NeuroLink with eval-based dynamic import to bypass TypeScript compilation
+            const dynamicImport = eval('(specifier) => import(specifier)');
+            const { NeuroLink } = await dynamicImport('@juspay/neurolink');
+            this.neurolink = new NeuroLink();
+            // Initialize core components
+            this.contextGatherer = new ContextGatherer_1.ContextGatherer(this.bitbucketProvider, this.config.providers.ai);
+            this.codeReviewer = new CodeReviewer_1.CodeReviewer(this.bitbucketProvider, this.config.providers.ai, this.config.features.codeReview);
+            this.descriptionEnhancer = new DescriptionEnhancer_1.DescriptionEnhancer(this.bitbucketProvider, this.config.providers.ai);
+            this.initialized = true;
+            Logger_1.logger.success('✅ Yama initialized successfully');
+        }
+        catch (error) {
+            Logger_1.logger.error(`Failed to initialize Yama: ${error.message}`);
+            throw new types_1.GuardianError('INITIALIZATION_ERROR', `Initialization failed: ${error.message}`);
+        }
+    }
+    /**
+     * Main method: Process PR with multiple operations using unified context
+     */
+    async processPR(options) {
+        await this.ensureInitialized();
+        const startTime = Date.now();
+        const operations = [];
+        try {
+            Logger_1.logger.operation('PR Processing', 'started');
+            Logger_1.logger.info(`Target: ${options.workspace}/${options.repository}`);
+            Logger_1.logger.info(`Operations: ${options.operations.join(', ')}`);
+            Logger_1.logger.info(`Mode: ${options.dryRun ? 'DRY RUN' : 'LIVE'}`);
+            // Step 1: Gather unified context ONCE for all operations
+            Logger_1.logger.phase('📋 Gathering unified context...');
+            const context = await this.gatherUnifiedContext(options);
+            Logger_1.logger.success(`Context ready: PR #${context.pr.id} - "${context.pr.title}"`);
+            Logger_1.logger.info(`Files: ${context.diffStrategy.fileCount}, Strategy: ${context.diffStrategy.strategy}`);
+            // Step 2: Execute requested operations using shared context
+            for (const operation of options.operations) {
+                if (operation === 'all') {
+                    // Execute all available operations
+                    operations.push(await this.executeOperation('review', context, options));
+                    operations.push(await this.executeOperation('enhance-description', context, options));
+                }
+                else {
+                    operations.push(await this.executeOperation(operation, context, options));
+                }
+            }
+            const duration = Date.now() - startTime;
+            const successCount = operations.filter(op => op.status === 'success').length;
+            const errorCount = operations.filter(op => op.status === 'error').length;
+            const skippedCount = operations.filter(op => op.status === 'skipped').length;
+            const result = {
+                pullRequest: context.pr,
+                operations,
+                summary: {
+                    totalOperations: operations.length,
+                    successCount,
+                    errorCount,
+                    skippedCount,
+                    totalDuration: duration
+                }
+            };
+            Logger_1.logger.operation('PR Processing', 'completed');
+            Logger_1.logger.success(`✅ Processing completed in ${Math.round(duration / 1000)}s: ` +
+                `${successCount} success, ${errorCount} errors, ${skippedCount} skipped`);
+            return result;
+        }
+        catch (error) {
+            Logger_1.logger.operation('PR Processing', 'failed');
+            Logger_1.logger.error(`Processing failed: ${error.message}`);
+            throw error;
+        }
+    }
+    /**
+     * Streaming version of processPR for real-time updates
+     */
+    async *processPRStream(options, _streamOptions) {
+        await this.ensureInitialized();
+        const startTime = Date.now();
+        try {
+            // Initial update
+            yield {
+                operation: 'all',
+                status: 'started',
+                message: 'Yama processing initiated',
+                timestamp: new Date().toISOString()
+            };
+            // Context gathering phase
+            yield {
+                operation: 'all',
+                status: 'progress',
+                progress: 10,
+                message: 'Gathering unified context...',
+                timestamp: new Date().toISOString()
+            };
+            const context = await this.gatherUnifiedContext(options);
+            yield {
+                operation: 'all',
+                status: 'progress',
+                progress: 30,
+                message: `Context ready: PR #${context.pr.id}`,
+                data: { prId: context.pr.id, title: context.pr.title },
+                timestamp: new Date().toISOString()
+            };
+            // Execute operations with progress updates
+            const totalOps = options.operations.length;
+            let completedOps = 0;
+            for (const operation of options.operations) {
+                yield {
+                    operation,
+                    status: 'started',
+                    message: `Starting ${operation}...`,
+                    timestamp: new Date().toISOString()
+                };
+                try {
+                    const result = await this.executeOperation(operation, context, options);
+                    if (result.status === 'error') {
+                        yield {
+                            operation,
+                            status: 'error',
+                            message: `${operation} failed: ${result.error}`,
+                            timestamp: new Date().toISOString()
+                        };
+                    }
+                    else {
+                        completedOps++;
+                        yield {
+                            operation,
+                            status: 'completed',
+                            progress: 30 + Math.round((completedOps / totalOps) * 60),
+                            message: `${operation} completed`,
+                            data: result,
+                            timestamp: new Date().toISOString()
+                        };
+                    }
+                }
+                catch (error) {
+                    // This catch is for unexpected errors that bypass executeOperation's own error handling
+                    yield {
+                        operation,
+                        status: 'error',
+                        message: `${operation} failed: ${error.message}`,
+                        timestamp: new Date().toISOString()
+                    };
+                }
+            }
+            // Final completion
+            const duration = Date.now() - startTime;
+            yield {
+                operation: 'all',
+                status: 'completed',
+                progress: 100,
+                message: `Processing completed in ${Math.round(duration / 1000)}s`,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            yield {
+                operation: 'all',
+                status: 'error',
+                message: `Processing failed: ${error.message}`,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+    /**
+     * Gather unified context (cached and reusable)
+     */
+    async gatherUnifiedContext(options) {
+        const identifier = {
+            workspace: options.workspace,
+            repository: options.repository,
+            branch: options.branch,
+            pullRequestId: options.pullRequestId
+        };
+        // Check if we have cached context first
+        const cachedContext = await this.contextGatherer.getCachedContext(identifier);
+        if (cachedContext && options.config?.cache?.enabled !== false) {
+            Logger_1.logger.debug('✓ Using cached context');
+            return cachedContext;
+        }
+        // Determine what operations need diff data
+        const needsDiff = options.operations.some(op => op === 'review' || op === 'security-scan' || op === 'all');
+        const contextOptions = {
+            excludePatterns: this.config.features.codeReview.excludePatterns,
+            contextLines: this.config.features.codeReview.contextLines,
+            forceRefresh: false,
+            includeDiff: needsDiff,
+            diffStrategyConfig: this.config.features.diffStrategy
+        };
+        return await this.contextGatherer.gatherContext(identifier, contextOptions);
+    }
+    /**
+     * Execute individual operation using shared context
+     */
+    async executeOperation(operation, context, options) {
+        const startTime = Date.now();
+        try {
+            let data;
+            switch (operation) {
+                case 'review':
+                    data = await this.executeCodeReview(context, options);
+                    break;
+                case 'enhance-description':
+                    data = await this.executeDescriptionEnhancement(context, options);
+                    break;
+                case 'security-scan':
+                    // TODO: Implement in future phases
+                    throw new Error('Security scan not implemented in Phase 1');
+                case 'analytics':
+                    // TODO: Implement in future phases
+                    throw new Error('Analytics not implemented in Phase 1');
+                default:
+                    throw new Error(`Unknown operation: ${operation}`);
+            }
+            return {
+                operation,
+                status: 'success',
+                data,
+                duration: Date.now() - startTime,
+                timestamp: new Date().toISOString()
+            };
+        }
+        catch (error) {
+            Logger_1.logger.error(`Operation ${operation} failed: ${error.message}`);
+            return {
+                operation,
+                status: 'error',
+                error: error.message,
+                duration: Date.now() - startTime,
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+    /**
+     * Execute code review using shared context
+     */
+    async executeCodeReview(context, options) {
+        if (!this.config.features.codeReview.enabled) {
+            Logger_1.logger.info('Code review is disabled in configuration');
+            return { skipped: true, reason: 'disabled in config' };
+        }
+        Logger_1.logger.phase('🔍 Executing code review...');
+        const reviewOptions = {
+            workspace: context.identifier.workspace,
+            repository: context.identifier.repository,
+            pullRequestId: context.identifier.pullRequestId,
+            dryRun: options.dryRun,
+            verbose: Logger_1.logger.getConfig().verbose,
+            excludePatterns: this.config.features.codeReview.excludePatterns,
+            contextLines: this.config.features.codeReview.contextLines
+        };
+        // Use the already gathered context instead of gathering again
+        return await this.codeReviewer.reviewCodeWithContext(context, reviewOptions);
+    }
+    /**
+     * Execute description enhancement using shared context
+     */
+    async executeDescriptionEnhancement(context, options) {
+        if (!this.config.features.descriptionEnhancement.enabled) {
+            Logger_1.logger.info('Description enhancement is disabled in configuration');
+            return { skipped: true, reason: 'disabled in config' };
+        }
+        Logger_1.logger.phase('📝 Executing description enhancement...');
+        const enhancementOptions = {
+            workspace: context.identifier.workspace,
+            repository: context.identifier.repository,
+            pullRequestId: context.identifier.pullRequestId,
+            dryRun: options.dryRun,
+            verbose: Logger_1.logger.getConfig().verbose,
+            preserveContent: this.config.features.descriptionEnhancement.preserveContent,
+            ensureRequiredSections: true,
+            customSections: this.config.features.descriptionEnhancement.requiredSections
+        };
+        // Use the already gathered context instead of gathering again
+        return await this.descriptionEnhancer.enhanceWithContext(context, enhancementOptions);
+    }
+    /**
+     * Individual operation methods for backwards compatibility
+     */
+    /**
+     * Code review operation (standalone)
+     */
+    async reviewCode(options) {
+        await this.ensureInitialized();
+        const identifier = {
+            workspace: options.workspace,
+            repository: options.repository,
+            branch: options.branch,
+            pullRequestId: options.pullRequestId
+        };
+        Logger_1.logger.operation('Code Review', 'started');
+        try {
+            // Gather context specifically for code review
+            const context = await this.contextGatherer.gatherContext(identifier, {
+                excludePatterns: options.excludePatterns,
+                contextLines: options.contextLines,
+                includeDiff: true
+            });
+            const result = await this.codeReviewer.reviewCodeWithContext(context, options);
+            Logger_1.logger.operation('Code Review', 'completed');
+            return result;
+        }
+        catch (error) {
+            Logger_1.logger.operation('Code Review', 'failed');
+            throw error;
+        }
+    }
+    /**
+     * Description enhancement operation (standalone)
+     */
+    async enhanceDescription(options) {
+        await this.ensureInitialized();
+        const identifier = {
+            workspace: options.workspace,
+            repository: options.repository,
+            branch: options.branch,
+            pullRequestId: options.pullRequestId
+        };
+        Logger_1.logger.operation('Description Enhancement', 'started');
+        try {
+            // Gather context specifically for description enhancement
+            const context = await this.contextGatherer.gatherContext(identifier, {
+                includeDiff: true // Description enhancement may need to see changes
+            });
+            const result = await this.descriptionEnhancer.enhanceWithContext(context, options);
+            Logger_1.logger.operation('Description Enhancement', 'completed');
+            return result;
+        }
+        catch (error) {
+            Logger_1.logger.operation('Description Enhancement', 'failed');
+            throw error;
+        }
+    }
+    /**
+     * Health check for all components
+     */
+    async healthCheck() {
+        const components = {};
+        try {
+            // Check Bitbucket provider
+            components.bitbucket = await this.bitbucketProvider.healthCheck();
+            // Check cache
+            components.cache = {
+                healthy: true,
+                stats: Cache_1.cache.stats()
+            };
+            // Check NeuroLink (if initialized)
+            components.neurolink = {
+                healthy: true,
+                initialized: !!this.neurolink
+            };
+            const allHealthy = Object.values(components).every((comp) => comp.healthy);
+            return {
+                healthy: allHealthy,
+                components
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                components: {
+                    ...components,
+                    error: error.message
+                }
+            };
+        }
+    }
+    /**
+     * Get comprehensive statistics
+     */
+    getStats() {
+        return {
+            initialized: this.initialized,
+            config: {
+                features: Object.keys(this.config.features || {}),
+                cacheEnabled: this.config.cache?.enabled
+            },
+            providers: {
+                bitbucket: this.bitbucketProvider?.getStats(),
+                context: this.contextGatherer?.getStats()
+            },
+            cache: Cache_1.cache.stats()
+        };
+    }
+    /**
+     * Clear all caches
+     */
+    clearCache() {
+        Cache_1.cache.clear();
+        this.bitbucketProvider?.clearCache();
+        Logger_1.logger.info('All caches cleared');
+    }
+    /**
+     * Ensure Guardian is initialized
+     */
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Shutdown Guardian gracefully
+     */
+    async shutdown() {
+        Logger_1.logger.info('Shutting down Yama...');
+        // Clear caches
+        this.clearCache();
+        // Reset state
+        this.initialized = false;
+        Logger_1.logger.success('Yama shutdown complete');
+    }
+}
+exports.Guardian = Guardian;
+// Export factory function
+function createGuardian(config) {
+    return new Guardian(config);
+}
+// Export default instance
+exports.guardian = new Guardian();
+//# sourceMappingURL=Guardian.js.map

package/dist/core/providers/BitbucketProvider.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Enhanced Bitbucket Provider - Optimized from both pr-police.js and pr-describe.js
+ * Provides unified, cached, and optimized Bitbucket operations
+ */
+import { PRIdentifier, PRInfo, PRDiff, GitCredentials } from '../../types';
+export interface BitbucketMCPResponse {
+    content?: Array<{
+        text?: string;
+    }>;
+    message?: string;
+    error?: string;
+}
+export declare class BitbucketProvider {
+    private apiClient;
+    private branchHandlers;
+    private pullRequestHandlers;
+    private reviewHandlers;
+    private fileHandlers;
+    private initialized;
+    private baseUrl;
+    private credentials;
+    constructor(credentials: GitCredentials);
+    /**
+     * Initialize MCP handlers with lazy loading and connection reuse
+     */
+    initialize(): Promise<void>;
+    /**
+     * Parse MCP response - exactly matching the working pr-police.js implementation
+     */
+    private parseMCPResponse;
+    /**
+     * Find PR for branch with intelligent caching
+     */
+    findPRForBranch(identifier: PRIdentifier): Promise<PRInfo>;
+    /**
+     * Get PR details with enhanced caching
+     */
+    getPRDetails(identifier: PRIdentifier): Promise<PRInfo>;
+    /**
+     * Get PR diff with smart caching and filtering
+     */
+    getPRDiff(identifier: PRIdentifier, contextLines?: number, excludePatterns?: string[], includePatterns?: string[]): Promise<PRDiff>;
+    /**
+     * Get file content with caching
+     */
+    getFileContent(workspace: string, repository: string, filePath: string, branch: string): Promise<string>;
+    /**
+     * List directory content with caching
+     */
+    listDirectoryContent(workspace: string, repository: string, path: string, branch: string): Promise<any[]>;
+    /**
+     * Update PR description with reviewer preservation
+     */
+    updatePRDescription(identifier: PRIdentifier, description: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    /**
+     * Add comment to PR with smart positioning
+     */
+    addComment(identifier: PRIdentifier, commentText: string, options?: {
+        filePath?: string;
+        lineNumber?: number;
+        lineType?: 'ADDED' | 'REMOVED' | 'CONTEXT';
+        codeSnippet?: string;
+        searchContext?: {
+            before: string[];
+            after: string[];
+        };
+        matchStrategy?: 'exact' | 'best' | 'strict';
+        suggestion?: string;
+    }): Promise<{
+        success: boolean;
+        commentId?: number;
+    }>;
+    /**
+     * Batch operation support for multiple API calls
+     */
+    batchOperations<T>(operations: Array<() => Promise<T>>, options?: {
+        maxConcurrent?: number;
+        delayBetween?: number;
+        continueOnError?: boolean;
+    }): Promise<Array<{
+        success: boolean;
+        data?: T;
+        error?: string;
+    }>>;
+    /**
+     * Health check for the provider
+     */
+    healthCheck(): Promise<{
+        healthy: boolean;
+        details: any;
+    }>;
+    /**
+     * Get provider statistics and cache metrics
+     */
+    getStats(): any;
+    /**
+     * Clear provider-related cache entries
+     */
+    clearCache(): void;
+}
+export declare function createBitbucketProvider(credentials: GitCredentials): BitbucketProvider;
+//# sourceMappingURL=BitbucketProvider.d.ts.map