@juspay/yama 1.6.0 → 2.0.0

package/dist/utils/ExactDuplicateRemover.js

@@ -1,361 +0,0 @@
-/**
- * Exact Duplicate Removal Utility for Multi-Instance Processing
- * Handles deduplication of violations from multiple Neurolink SDK instances
- */
-import { createHash } from "crypto";
-import { logger } from "./Logger.js";
-/**
- * Exact Duplicate Remover for Multi-Instance Results
- * Implements multi-level deduplication strategy
- */
-export class ExactDuplicateRemover {
-    /**
-     * Remove exact duplicates from multiple instance results
-     */
-    removeDuplicates(instanceResults) {
-        const startTime = Date.now();
-        logger.debug("🔍 Starting exact duplicate removal process");
-        // Step 1: Flatten all violations with source tracking
-        const allViolations = this.flattenViolationsWithSource(instanceResults);
-        logger.debug(`📊 Total violations from all instances: ${allViolations.length}`);
-        // Step 2: Remove exact hash duplicates
-        const exactDuplicates = this.removeExactHashDuplicates(allViolations);
-        logger.debug(`🎯 Exact duplicates removed: ${exactDuplicates.removed}`);
-        // Step 3: Remove normalized duplicates
-        const normalizedDuplicates = this.removeNormalizedDuplicates(exactDuplicates.unique);
-        logger.debug(`📝 Normalized duplicates removed: ${normalizedDuplicates.removed}`);
-        // Step 4: Remove same file+line duplicates
-        const finalResult = this.removeSameLineDuplicates(normalizedDuplicates.unique);
-        logger.debug(`📍 Same-line duplicates removed: ${finalResult.removed}`);
-        // Step 5: Track contributions and create metrics
-        const instanceContributions = this.trackContributions(finalResult.unique);
-        const processingTime = Date.now() - startTime;
-        const metrics = {
-            totalViolationsInput: allViolations.length,
-            exactDuplicatesRemoved: exactDuplicates.removed,
-            normalizedDuplicatesRemoved: normalizedDuplicates.removed,
-            sameLineDuplicatesRemoved: finalResult.removed,
-            finalUniqueViolations: finalResult.unique.length,
-            deduplicationRate: ((allViolations.length - finalResult.unique.length) /
-                allViolations.length) *
-                100,
-            instanceContributions: Object.fromEntries(instanceContributions),
-            processingTimeMs: processingTime,
-        };
-        logger.success(`✅ Deduplication completed: ${allViolations.length} → ${finalResult.unique.length} violations ` +
-            `(${metrics.deduplicationRate.toFixed(1)}% reduction) in ${processingTime}ms`);
-        return {
-            uniqueViolations: finalResult.unique.map((v) => this.stripSourceInfo(v)),
-            duplicatesRemoved: {
-                exactDuplicates: exactDuplicates.removed,
-                normalizedDuplicates: normalizedDuplicates.removed,
-                sameLineDuplicates: finalResult.removed,
-            },
-            instanceContributions,
-            processingMetrics: metrics,
-        };
-    }
-    /**
-     * Flatten violations from all instances with source tracking
-     */
-    flattenViolationsWithSource(instanceResults) {
-        const allViolations = [];
-        for (const result of instanceResults) {
-            if (!result.success || !result.violations) {
-                logger.debug(`⚠️ Skipping failed instance: ${result.instanceName}`);
-                continue;
-            }
-            result.violations.forEach((violation, index) => {
-                allViolations.push({
-                    ...violation,
-                    source: result.instanceName,
-                    originalIndex: index,
-                });
-            });
-        }
-        return allViolations;
-    }
-    /**
-     * Remove exact hash duplicates (Level 1)
-     */
-    removeExactHashDuplicates(violations) {
-        const seenHashes = new Set();
-        const unique = [];
-        let removed = 0;
-        for (const violation of violations) {
-            const hash = this.createViolationHash(violation);
-            if (!seenHashes.has(hash)) {
-                seenHashes.add(hash);
-                unique.push(violation);
-            }
-            else {
-                removed++;
-                logger.debug(`🔄 Exact duplicate removed: ${violation.issue} (${violation.source})`);
-            }
-        }
-        return { unique, removed };
-    }
-    /**
-     * Remove normalized duplicates (Level 2)
-     */
-    removeNormalizedDuplicates(violations) {
-        const seenNormalizedHashes = new Set();
-        const unique = [];
-        let removed = 0;
-        for (const violation of violations) {
-            const normalizedHash = this.createNormalizedViolationHash(violation);
-            if (!seenNormalizedHashes.has(normalizedHash)) {
-                seenNormalizedHashes.add(normalizedHash);
-                unique.push(violation);
-            }
-            else {
-                removed++;
-                logger.debug(`📝 Normalized duplicate removed: ${violation.issue} (${violation.source})`);
-            }
-        }
-        return { unique, removed };
-    }
-    /**
-     * Remove same file+line duplicates (Level 3)
-     */
-    removeSameLineDuplicates(violations) {
-        const fileLineMap = new Map();
-        const uniqueMap = new Map();
-        let removed = 0;
-        for (const violation of violations) {
-            if (!violation.file || !violation.code_snippet) {
-                uniqueMap.set(`${violation.file}_${violation.originalIndex}`, violation);
-                continue;
-            }
-            const fileKey = violation.file;
-            const lineKey = this.normalizeCodeSnippet(violation.code_snippet);
-            const uniqueKey = `${violation.file}_${violation.originalIndex}`;
-            if (!fileLineMap.has(fileKey)) {
-                fileLineMap.set(fileKey, new Map());
-            }
-            const linesInFile = fileLineMap.get(fileKey);
-            if (linesInFile.has(lineKey)) {
-                // Duplicate found - resolve by severity and instance quality
-                const existing = linesInFile.get(lineKey);
-                const better = this.resolveDuplicateBySeverity([existing, violation]);
-                if (better === violation) {
-                    // Replace existing with current
-                    linesInFile.set(lineKey, violation);
-                    // Remove existing from unique map and add current
-                    const existingKey = `${existing.file}_${existing.originalIndex}`;
-                    uniqueMap.delete(existingKey);
-                    uniqueMap.set(uniqueKey, violation);
-                }
-                removed++;
-                logger.debug(`📍 Same-line duplicate resolved: ${violation.issue} (${violation.source})`);
-            }
-            else {
-                linesInFile.set(lineKey, violation);
-                uniqueMap.set(uniqueKey, violation);
-            }
-        }
-        return { unique: Array.from(uniqueMap.values()), removed };
-    }
-    /**
-     * Create hash for exact violation matching
-     */
-    createViolationHash(violation) {
-        const key = {
-            file: violation.file?.trim(),
-            code_snippet: violation.code_snippet?.trim(),
-            severity: violation.severity,
-            category: violation.category,
-            issue: violation.issue.trim(),
-            message: violation.message.trim(),
-        };
-        return createHash("sha256").update(JSON.stringify(key)).digest("hex");
-    }
-    /**
-     * Create hash for normalized violation matching
-     */
-    createNormalizedViolationHash(violation) {
-        const normalized = {
-            file: violation.file?.toLowerCase().trim(),
-            code_snippet: this.normalizeCodeSnippet(violation.code_snippet || ""),
-            severity: violation.severity,
-            category: violation.category,
-            issue: this.normalizeText(violation.issue),
-            message: this.normalizeText(violation.message),
-        };
-        return createHash("sha256")
-            .update(JSON.stringify(normalized))
-            .digest("hex");
-    }
-    /**
-     * Normalize code snippet for comparison
-     */
-    normalizeCodeSnippet(snippet) {
-        return snippet
-            .replace(/\s+/g, " ") // Normalize whitespace
-            .replace(/['"]/g, '"') // Normalize quotes
-            .replace(/;+$/, "") // Remove trailing semicolons
-            .replace(/[{}]/g, "") // Remove braces for comparison
-            .trim()
-            .toLowerCase();
-    }
-    /**
-     * Normalize text for comparison
-     */
-    normalizeText(text) {
-        return text
-            .toLowerCase()
-            .replace(/[^\w\s]/g, "") // Remove punctuation
-            .replace(/\s+/g, " ") // Normalize whitespace
-            .trim();
-    }
-    /**
-     * Resolve duplicate by severity (and potentially other factors)
-     */
-    resolveDuplicateBySeverity(duplicates) {
-        const severityOrder = {
-            CRITICAL: 4,
-            MAJOR: 3,
-            MINOR: 2,
-            SUGGESTION: 1,
-        };
-        return duplicates.reduce((best, current) => {
-            const bestScore = severityOrder[best.severity] || 0;
-            const currentScore = severityOrder[current.severity] || 0;
-            if (currentScore > bestScore) {
-                return current;
-            }
-            else if (currentScore === bestScore) {
-                // Same severity - could add more sophisticated logic here
-                // For now, prefer the first one (could be based on instance quality)
-                return best;
-            }
-            return best;
-        });
-    }
-    /**
-     * Track which instance contributed how many violations
-     */
-    trackContributions(violations) {
-        const contributions = new Map();
-        for (const violation of violations) {
-            const current = contributions.get(violation.source) || 0;
-            contributions.set(violation.source, current + 1);
-        }
-        return contributions;
-    }
-    /**
-     * Remove source tracking information from violation
-     */
-    stripSourceInfo(violation) {
-        const { source, originalIndex, ...cleanViolation } = violation;
-        return cleanViolation;
-    }
-    /**
-     * Remove violations that duplicate existing PR comments using semantic similarity
-     * Uses AI-powered ContentSimilarityService for intelligent deduplication
-     */
-    async removeAgainstExistingComments(newViolations, existingComments, aiConfig, similarityThreshold = 85) {
-        const startTime = Date.now();
-        logger.debug("🔍 Starting semantic comment deduplication process");
-        logger.debug(`📊 New violations: ${newViolations.length}, Existing comments: ${existingComments.length}`);
-        logger.debug(`🎯 Similarity threshold: ${similarityThreshold}%`);
-        if (newViolations.length === 0 || existingComments.length === 0) {
-            logger.debug("⏭️ No violations or comments to compare, skipping deduplication");
-            return {
-                uniqueViolations: newViolations,
-                duplicatesRemoved: 0,
-                semanticMatches: [],
-            };
-        }
-        try {
-            // Use ContentSimilarityService for semantic analysis
-            const { ContentSimilarityService } = await import("./ContentSimilarityService.js");
-            const similarityService = new ContentSimilarityService(aiConfig);
-            // Get similarity results
-            const similarityResults = await similarityService.batchCalculateSimilarity(newViolations, existingComments, 15);
-            // Filter violations based on similarity threshold
-            const duplicateViolationIndices = new Set();
-            const semanticMatches = [];
-            for (const result of similarityResults) {
-                if (result.similarityScore >= similarityThreshold) {
-                    duplicateViolationIndices.add(result.violationIndex);
-                    const violation = newViolations[result.violationIndex];
-                    const comment = existingComments[result.commentIndex];
-                    semanticMatches.push({
-                        violation: violation.issue,
-                        comment: `Comment ${comment.id}`,
-                        similarityScore: result.similarityScore,
-                        reasoning: result.reasoning,
-                    });
-                    logger.debug(`🎯 Semantic duplicate found: "${violation.issue}" matches comment ${comment.id} ` +
-                        `(${result.similarityScore}% similarity)`);
-                }
-            }
-            // Create final list of unique violations
-            const uniqueViolations = newViolations.filter((_, index) => !duplicateViolationIndices.has(index));
-            const processingTime = Date.now() - startTime;
-            const duplicatesRemoved = duplicateViolationIndices.size;
-            logger.success(`✅ Semantic deduplication completed: ${newViolations.length} → ${uniqueViolations.length} violations ` +
-                `(${duplicatesRemoved} duplicates removed) in ${processingTime}ms`);
-            return {
-                uniqueViolations,
-                duplicatesRemoved,
-                semanticMatches,
-            };
-        }
-        catch (error) {
-            logger.error(`❌ Semantic deduplication failed: ${error.message}`);
-            logger.warn("⚠️ Falling back to no deduplication - returning all violations");
-            // Graceful fallback: return all violations if AI analysis fails
-            return {
-                uniqueViolations: newViolations,
-                duplicatesRemoved: 0,
-                semanticMatches: [],
-            };
-        }
-    }
-    /**
-     * Get detailed deduplication statistics
-     */
-    getDeduplicationStats(result) {
-        const metrics = result.processingMetrics;
-        const contributions = Array.from(result.instanceContributions.entries())
-            .map(([instance, count]) => `${instance}: ${count}`)
-            .join(", ");
-        return `
-📊 Deduplication Statistics:
-• Input violations: ${metrics.totalViolationsInput}
-• Exact duplicates removed: ${metrics.exactDuplicatesRemoved}
-• Normalized duplicates removed: ${metrics.normalizedDuplicatesRemoved}
-• Same-line duplicates removed: ${metrics.sameLineDuplicatesRemoved}
-• Final unique violations: ${metrics.finalUniqueViolations}
-• Deduplication rate: ${metrics.deduplicationRate.toFixed(1)}%
-• Processing time: ${metrics.processingTimeMs}ms
-• Instance contributions: ${contributions}
-    `.trim();
-    }
-    /**
-     * Get detailed comment deduplication statistics
-     */
-    getCommentDeduplicationStats(result) {
-        const averageSimilarity = result.semanticMatches.length > 0
-            ? result.semanticMatches.reduce((sum, match) => sum + match.similarityScore, 0) / result.semanticMatches.length
-            : 0;
-        return `
-📊 Comment Deduplication Statistics:
-• Input violations: ${result.uniqueViolations.length + result.duplicatesRemoved}
-• Unique violations: ${result.uniqueViolations.length}
-• Duplicates removed: ${result.duplicatesRemoved}
-• Deduplication rate: ${((result.duplicatesRemoved / (result.uniqueViolations.length + result.duplicatesRemoved)) * 100).toFixed(1)}%
-• Semantic matches: ${result.semanticMatches.length}
-• Average similarity score: ${averageSimilarity.toFixed(1)}%
-    `.trim();
-    }
-}
-/**
- * Factory function to create ExactDuplicateRemover
- */
-export function createExactDuplicateRemover() {
-    return new ExactDuplicateRemover();
-}
-//# sourceMappingURL=ExactDuplicateRemover.js.map

package/dist/utils/Logger.d.ts

@@ -1,31 +0,0 @@
-/**
- * Enhanced Logger utility - Optimized from both pr-police.js and pr-describe.js
- * Provides consistent logging across all Guardian operations
- */
-import { Logger as ILogger, LogLevel, LoggerOptions } from "../types/index.js";
-export declare class Logger implements ILogger {
-    private options;
-    private showBanner;
-    constructor(options?: Partial<LoggerOptions>, showBanner?: boolean);
-    private shouldLog;
-    private formatMessage;
-    private colorize;
-    debug(message: string, ...args: any[]): void;
-    info(message: string, ...args: any[]): void;
-    warn(message: string, ...args: any[]): void;
-    error(message: string, ...args: any[]): void;
-    badge(): void;
-    phase(message: string): void;
-    success(message: string): void;
-    operation(operation: string, status: "started" | "completed" | "failed"): void;
-    violation(severity: string, message: string, file?: string): void;
-    progress(current: number, total: number, operation: string): void;
-    private createProgressBar;
-    child(context: Record<string, any>): Logger;
-    setLevel(level: LogLevel): void;
-    setVerbose(verbose: boolean): void;
-    getConfig(): LoggerOptions;
-}
-export declare const logger: Logger;
-export declare function createLogger(options?: Partial<LoggerOptions>, showBanner?: boolean): Logger;
-//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/Logger.js

@@ -1,214 +0,0 @@
-/**
- * Enhanced Logger utility - Optimized from both pr-police.js and pr-describe.js
- * Provides consistent logging across all Guardian operations
- */
-import chalk from "chalk";
-const YAMA_BADGE = `
-⚔️ ═══════════════════════════════════════════════════════════ ⚔️
-   ██╗   ██╗ █████╗ ███╗   ███╗ █████╗ 
-   ╚██╗ ██╔╝██╔══██╗████╗ ████║██╔══██╗
-    ╚████╔╝ ███████║██╔████╔██║███████║
-     ╚██╔╝  ██╔══██║██║╚██╔╝██║██╔══██║
-      ██║   ██║  ██║██║ ╚═╝ ██║██║  ██║
-      ╚═╝   ╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝
-⚔️ ═══════════════════════════════════════════════════════════ ⚔️
-        AI-Powered PR Automation • Enterprise Security • Code Quality Yama
-`;
-export class Logger {
-    options;
-    showBanner;
-    constructor(options = {}, showBanner = true) {
-        this.options = {
-            level: "info",
-            verbose: false,
-            format: "simple",
-            colors: true,
-            ...options,
-        };
-        this.showBanner = showBanner;
-    }
-    shouldLog(level) {
-        const levels = {
-            debug: 0,
-            info: 1,
-            warn: 2,
-            error: 3,
-        };
-        return levels[level] >= levels[this.options.level];
-    }
-    formatMessage(level, message, ...args) {
-        const timestamp = new Date().toISOString();
-        const formattedArgs = args.length > 0
-            ? ` ${args
-                .map((a) => typeof a === "object" ? JSON.stringify(a, null, 2) : String(a))
-                .join(" ")}`
-            : "";
-        switch (this.options.format) {
-            case "json":
-                return JSON.stringify({
-                    timestamp,
-                    level: level.toUpperCase(),
-                    message: message + formattedArgs,
-                    args: args.length > 0 ? args : undefined,
-                });
-            case "detailed":
-                return `[${timestamp}] [${level.toUpperCase().padEnd(5)}] ${message}${formattedArgs}`;
-            default: // simple
-                return `${message}${formattedArgs}`;
-        }
-    }
-    colorize(level, text) {
-        if (!this.options.colors) {
-            return text;
-        }
-        switch (level) {
-            case "debug":
-                return chalk.gray(text);
-            case "info":
-                return chalk.blue(text);
-            case "warn":
-                return chalk.yellow(text);
-            case "error":
-                return chalk.red(text);
-            default:
-                return text;
-        }
-    }
-    debug(message, ...args) {
-        if (!this.shouldLog("debug") || !this.options.verbose) {
-            return;
-        }
-        const formatted = this.formatMessage("debug", `🔍 ${message}`, ...args);
-        console.log(this.colorize("debug", formatted));
-    }
-    info(message, ...args) {
-        if (!this.shouldLog("info")) {
-            return;
-        }
-        const formatted = this.formatMessage("info", `ℹ️  ${message}`, ...args);
-        console.log(this.colorize("info", formatted));
-    }
-    warn(message, ...args) {
-        if (!this.shouldLog("warn")) {
-            return;
-        }
-        const formatted = this.formatMessage("warn", `⚠️  ${message}`, ...args);
-        console.warn(this.colorize("warn", formatted));
-    }
-    error(message, ...args) {
-        if (!this.shouldLog("error")) {
-            return;
-        }
-        const formatted = this.formatMessage("error", `❌ ${message}`, ...args);
-        console.error(this.colorize("error", formatted));
-    }
-    badge() {
-        if (this.showBanner) {
-            console.log(chalk.cyan(YAMA_BADGE));
-        }
-    }
-    phase(message) {
-        const formatted = `\n🔄 ${message}`;
-        console.log(this.options.colors ? chalk.magenta(formatted) : formatted);
-    }
-    success(message) {
-        const formatted = `✅ ${message}`;
-        console.log(this.options.colors ? chalk.green(formatted) : formatted);
-    }
-    operation(operation, status) {
-        const emoji = status === "started" ? "🚀" : status === "completed" ? "✅" : "❌";
-        const color = status === "started" ? "blue" : status === "completed" ? "green" : "red";
-        const message = `${emoji} ${operation.toUpperCase()}: ${status}`;
-        if (this.options.colors) {
-            console.log(chalk[color](message));
-        }
-        else {
-            console.log(message);
-        }
-    }
-    violation(severity, message, file) {
-        const emoji = {
-            CRITICAL: "🚨",
-            MAJOR: "⚠️",
-            MINOR: "📝",
-            SUGGESTION: "💡",
-        }[severity] || "📋";
-        const color = {
-            CRITICAL: "red",
-            MAJOR: "yellow",
-            MINOR: "blue",
-            SUGGESTION: "cyan",
-        }[severity] || "white";
-        const location = file ? ` in ${file}` : "";
-        const formatted = `${emoji} ${severity}: ${message}${location}`;
-        if (this.options.colors) {
-            console.log(chalk[color](formatted));
-        }
-        else {
-            console.log(formatted);
-        }
-    }
-    progress(current, total, operation) {
-        const percentage = Math.round((current / total) * 100);
-        const progressBar = this.createProgressBar(percentage);
-        const message = `🔄 ${operation}: ${progressBar} ${current}/${total} (${percentage}%)`;
-        // Use carriage return to overwrite the line
-        process.stdout.write(`\r${message}`);
-        // Add newline when complete
-        if (current === total) {
-            process.stdout.write("\n");
-        }
-    }
-    createProgressBar(percentage) {
-        const width = 20;
-        const filled = Math.round((percentage / 100) * width);
-        const empty = width - filled;
-        if (this.options.colors) {
-            return chalk.green("█".repeat(filled)) + chalk.gray("░".repeat(empty));
-        }
-        else {
-            return "█".repeat(filled) + "░".repeat(empty);
-        }
-    }
-    // Method to create child logger with context
-    child(context) {
-        const childLogger = new Logger(this.options);
-        // Override methods to include context
-        const originalMethods = ["debug", "info", "warn", "error"];
-        originalMethods.forEach((method) => {
-            const original = childLogger[method].bind(childLogger);
-            childLogger[method] = (message, ...args) => {
-                const contextStr = Object.entries(context)
-                    .map(([k, v]) => `${k}=${v}`)
-                    .join(" ");
-                original(`[${contextStr}] ${message}`, ...args);
-            };
-        });
-        return childLogger;
-    }
-    // Method to update log level dynamically
-    setLevel(level) {
-        this.options.level = level;
-    }
-    // Method to toggle verbose mode
-    setVerbose(verbose) {
-        this.options.verbose = verbose;
-    }
-    // Method to get current configuration
-    getConfig() {
-        return { ...this.options };
-    }
-}
-// Export singleton instance for convenience with environment-aware defaults
-const loggerOptions = {};
-// Check environment variables for debug mode
-if (process.env.YAMA_DEBUG === "true") {
-    loggerOptions.level = "debug";
-    loggerOptions.verbose = true;
-}
-export const logger = new Logger(loggerOptions);
-// Export factory function
-export function createLogger(options, showBanner) {
-    return new Logger(options, showBanner);
-}
-//# sourceMappingURL=Logger.js.map

package/dist/utils/MemoryBankManager.d.ts

@@ -1,73 +0,0 @@
-/**
- * Memory Bank Manager - Handles configurable memory bank operations
- * Provides abstraction for memory bank file access with fallback support
- */
-import { MemoryBankConfig, PRIdentifier } from "../types/index.js";
-import { BitbucketProvider } from "../core/providers/BitbucketProvider.js";
-export interface MemoryBankFile {
-    name: string;
-    content: string;
-    path: string;
-}
-export interface MemoryBankResult {
-    files: MemoryBankFile[];
-    resolvedPath: string;
-    filesProcessed: number;
-    fallbackUsed: boolean;
-}
-export declare class MemoryBankManager {
-    private config;
-    private bitbucketProvider;
-    constructor(config: MemoryBankConfig, bitbucketProvider: BitbucketProvider);
-    /**
-     * Get memory bank files from the configured path with fallback support
-     */
-    getMemoryBankFiles(identifier: PRIdentifier, forceRefresh?: boolean): Promise<MemoryBankResult>;
-    /**
-     * Try to get files from a specific path
-     */
-    private tryGetFilesFromPath;
-    /**
-     * Get the effective memory bank path (resolved after fallback logic)
-     */
-    getEffectiveMemoryBankPath(identifier: PRIdentifier): Promise<string | null>;
-    /**
-     * Check if memory bank exists at any configured path
-     */
-    hasMemoryBank(identifier: PRIdentifier): Promise<boolean>;
-    /**
-     * Get memory bank configuration
-     */
-    getConfig(): MemoryBankConfig;
-    /**
-     * Update memory bank configuration
-     */
-    updateConfig(newConfig: Partial<MemoryBankConfig>): void;
-    /**
-     * Validates that a path is safe for use as a relative path
-     * Protects against path traversal attacks including encoded variants
-     */
-    private static isSafeRelativePath;
-    /**
-     * Validate memory bank configuration
-     */
-    private validateConfig;
-    /**
-     * Clear memory bank cache for a specific repository
-     */
-    clearCache(identifier: PRIdentifier): void;
-    /**
-     * Get memory bank statistics
-     */
-    getStats(identifier: PRIdentifier): Promise<{
-        enabled: boolean;
-        primaryPath: string;
-        fallbackPaths: string[];
-        hasMemoryBank: boolean;
-        resolvedPath: string | null;
-        fileCount: number;
-        cacheHits: number;
-    }>;
-}
-export declare function createMemoryBankManager(config: MemoryBankConfig, bitbucketProvider: BitbucketProvider): MemoryBankManager;
-//# sourceMappingURL=MemoryBankManager.d.ts.map