@juspay/yama 1.1.0 → 1.2.0

package/dist/utils/Logger.d.ts

@@ -2,7 +2,7 @@
  * 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';
+import { Logger as ILogger, LogLevel, LoggerOptions } from "../types/index.js";
 export declare class Logger implements ILogger {
     private options;
     constructor(options?: Partial<LoggerOptions>);
@@ -16,7 +16,7 @@ export declare class Logger implements ILogger {
     badge(): void;
     phase(message: string): void;
     success(message: string): void;
-    operation(operation: string, status: 'started' | 'completed' | 'failed'): 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;

package/dist/utils/Logger.js

@@ -1,15 +1,8 @@
-"use strict";
 /**
  * Enhanced Logger utility - Optimized from both pr-police.js and pr-describe.js
  * Provides consistent logging across all Guardian operations
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.Logger = void 0;
-exports.createLogger = createLogger;
-const chalk_1 = __importDefault(require("chalk"));
+import chalk from "chalk";
 const YAMA_BADGE = `
 ⚔️ ═══════════════════════════════════════════════════════════ ⚔️
    ██╗   ██╗ █████╗ ███╗   ███╗ █████╗ 
@@ -21,14 +14,15 @@ const YAMA_BADGE = `
 ⚔️ ═══════════════════════════════════════════════════════════ ⚔️
         AI-Powered PR Automation • Enterprise Security • Code Quality Yama
 `;
-class Logger {
+export class Logger {
+    options;
     constructor(options = {}) {
         this.options = {
-            level: 'info',
+            level: "info",
             verbose: false,
-            format: 'simple',
+            format: "simple",
             colors: true,
-            ...options
+            ...options,
         };
     }
     shouldLog(level) {
@@ -36,84 +30,93 @@ class Logger {
             debug: 0,
             info: 1,
             warn: 2,
-            error: 3
+            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(' ')}` : '';
+        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':
+            case "json":
                 return JSON.stringify({
                     timestamp,
                     level: level.toUpperCase(),
                     message: message + formattedArgs,
-                    args: args.length > 0 ? args : undefined
+                    args: args.length > 0 ? args : undefined,
                 });
-            case 'detailed':
+            case "detailed":
                 return `[${timestamp}] [${level.toUpperCase().padEnd(5)}] ${message}${formattedArgs}`;
             default: // simple
                 return `${message}${formattedArgs}`;
         }
     }
     colorize(level, text) {
-        if (!this.options.colors)
+        if (!this.options.colors) {
             return text;
+        }
         switch (level) {
-            case 'debug':
-                return chalk_1.default.gray(text);
-            case 'info':
-                return chalk_1.default.blue(text);
-            case 'warn':
-                return chalk_1.default.yellow(text);
-            case 'error':
-                return chalk_1.default.red(text);
+            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)
+        if (!this.shouldLog("debug") || !this.options.verbose) {
             return;
-        const formatted = this.formatMessage('debug', `🔍 ${message}`, ...args);
-        console.log(this.colorize('debug', formatted));
+        }
+        const formatted = this.formatMessage("debug", `🔍 ${message}`, ...args);
+        console.log(this.colorize("debug", formatted));
     }
     info(message, ...args) {
-        if (!this.shouldLog('info'))
+        if (!this.shouldLog("info")) {
             return;
-        const formatted = this.formatMessage('info', `ℹ️  ${message}`, ...args);
-        console.log(this.colorize('info', formatted));
+        }
+        const formatted = this.formatMessage("info", `ℹ️  ${message}`, ...args);
+        console.log(this.colorize("info", formatted));
     }
     warn(message, ...args) {
-        if (!this.shouldLog('warn'))
+        if (!this.shouldLog("warn")) {
             return;
-        const formatted = this.formatMessage('warn', `⚠️  ${message}`, ...args);
-        console.warn(this.colorize('warn', formatted));
+        }
+        const formatted = this.formatMessage("warn", `⚠️  ${message}`, ...args);
+        console.warn(this.colorize("warn", formatted));
     }
     error(message, ...args) {
-        if (!this.shouldLog('error'))
+        if (!this.shouldLog("error")) {
             return;
-        const formatted = this.formatMessage('error', `❌ ${message}`, ...args);
-        console.error(this.colorize('error', formatted));
+        }
+        const formatted = this.formatMessage("error", `❌ ${message}`, ...args);
+        console.error(this.colorize("error", formatted));
     }
     badge() {
-        console.log(chalk_1.default.cyan(YAMA_BADGE));
+        console.log(chalk.cyan(YAMA_BADGE));
     }
     phase(message) {
         const formatted = `\n🔄 ${message}`;
-        console.log(this.options.colors ? chalk_1.default.magenta(formatted) : formatted);
+        console.log(this.options.colors ? chalk.magenta(formatted) : formatted);
     }
     success(message) {
         const formatted = `✅ ${message}`;
-        console.log(this.options.colors ? chalk_1.default.green(formatted) : formatted);
+        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 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_1.default[color](message));
+            console.log(chalk[color](message));
         }
         else {
             console.log(message);
@@ -121,21 +124,21 @@ class Logger {
     }
     violation(severity, message, file) {
         const emoji = {
-            'CRITICAL': '🚨',
-            'MAJOR': '⚠️',
-            'MINOR': '📝',
-            'SUGGESTION': '💡'
-        }[severity] || '📋';
+            CRITICAL: "🚨",
+            MAJOR: "⚠️",
+            MINOR: "📝",
+            SUGGESTION: "💡",
+        }[severity] || "📋";
         const color = {
-            'CRITICAL': 'red',
-            'MAJOR': 'yellow',
-            'MINOR': 'blue',
-            'SUGGESTION': 'cyan'
-        }[severity] || 'white';
-        const location = file ? ` in ${file}` : '';
+            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_1.default[color](formatted));
+            console.log(chalk[color](formatted));
         }
         else {
             console.log(formatted);
@@ -149,7 +152,7 @@ class Logger {
         process.stdout.write(`\r${message}`);
         // Add newline when complete
         if (current === total) {
-            process.stdout.write('\n');
+            process.stdout.write("\n");
         }
     }
     createProgressBar(percentage) {
@@ -157,23 +160,23 @@ class Logger {
         const filled = Math.round((percentage / 100) * width);
         const empty = width - filled;
         if (this.options.colors) {
-            return chalk_1.default.green('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+            return chalk.green("█".repeat(filled)) + chalk.gray("░".repeat(empty));
         }
         else {
-            return '█'.repeat(filled) + '░'.repeat(empty);
+            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 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(' ');
+                    .join(" ");
                 original(`[${contextStr}] ${message}`, ...args);
             };
         });
@@ -192,17 +195,16 @@ class Logger {
         return { ...this.options };
     }
 }
-exports.Logger = Logger;
 // 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';
+if (process.env.YAMA_DEBUG === "true") {
+    loggerOptions.level = "debug";
     loggerOptions.verbose = true;
 }
-exports.logger = new Logger(loggerOptions);
+export const logger = new Logger(loggerOptions);
 // Export factory function
-function createLogger(options) {
+export function createLogger(options) {
     return new Logger(options);
 }
 //# sourceMappingURL=Logger.js.map

package/dist/utils/MemoryBankManager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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

package/dist/utils/MemoryBankManager.js

@@ -0,0 +1,310 @@
+/**
+ * Memory Bank Manager - Handles configurable memory bank operations
+ * Provides abstraction for memory bank file access with fallback support
+ */
+import { ConfigurationError } from "../types/index.js";
+import { logger } from "./Logger.js";
+import { cache, Cache } from "./Cache.js";
+export class MemoryBankManager {
+    config;
+    bitbucketProvider;
+    constructor(config, bitbucketProvider) {
+        this.config = config;
+        this.bitbucketProvider = bitbucketProvider;
+        this.validateConfig();
+    }
+    /**
+     * Get memory bank files from the configured path with fallback support
+     */
+    async getMemoryBankFiles(identifier, forceRefresh = false) {
+        if (!this.config.enabled) {
+            logger.debug("Memory bank is disabled in configuration");
+            return {
+                files: [],
+                resolvedPath: "",
+                filesProcessed: 0,
+                fallbackUsed: false,
+            };
+        }
+        const cacheKey = Cache.keys.memoryBankFiles(identifier.workspace, identifier.repository, identifier.branch || "main", this.config.path);
+        if (!forceRefresh && cache.has(cacheKey)) {
+            logger.debug("Using cached memory bank files");
+            return cache.get(cacheKey);
+        }
+        logger.debug(`Gathering memory bank files from configured paths...`);
+        // Try primary path first
+        const primaryResult = await this.tryGetFilesFromPath(identifier, this.config.path);
+        if (primaryResult.files.length > 0) {
+            const result = {
+                ...primaryResult,
+                resolvedPath: this.config.path,
+                fallbackUsed: false,
+            };
+            // Cache the result
+            cache.set(cacheKey, result, 7200); // 2 hours
+            return result;
+        }
+        // Try fallback paths if primary path failed
+        if (this.config.fallbackPaths && this.config.fallbackPaths.length > 0) {
+            logger.debug(`Primary path '${this.config.path}' not found, trying fallback paths...`);
+            for (const fallbackPath of this.config.fallbackPaths) {
+                logger.debug(`Trying fallback path: ${fallbackPath}`);
+                const fallbackResult = await this.tryGetFilesFromPath(identifier, fallbackPath);
+                if (fallbackResult.files.length > 0) {
+                    logger.info(`Memory bank found at fallback path: ${fallbackPath} (${fallbackResult.files.length} files)`);
+                    const result = {
+                        ...fallbackResult,
+                        resolvedPath: fallbackPath,
+                        fallbackUsed: true,
+                    };
+                    // Cache the result
+                    cache.set(cacheKey, result, 7200); // 2 hours
+                    return result;
+                }
+            }
+        }
+        // No memory bank found anywhere
+        logger.debug(`No memory bank found in primary path '${this.config.path}' or fallback paths`);
+        const emptyResult = {
+            files: [],
+            resolvedPath: "",
+            filesProcessed: 0,
+            fallbackUsed: false,
+        };
+        // Cache empty result for shorter time to allow for quick retry
+        cache.set(cacheKey, emptyResult, 1800); // 30 minutes
+        return emptyResult;
+    }
+    /**
+     * Try to get files from a specific path
+     */
+    async tryGetFilesFromPath(identifier, path) {
+        try {
+            // Get directory listing
+            const directoryFiles = await this.bitbucketProvider.listDirectoryContent(identifier.workspace, identifier.repository, path, identifier.branch || "main");
+            if (!directoryFiles.length) {
+                logger.debug(`No files found in directory: ${path}`);
+                return { files: [], filesProcessed: 0 };
+            }
+            // Filter to only files (not directories)
+            const files = directoryFiles.filter((f) => f.type === "file");
+            logger.debug(`Found ${files.length} files in ${path}`);
+            // Get content of each file
+            const memoryBankFiles = [];
+            for (const file of files) {
+                try {
+                    const content = await this.bitbucketProvider.getFileContent(identifier.workspace, identifier.repository, `${path}/${file.name}`, identifier.branch || "main");
+                    memoryBankFiles.push({
+                        name: file.name,
+                        content,
+                        path: `${path}/${file.name}`,
+                    });
+                    logger.debug(`✓ Loaded content for: ${file.name}`);
+                }
+                catch (error) {
+                    logger.debug(`Could not read file ${file.name}: ${error.message}`);
+                    // Continue with other files even if one fails
+                }
+            }
+            return {
+                files: memoryBankFiles,
+                filesProcessed: memoryBankFiles.length,
+            };
+        }
+        catch (error) {
+            logger.debug(`Failed to access path '${path}': ${error.message}`);
+            return { files: [], filesProcessed: 0 };
+        }
+    }
+    /**
+     * Get the effective memory bank path (resolved after fallback logic)
+     */
+    async getEffectiveMemoryBankPath(identifier) {
+        const result = await this.getMemoryBankFiles(identifier);
+        return result.resolvedPath || null;
+    }
+    /**
+     * Check if memory bank exists at any configured path
+     */
+    async hasMemoryBank(identifier) {
+        const result = await this.getMemoryBankFiles(identifier);
+        return result.files.length > 0;
+    }
+    /**
+     * Get memory bank configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update memory bank configuration
+     */
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        this.validateConfig();
+        logger.debug("Memory bank configuration updated");
+    }
+    /**
+     * Validates that a path is safe for use as a relative path
+     * Protects against path traversal attacks including encoded variants
+     */
+    static isSafeRelativePath(path) {
+        if (!path || typeof path !== "string") {
+            return false;
+        }
+        // Reject empty or whitespace-only paths
+        if (path.trim().length === 0) {
+            return false;
+        }
+        // Reject excessively long paths
+        if (path.length > 1000) {
+            return false;
+        }
+        // Reject absolute paths (Unix-style)
+        if (path.startsWith("/")) {
+            return false;
+        }
+        // Reject absolute paths (Windows-style)
+        if (/^[a-zA-Z]:/.test(path)) {
+            return false;
+        }
+        // Reject UNC paths (Windows network paths)
+        if (path.startsWith("\\\\") || path.startsWith("//")) {
+            return false;
+        }
+        // Decode URL-encoded characters to catch encoded traversal attempts
+        let decodedPath = path;
+        try {
+            // Multiple rounds of decoding to catch double-encoded attacks
+            for (let i = 0; i < 3; i++) {
+                const previousPath = decodedPath;
+                decodedPath = decodeURIComponent(decodedPath);
+                if (decodedPath === previousPath) {
+                    break; // No more decoding needed
+                }
+            }
+        }
+        catch {
+            // If decoding fails, treat as suspicious
+            return false;
+        }
+        // Normalize Unicode characters
+        decodedPath = decodedPath.normalize("NFC");
+        // Check for null bytes (can be used to bypass filters)
+        if (decodedPath.includes("\0") || decodedPath.includes("%00")) {
+            return false;
+        }
+        // Normalize path separators to forward slashes
+        const normalizedPath = decodedPath.replace(/\\/g, "/");
+        // Check for path traversal sequences after normalization
+        if (normalizedPath.includes("../") || normalizedPath.includes("/..")) {
+            return false;
+        }
+        // Check for path traversal at the beginning or end
+        if (normalizedPath.startsWith("..") || normalizedPath.endsWith("..")) {
+            return false;
+        }
+        // Check for hidden traversal patterns
+        if (normalizedPath.includes("./..") || normalizedPath.includes("../.")) {
+            return false;
+        }
+        // Split path into segments and validate each
+        const segments = normalizedPath.split("/").filter(segment => segment.length > 0);
+        for (const segment of segments) {
+            // Reject any segment that is exactly ".."
+            if (segment === "..") {
+                return false;
+            }
+            // Reject segments that contain ".." anywhere
+            if (segment.includes("..")) {
+                return false;
+            }
+            // Allow segments that start with a single dot (like .memory-bank, .config)
+            // but reject multiple dots or suspicious patterns
+            if (segment.startsWith(".") && segment !== ".") {
+                // Allow single dot followed by alphanumeric/dash/underscore
+                if (!/^\.[\w-]+$/.test(segment)) {
+                    return false;
+                }
+            }
+            // Reject segments with control characters
+            // Check for control characters (0x00-0x1F and 0x7F)
+            for (let i = 0; i < segment.length; i++) {
+                const charCode = segment.charCodeAt(i);
+                if ((charCode >= 0 && charCode <= 31) || charCode === 127) {
+                    return false;
+                }
+            }
+        }
+        // Additional check: ensure the resolved path doesn't escape the base
+        // This is a final safety check using path resolution logic
+        const pathParts = segments.filter(part => part !== ".");
+        let depth = 0;
+        for (const part of pathParts) {
+            if (part === "..") {
+                depth--;
+                if (depth < 0) {
+                    return false; // Would escape the base directory
+                }
+            }
+            else {
+                depth++;
+            }
+        }
+        return true;
+    }
+    /**
+     * Validate memory bank configuration
+     */
+    validateConfig() {
+        if (!this.config.path) {
+            throw new ConfigurationError("Memory bank path must be specified when memory bank is enabled");
+        }
+        if (!MemoryBankManager.isSafeRelativePath(this.config.path)) {
+            throw new ConfigurationError(`Memory bank path is unsafe or contains path traversal: ${this.config.path}`);
+        }
+        // Validate fallback paths
+        if (this.config.fallbackPaths) {
+            for (const fallbackPath of this.config.fallbackPaths) {
+                if (!MemoryBankManager.isSafeRelativePath(fallbackPath)) {
+                    throw new ConfigurationError(`Memory bank fallback path is unsafe or contains path traversal: ${fallbackPath}`);
+                }
+            }
+        }
+        logger.debug("Memory bank configuration validated successfully");
+    }
+    /**
+     * Clear memory bank cache for a specific repository
+     */
+    clearCache(identifier) {
+        const patterns = [
+            `memory-bank:${identifier.workspace}:${identifier.repository}:*`,
+            `project-context:${identifier.workspace}:${identifier.repository}:*`,
+        ];
+        patterns.forEach((pattern) => {
+            cache.invalidatePattern(pattern);
+        });
+        logger.debug(`Memory bank cache cleared for ${identifier.workspace}/${identifier.repository}`);
+    }
+    /**
+     * Get memory bank statistics
+     */
+    async getStats(identifier) {
+        const result = await this.getMemoryBankFiles(identifier);
+        const cacheStats = cache.stats();
+        return {
+            enabled: this.config.enabled,
+            primaryPath: this.config.path,
+            fallbackPaths: this.config.fallbackPaths || [],
+            hasMemoryBank: result.files.length > 0,
+            resolvedPath: result.resolvedPath || null,
+            fileCount: result.files.length,
+            cacheHits: cacheStats.hits,
+        };
+    }
+}
+// Export factory function
+export function createMemoryBankManager(config, bitbucketProvider) {
+    return new MemoryBankManager(config, bitbucketProvider);
+}
+//# sourceMappingURL=MemoryBankManager.js.map