@juspay/yama 1.1.0 → 1.2.0

package/dist/core/Guardian.d.ts

@@ -2,7 +2,7 @@
  * Yama - Unified orchestrator class
  * The main class that coordinates all operations using shared context
  */
-import { GuardianConfig, OperationOptions, ProcessResult, StreamUpdate, StreamOptions, ReviewOptions, EnhancementOptions } from '../types';
+import { GuardianConfig, OperationOptions, ProcessResult, StreamUpdate, StreamOptions, ReviewOptions, EnhancementOptions } from "../types/index.js";
 export declare class Guardian {
     private config;
     private bitbucketProvider;

package/dist/core/Guardian.js

@@ -1,22 +1,24 @@
-"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 {
+import { GuardianError, } from "../types/index.js";
+import { BitbucketProvider } from "./providers/BitbucketProvider.js";
+import { ContextGatherer } from "./ContextGatherer.js";
+import { CodeReviewer } from "../features/CodeReviewer.js";
+import { DescriptionEnhancer } from "../features/DescriptionEnhancer.js";
+import { logger } from "../utils/Logger.js";
+import { configManager } from "../utils/ConfigManager.js";
+import { cache } from "../utils/Cache.js";
+export class Guardian {
+    config;
+    bitbucketProvider;
+    contextGatherer;
+    codeReviewer;
+    descriptionEnhancer;
+    neurolink;
+    initialized = false;
     constructor(config) {
-        this.initialized = false;
         this.config = {};
         if (config) {
             this.config = { ...this.config, ...config };
@@ -30,27 +32,30 @@ class Guardian {
             return;
         }
         try {
-            Logger_1.logger.badge();
-            Logger_1.logger.phase('🚀 Initializing Yama...');
+            logger.badge();
+            logger.phase("🚀 Initializing Yama...");
             // Load configuration
-            this.config = await ConfigManager_1.configManager.loadConfig(configPath);
+            this.config = await configManager.loadConfig(configPath);
             // Initialize providers
-            this.bitbucketProvider = new BitbucketProvider_1.BitbucketProvider(this.config.providers.git.credentials);
+            this.bitbucketProvider = new 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');
+            // Initialize NeuroLink with native ESM dynamic import
+            const { NeuroLink } = await import("@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.contextGatherer = new ContextGatherer(this.bitbucketProvider, this.config.providers.ai, this.config.memoryBank || {
+                enabled: true,
+                path: "memory-bank",
+                fallbackPaths: ["docs/memory-bank", ".memory-bank"],
+            });
+            this.codeReviewer = new CodeReviewer(this.bitbucketProvider, this.config.providers.ai, this.config.features.codeReview);
+            this.descriptionEnhancer = new DescriptionEnhancer(this.bitbucketProvider, this.config.providers.ai);
             this.initialized = true;
-            Logger_1.logger.success('✅ Yama initialized successfully');
+            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}`);
+            logger.error(`Failed to initialize Yama: ${error.message}`);
+            throw new GuardianError("INITIALIZATION_ERROR", `Initialization failed: ${error.message}`);
         }
     }
     /**
@@ -61,30 +66,30 @@ class Guardian {
         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'}`);
+            logger.operation("PR Processing", "started");
+            logger.info(`Target: ${options.workspace}/${options.repository}`);
+            logger.info(`Operations: ${options.operations.join(", ")}`);
+            logger.info(`Mode: ${options.dryRun ? "DRY RUN" : "LIVE"}`);
             // Step 1: Gather unified context ONCE for all operations
-            Logger_1.logger.phase('📋 Gathering unified context...');
+            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}`);
+            logger.success(`Context ready: PR #${context.pr.id} - "${context.pr.title}"`);
+            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') {
+                if (operation === "all") {
                     // Execute all available operations
-                    operations.push(await this.executeOperation('review', context, options));
-                    operations.push(await this.executeOperation('enhance-description', context, options));
+                    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 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,
@@ -93,17 +98,17 @@ class Guardian {
                     successCount,
                     errorCount,
                     skippedCount,
-                    totalDuration: duration
-                }
+                    totalDuration: duration,
+                },
             };
-            Logger_1.logger.operation('PR Processing', 'completed');
-            Logger_1.logger.success(`✅ Processing completed in ${Math.round(duration / 1000)}s: ` +
+            logger.operation("PR Processing", "completed");
+            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}`);
+            logger.operation("PR Processing", "failed");
+            logger.error(`Processing failed: ${error.message}`);
             throw error;
         }
     }
@@ -116,27 +121,27 @@ class Guardian {
         try {
             // Initial update
             yield {
-                operation: 'all',
-                status: 'started',
-                message: 'Yama processing initiated',
-                timestamp: new Date().toISOString()
+                operation: "all",
+                status: "started",
+                message: "Yama processing initiated",
+                timestamp: new Date().toISOString(),
             };
             // Context gathering phase
             yield {
-                operation: 'all',
-                status: 'progress',
+                operation: "all",
+                status: "progress",
                 progress: 10,
-                message: 'Gathering unified context...',
-                timestamp: new Date().toISOString()
+                message: "Gathering unified context...",
+                timestamp: new Date().toISOString(),
             };
             const context = await this.gatherUnifiedContext(options);
             yield {
-                operation: 'all',
-                status: 'progress',
+                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()
+                timestamp: new Date().toISOString(),
             };
             // Execute operations with progress updates
             const totalOps = options.operations.length;
@@ -144,29 +149,29 @@ class Guardian {
             for (const operation of options.operations) {
                 yield {
                     operation,
-                    status: 'started',
+                    status: "started",
                     message: `Starting ${operation}...`,
-                    timestamp: new Date().toISOString()
+                    timestamp: new Date().toISOString(),
                 };
                 try {
                     const result = await this.executeOperation(operation, context, options);
-                    if (result.status === 'error') {
+                    if (result.status === "error") {
                         yield {
                             operation,
-                            status: 'error',
+                            status: "error",
                             message: `${operation} failed: ${result.error}`,
-                            timestamp: new Date().toISOString()
+                            timestamp: new Date().toISOString(),
                         };
                     }
                     else {
                         completedOps++;
                         yield {
                             operation,
-                            status: 'completed',
+                            status: "completed",
                             progress: 30 + Math.round((completedOps / totalOps) * 60),
                             message: `${operation} completed`,
                             data: result,
-                            timestamp: new Date().toISOString()
+                            timestamp: new Date().toISOString(),
                         };
                     }
                 }
@@ -174,28 +179,28 @@ class Guardian {
                     // This catch is for unexpected errors that bypass executeOperation's own error handling
                     yield {
                         operation,
-                        status: 'error',
+                        status: "error",
                         message: `${operation} failed: ${error.message}`,
-                        timestamp: new Date().toISOString()
+                        timestamp: new Date().toISOString(),
                     };
                 }
             }
             // Final completion
             const duration = Date.now() - startTime;
             yield {
-                operation: 'all',
-                status: 'completed',
+                operation: "all",
+                status: "completed",
                 progress: 100,
                 message: `Processing completed in ${Math.round(duration / 1000)}s`,
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString(),
             };
         }
         catch (error) {
             yield {
-                operation: 'all',
-                status: 'error',
+                operation: "all",
+                status: "error",
                 message: `Processing failed: ${error.message}`,
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString(),
             };
         }
     }
@@ -207,22 +212,22 @@ class Guardian {
             workspace: options.workspace,
             repository: options.repository,
             branch: options.branch,
-            pullRequestId: options.pullRequestId
+            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');
+            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 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
+            diffStrategyConfig: this.config.features.diffStrategy,
         };
         return await this.contextGatherer.gatherContext(identifier, contextOptions);
     }
@@ -234,37 +239,37 @@ class Guardian {
         try {
             let data;
             switch (operation) {
-                case 'review':
+                case "review":
                     data = await this.executeCodeReview(context, options);
                     break;
-                case 'enhance-description':
+                case "enhance-description":
                     data = await this.executeDescriptionEnhancement(context, options);
                     break;
-                case 'security-scan':
+                case "security-scan":
                     // TODO: Implement in future phases
-                    throw new Error('Security scan not implemented in Phase 1');
-                case 'analytics':
+                    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');
+                    throw new Error("Analytics not implemented in Phase 1");
                 default:
                     throw new Error(`Unknown operation: ${operation}`);
             }
             return {
                 operation,
-                status: 'success',
+                status: "success",
                 data,
                 duration: Date.now() - startTime,
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString(),
             };
         }
         catch (error) {
-            Logger_1.logger.error(`Operation ${operation} failed: ${error.message}`);
+            logger.error(`Operation ${operation} failed: ${error.message}`);
             return {
                 operation,
-                status: 'error',
+                status: "error",
                 error: error.message,
                 duration: Date.now() - startTime,
-                timestamp: new Date().toISOString()
+                timestamp: new Date().toISOString(),
             };
         }
     }
@@ -273,18 +278,18 @@ class Guardian {
      */
     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.info("Code review is disabled in configuration");
+            return { skipped: true, reason: "disabled in config" };
         }
-        Logger_1.logger.phase('🔍 Executing code review...');
+        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,
+            verbose: logger.getConfig().verbose,
             excludePatterns: this.config.features.codeReview.excludePatterns,
-            contextLines: this.config.features.codeReview.contextLines
+            contextLines: this.config.features.codeReview.contextLines,
         };
         // Use the already gathered context instead of gathering again
         return await this.codeReviewer.reviewCodeWithContext(context, reviewOptions);
@@ -294,19 +299,19 @@ class Guardian {
      */
     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.info("Description enhancement is disabled in configuration");
+            return { skipped: true, reason: "disabled in config" };
         }
-        Logger_1.logger.phase('📝 Executing description enhancement...');
+        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,
+            verbose: logger.getConfig().verbose,
             preserveContent: this.config.features.descriptionEnhancement.preserveContent,
             ensureRequiredSections: true,
-            customSections: this.config.features.descriptionEnhancement.requiredSections
+            customSections: this.config.features.descriptionEnhancement.requiredSections,
         };
         // Use the already gathered context instead of gathering again
         return await this.descriptionEnhancer.enhanceWithContext(context, enhancementOptions);
@@ -323,22 +328,22 @@ class Guardian {
             workspace: options.workspace,
             repository: options.repository,
             branch: options.branch,
-            pullRequestId: options.pullRequestId
+            pullRequestId: options.pullRequestId,
         };
-        Logger_1.logger.operation('Code Review', 'started');
+        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
+                includeDiff: true,
             });
             const result = await this.codeReviewer.reviewCodeWithContext(context, options);
-            Logger_1.logger.operation('Code Review', 'completed');
+            logger.operation("Code Review", "completed");
             return result;
         }
         catch (error) {
-            Logger_1.logger.operation('Code Review', 'failed');
+            logger.operation("Code Review", "failed");
             throw error;
         }
     }
@@ -351,20 +356,20 @@ class Guardian {
             workspace: options.workspace,
             repository: options.repository,
             branch: options.branch,
-            pullRequestId: options.pullRequestId
+            pullRequestId: options.pullRequestId,
         };
-        Logger_1.logger.operation('Description Enhancement', 'started');
+        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
+                includeDiff: true, // Description enhancement may need to see changes
             });
             const result = await this.descriptionEnhancer.enhanceWithContext(context, options);
-            Logger_1.logger.operation('Description Enhancement', 'completed');
+            logger.operation("Description Enhancement", "completed");
             return result;
         }
         catch (error) {
-            Logger_1.logger.operation('Description Enhancement', 'failed');
+            logger.operation("Description Enhancement", "failed");
             throw error;
         }
     }
@@ -379,17 +384,17 @@ class Guardian {
             // Check cache
             components.cache = {
                 healthy: true,
-                stats: Cache_1.cache.stats()
+                stats: cache.stats(),
             };
             // Check NeuroLink (if initialized)
             components.neurolink = {
                 healthy: true,
-                initialized: !!this.neurolink
+                initialized: !!this.neurolink,
             };
             const allHealthy = Object.values(components).every((comp) => comp.healthy);
             return {
                 healthy: allHealthy,
-                components
+                components,
             };
         }
         catch (error) {
@@ -397,8 +402,8 @@ class Guardian {
                 healthy: false,
                 components: {
                     ...components,
-                    error: error.message
-                }
+                    error: error.message,
+                },
             };
         }
     }
@@ -410,22 +415,22 @@ class Guardian {
             initialized: this.initialized,
             config: {
                 features: Object.keys(this.config.features || {}),
-                cacheEnabled: this.config.cache?.enabled
+                cacheEnabled: this.config.cache?.enabled,
             },
             providers: {
                 bitbucket: this.bitbucketProvider?.getStats(),
-                context: this.contextGatherer?.getStats()
+                context: this.contextGatherer?.getStats(),
             },
-            cache: Cache_1.cache.stats()
+            cache: cache.stats(),
         };
     }
     /**
      * Clear all caches
      */
     clearCache() {
-        Cache_1.cache.clear();
+        cache.clear();
         this.bitbucketProvider?.clearCache();
-        Logger_1.logger.info('All caches cleared');
+        logger.info("All caches cleared");
     }
     /**
      * Ensure Guardian is initialized
@@ -439,19 +444,18 @@ class Guardian {
      * Shutdown Guardian gracefully
      */
     async shutdown() {
-        Logger_1.logger.info('Shutting down Yama...');
+        logger.info("Shutting down Yama...");
         // Clear caches
         this.clearCache();
         // Reset state
         this.initialized = false;
-        Logger_1.logger.success('Yama shutdown complete');
+        logger.success("Yama shutdown complete");
     }
 }
-exports.Guardian = Guardian;
 // Export factory function
-function createGuardian(config) {
+export function createGuardian(config) {
     return new Guardian(config);
 }
 // Export default instance
-exports.guardian = new Guardian();
+export const guardian = new Guardian();
 //# sourceMappingURL=Guardian.js.map

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

@@ -2,7 +2,7 @@
  * 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';
+import { PRIdentifier, PRInfo, PRDiff, GitCredentials } from "../../types/index.js";
 export interface BitbucketMCPResponse {
     content?: Array<{
         text?: string;
@@ -61,13 +61,13 @@ export declare class BitbucketProvider {
     addComment(identifier: PRIdentifier, commentText: string, options?: {
         filePath?: string;
         lineNumber?: number;
-        lineType?: 'ADDED' | 'REMOVED' | 'CONTEXT';
+        lineType?: "ADDED" | "REMOVED" | "CONTEXT";
         codeSnippet?: string;
         searchContext?: {
             before: string[];
             after: string[];
         };
-        matchStrategy?: 'exact' | 'best' | 'strict';
+        matchStrategy?: "exact" | "best" | "strict";
         suggestion?: string;
     }): Promise<{
         success: boolean;