@juspay/yama 1.0.0 → 1.1.1

package/dist/core/ContextGatherer.js

@@ -1,18 +1,17 @@
-"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 {
+import { ProviderError, } from "../types/index.js";
+import { logger } from "../utils/Logger.js";
+import { cache, Cache } from "../utils/Cache.js";
+export class ContextGatherer {
+    neurolink;
+    bitbucketProvider;
+    aiConfig;
+    startTime = 0;
     constructor(bitbucketProvider, aiConfig) {
-        this.startTime = 0;
         this.bitbucketProvider = bitbucketProvider;
         this.aiConfig = aiConfig;
     }
@@ -23,8 +22,8 @@ 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);
@@ -36,7 +35,7 @@ class ContextGatherer {
             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;
@@ -61,72 +60,72 @@ class ContextGatherer {
                 cacheHits,
                 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)) {
+            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);
         }
         // 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)) {
+            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);
             // 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)) {
+            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,
                 });
             }, 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)) {
+        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");
+                    logger.debug("No memory-bank directory found");
                     return {
                         memoryBank: {
                             summary: "No project context available",
@@ -145,20 +144,20 @@ class ContextGatherer {
                     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}`);
+                        logger.debug(`✓ Got content for: ${file.name}`);
                     }
                     catch (error) {
-                        Logger_1.logger.debug(`Could not read file ${file.name}: ${error.message}`);
+                        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");
+                    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);
@@ -176,7 +175,7 @@ Standards: ${contextData.standards}`,
                 };
             }
             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",
@@ -210,8 +209,7 @@ 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
@@ -235,7 +233,7 @@ Extract and summarize the content and return ONLY this JSON format:
             });
             // 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);
@@ -249,7 +247,7 @@ Extract and summarize the content and return ONLY this JSON format:
             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",
@@ -322,12 +320,12 @@ Extract and summarize the content and return ONLY this JSON format:
      * 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)) {
+        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);
     }
@@ -335,21 +333,21 @@ Extract and summarize the content and return ONLY this JSON format:
      * 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`);
+        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]);
                     return fileDiff.diff;
@@ -364,7 +362,7 @@ Extract and summarize the content and return ONLY this JSON format:
                 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;
     }
     /**
@@ -372,9 +370,9 @@ 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}`,
@@ -386,9 +384,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;
@@ -397,9 +395,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
@@ -441,14 +439,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) {
+export function createContextGatherer(bitbucketProvider, aiConfig) {
     return new ContextGatherer(bitbucketProvider, aiConfig);
 }
 //# sourceMappingURL=ContextGatherer.js.map

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,26 @@ 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.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,15 +62,15 @@ 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") {
@@ -96,14 +97,14 @@ class Guardian {
                     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;
         }
     }
@@ -212,7 +213,7 @@ class Guardian {
         // 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
@@ -258,7 +259,7 @@ class Guardian {
             };
         }
         catch (error) {
-            Logger_1.logger.error(`Operation ${operation} failed: ${error.message}`);
+            logger.error(`Operation ${operation} failed: ${error.message}`);
             return {
                 operation,
                 status: "error",
@@ -273,16 +274,16 @@ class Guardian {
      */
     async executeCodeReview(context, options) {
         if (!this.config.features.codeReview.enabled) {
-            Logger_1.logger.info("Code review is disabled in configuration");
+            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,
         };
@@ -294,16 +295,16 @@ class Guardian {
      */
     async executeDescriptionEnhancement(context, options) {
         if (!this.config.features.descriptionEnhancement.enabled) {
-            Logger_1.logger.info("Description enhancement is disabled in configuration");
+            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,
@@ -325,7 +326,7 @@ class Guardian {
             branch: options.branch,
             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, {
@@ -334,11 +335,11 @@ class Guardian {
                 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;
         }
     }
@@ -353,18 +354,18 @@ class Guardian {
             branch: options.branch,
             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
             });
             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,7 +380,7 @@ class Guardian {
             // Check cache
             components.cache = {
                 healthy: true,
-                stats: Cache_1.cache.stats(),
+                stats: cache.stats(),
             };
             // Check NeuroLink (if initialized)
             components.neurolink = {
@@ -416,16 +417,16 @@ class Guardian {
                 bitbucket: this.bitbucketProvider?.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 +440,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;