@juspay/yama 1.0.0

package/dist/cli/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Yama CLI - Enhanced command line interface
+ * Provides backward compatibility with pr-police.js and pr-describe.js
+ * Plus new unified commands for the enhanced functionality
+ */
+/**
+ * Main execution
+ */
+declare function main(): void;
+export { main };
+//# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -0,0 +1,541 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Yama CLI - Enhanced command line interface
+ * Provides backward compatibility with pr-police.js and pr-describe.js
+ * Plus new unified commands for the enhanced functionality
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const Guardian_1 = require("../core/Guardian");
+const Logger_1 = require("../utils/Logger");
+const ConfigManager_1 = require("../utils/ConfigManager");
+const Cache_1 = require("../utils/Cache");
+// Load environment variables
+dotenv_1.default.config();
+const program = new commander_1.Command();
+// Package info
+const packageInfo = {
+    name: "@juspay/yama",
+    version: "1.1.0",
+    description: "Enterprise-grade Pull Request automation toolkit",
+};
+/**
+ * Main CLI setup
+ */
+function setupCLI() {
+    program
+        .name("yama")
+        .description(packageInfo.description)
+        .version(packageInfo.version);
+    // Global options
+    program
+        .option("-v, --verbose", "Enable verbose logging")
+        .option("-c, --config <path>", "Path to configuration file")
+        .option("--dry-run", "Preview mode - no changes made")
+        .option("--no-cache", "Disable caching");
+    // Configure help options (removed custom formatter to fix recursion)
+    program.configureHelp({
+        sortSubcommands: true,
+    });
+    // Setup commands
+    setupProcessCommand();
+    setupReviewCommand();
+    setupEnhanceCommand();
+    setupInitCommand();
+    setupStatusCommand();
+    setupCacheCommand();
+    setupConfigCommand();
+    // Backward compatibility aliases
+    setupBackwardCompatibility();
+}
+/**
+ * Main unified processing command
+ */
+function setupProcessCommand() {
+    program
+        .command("process")
+        .description("Process PR with multiple operations using unified context (NEW)")
+        .requiredOption("-w, --workspace <workspace>", "Bitbucket workspace")
+        .requiredOption("-r, --repository <repository>", "Repository name")
+        .option("-b, --branch <branch>", "Branch name")
+        .option("-p, --pr <id>", "Pull request ID")
+        .option("-o, --operations <operations>", "Operations to perform (review,enhance-description,all)", "all")
+        .option("--exclude <patterns>", "Comma-separated exclude patterns", "*.lock,*.svg")
+        .option("--context-lines <number>", "Context lines for diff", "3")
+        .action(async (options) => {
+        try {
+            await handleGlobalOptions(options);
+            const operations = parseOperations(options.operations);
+            const operationOptions = {
+                workspace: options.workspace,
+                repository: options.repository,
+                branch: options.branch,
+                pullRequestId: options.pr,
+                operations,
+                dryRun: options.dryRun,
+                verbose: options.verbose,
+            };
+            const guardian = new Guardian_1.Guardian();
+            await guardian.initialize(options.config);
+            if (options.verbose) {
+                // Use streaming for verbose mode
+                console.log(chalk_1.default.blue("\n📡 Starting streaming processing...\n"));
+                for await (const update of guardian.processPRStream(operationOptions)) {
+                    logStreamUpdate(update);
+                }
+            }
+            else {
+                // Use regular processing
+                const spinner = (0, ora_1.default)("Processing PR...").start();
+                try {
+                    const result = await guardian.processPR(operationOptions);
+                    spinner.succeed("Processing completed");
+                    printProcessResult(result);
+                }
+                catch (error) {
+                    spinner.fail("Processing failed");
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Code review command (backward compatible with pr-police.js)
+ */
+function setupReviewCommand() {
+    program
+        .command("review")
+        .alias("police") // Backward compatibility
+        .description("AI-powered code review (equivalent to pr-police.js)")
+        .requiredOption("-w, --workspace <workspace>", "Bitbucket workspace")
+        .requiredOption("-r, --repository <repository>", "Repository name")
+        .option("-b, --branch <branch>", "Branch name")
+        .option("-p, --pr <id>", "Pull request ID")
+        .option("--exclude <patterns>", "Comma-separated exclude patterns", "*.lock,*.svg")
+        .option("--context-lines <number>", "Context lines for diff", "3")
+        .action(async (options) => {
+        try {
+            await handleGlobalOptions(options);
+            const reviewOptions = {
+                workspace: options.workspace,
+                repository: options.repository,
+                branch: options.branch,
+                pullRequestId: options.pr,
+                dryRun: options.dryRun,
+                verbose: options.verbose,
+                excludePatterns: options.exclude
+                    ?.split(",")
+                    .map((p) => p.trim()),
+                contextLines: parseInt(options.contextLines),
+            };
+            const guardian = new Guardian_1.Guardian();
+            await guardian.initialize(options.config);
+            const spinner = (0, ora_1.default)("Conducting code review...").start();
+            try {
+                const result = await guardian.reviewCode(reviewOptions);
+                spinner.succeed("Code review completed");
+                printReviewResult(result);
+            }
+            catch (error) {
+                spinner.fail("Code review failed");
+                throw error;
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Description enhancement command (backward compatible with pr-describe.js)
+ */
+function setupEnhanceCommand() {
+    program
+        .command("enhance")
+        .alias("scribe") // Backward compatibility
+        .description("AI-powered description enhancement (equivalent to pr-describe.js)")
+        .requiredOption("-w, --workspace <workspace>", "Bitbucket workspace")
+        .requiredOption("-r, --repository <repository>", "Repository name")
+        .option("-b, --branch <branch>", "Branch name")
+        .option("-p, --pr <id>", "Pull request ID")
+        .option("--no-preserve", "Disable content preservation")
+        .action(async (options) => {
+        try {
+            await handleGlobalOptions(options);
+            const enhancementOptions = {
+                workspace: options.workspace,
+                repository: options.repository,
+                branch: options.branch,
+                pullRequestId: options.pr,
+                dryRun: options.dryRun,
+                verbose: options.verbose,
+                preserveContent: options.preserve !== false,
+                ensureRequiredSections: true,
+            };
+            const guardian = new Guardian_1.Guardian();
+            await guardian.initialize(options.config);
+            const spinner = (0, ora_1.default)("Enhancing PR description...").start();
+            try {
+                const result = await guardian.enhanceDescription(enhancementOptions);
+                spinner.succeed("Description enhancement completed");
+                printEnhancementResult(result);
+            }
+            catch (error) {
+                spinner.fail("Description enhancement failed");
+                throw error;
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Initialize configuration command
+ */
+function setupInitCommand() {
+    program
+        .command("init")
+        .description("Initialize Yama configuration")
+        .option("-o, --output <path>", "Output configuration file path")
+        .option("-i, --interactive", "Interactive configuration setup")
+        .action(async (options) => {
+        try {
+            if (options.interactive) {
+                await interactiveInit();
+            }
+            else {
+                const configPath = await ConfigManager_1.configManager.createDefaultConfig(options.output);
+                console.log(chalk_1.default.green(`✅ Configuration file created: ${configPath}`));
+                console.log(chalk_1.default.yellow("💡 Edit the configuration file to customize settings"));
+                console.log(chalk_1.default.blue("📖 Visit https://github.com/juspay/yama for documentation"));
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Status and health check command
+ */
+function setupStatusCommand() {
+    program
+        .command("status")
+        .description("Check Yama status and health")
+        .option("-d, --detailed", "Show detailed status information")
+        .action(async (options) => {
+        try {
+            await handleGlobalOptions(options);
+            const guardian = new Guardian_1.Guardian();
+            await guardian.initialize(options.config);
+            const health = await guardian.healthCheck();
+            const stats = guardian.getStats();
+            console.log(chalk_1.default.cyan("\n🛡️ Yama Status\n"));
+            // Health status
+            const healthEmoji = health.healthy ? "✅" : "❌";
+            console.log(`${healthEmoji} Overall Health: ${health.healthy ? "Healthy" : "Issues Detected"}`);
+            // Component status
+            console.log("\n📊 Component Status:");
+            Object.entries(health.components).forEach(([component, status]) => {
+                const emoji = status.healthy ? "✅" : "❌";
+                console.log(`  ${emoji} ${component}: ${status.healthy ? "OK" : "Error"}`);
+            });
+            // Statistics
+            if (options.detailed) {
+                console.log("\n📈 Statistics:");
+                console.log(JSON.stringify(stats, null, 2));
+            }
+            // Cache status
+            const cacheStats = Cache_1.cache.stats();
+            console.log(`\n💾 Cache: ${cacheStats.keys} keys, ${cacheStats.hits} hits, ${Math.round(Cache_1.cache.getHitRatio() * 100)}% hit ratio`);
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Cache management command
+ */
+function setupCacheCommand() {
+    const cacheCommand = program
+        .command("cache")
+        .description("Cache management operations");
+    cacheCommand
+        .command("clear")
+        .description("Clear all caches")
+        .action(() => {
+        Cache_1.cache.clear();
+        console.log(chalk_1.default.green("✅ All caches cleared"));
+    });
+    cacheCommand
+        .command("stats")
+        .description("Show cache statistics")
+        .action(() => {
+        const stats = Cache_1.cache.stats();
+        const detailed = Cache_1.cache.debug();
+        console.log(chalk_1.default.cyan("\n💾 Cache Statistics\n"));
+        console.log(`Keys: ${stats.keys}`);
+        console.log(`Hits: ${stats.hits}`);
+        console.log(`Misses: ${stats.misses}`);
+        console.log(`Hit Ratio: ${Math.round(Cache_1.cache.getHitRatio() * 100)}%`);
+        console.log("\n📊 Detailed Stats:");
+        console.log(JSON.stringify(detailed, null, 2));
+    });
+}
+/**
+ * Configuration management command
+ */
+function setupConfigCommand() {
+    const configCommand = program
+        .command("config")
+        .description("Configuration management");
+    configCommand
+        .command("validate")
+        .description("Validate configuration file")
+        .option("-c, --config <path>", "Configuration file path")
+        .action(async (options) => {
+        try {
+            await ConfigManager_1.configManager.loadConfig(options.config);
+            console.log(chalk_1.default.green("✅ Configuration is valid"));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Configuration error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+    configCommand
+        .command("show")
+        .description("Show current configuration")
+        .option("-c, --config <path>", "Configuration file path")
+        .action(async (options) => {
+        try {
+            const config = await ConfigManager_1.configManager.loadConfig(options.config);
+            console.log(chalk_1.default.cyan("\n⚙️ Current Configuration\n"));
+            // Mask sensitive information
+            const sanitizedConfig = { ...config };
+            if (sanitizedConfig.providers?.git?.credentials?.token) {
+                sanitizedConfig.providers.git.credentials.token = "***MASKED***";
+            }
+            console.log(JSON.stringify(sanitizedConfig, null, 2));
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`❌ Error: ${error.message}`));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Backward compatibility with original scripts
+ */
+function setupBackwardCompatibility() {
+    // pr-police.js compatibility
+    if (process.argv[1]?.includes("pr-police")) {
+        // Redirect to review command
+        const args = process.argv.slice(2);
+        process.argv = ["node", "yama", "review", ...args];
+    }
+    // pr-describe.js / pr-scribe.js compatibility
+    if (process.argv[1]?.includes("pr-scribe") ||
+        process.argv[1]?.includes("pr-describe")) {
+        // Redirect to enhance command
+        const args = process.argv.slice(2);
+        process.argv = ["node", "yama", "enhance", ...args];
+    }
+}
+/**
+ * Utility functions
+ */
+async function handleGlobalOptions(options) {
+    // Set up logging
+    if (options.verbose) {
+        Logger_1.logger.setVerbose(true);
+        Logger_1.logger.setLevel("debug");
+    }
+    // Handle cache disabling
+    if (options.cache === false) {
+        Cache_1.cache.clear();
+    }
+}
+function parseOperations(operationsStr) {
+    const operationMap = {
+        review: "review",
+        enhance: "enhance-description",
+        "enhance-description": "enhance-description",
+        security: "security-scan",
+        "security-scan": "security-scan",
+        analytics: "analytics",
+        all: "all",
+    };
+    return operationsStr
+        .split(",")
+        .map((op) => op.trim())
+        .map((op) => operationMap[op] || op)
+        .filter((op) => op);
+}
+function logStreamUpdate(update) {
+    const timestamp = new Date(update.timestamp).toLocaleTimeString();
+    const progressStr = update.progress ? ` (${update.progress}%)` : "";
+    switch (update.status) {
+        case "started":
+            console.log(chalk_1.default.blue(`🚀 [${timestamp}] ${update.operation}: ${update.message}`));
+            break;
+        case "progress":
+            console.log(chalk_1.default.yellow(`🔄 [${timestamp}] ${update.operation}: ${update.message}${progressStr}`));
+            break;
+        case "completed":
+            console.log(chalk_1.default.green(`✅ [${timestamp}] ${update.operation}: ${update.message}${progressStr}`));
+            break;
+        case "error":
+            console.log(chalk_1.default.red(`❌ [${timestamp}] ${update.operation}: ${update.message}`));
+            break;
+    }
+}
+function printProcessResult(result) {
+    console.log(chalk_1.default.cyan("\n🛡️ Yama Process Result\n"));
+    console.log(`PR: #${result.pullRequest.id} - ${result.pullRequest.title}`);
+    console.log(`Author: ${result.pullRequest.author}`);
+    console.log(`Operations: ${result.operations.length}`);
+    console.log("\n📊 Summary:");
+    console.log(`✅ Success: ${result.summary.successCount}`);
+    console.log(`❌ Errors: ${result.summary.errorCount}`);
+    console.log(`⏭️ Skipped: ${result.summary.skippedCount}`);
+    console.log(`⏱️ Total Duration: ${Math.round(result.summary.totalDuration / 1000)}s`);
+    // Show individual operation results
+    console.log("\n📋 Operations:");
+    result.operations.forEach((op) => {
+        const emoji = op.status === "success" ? "✅" : op.status === "error" ? "❌" : "⏭️";
+        console.log(`  ${emoji} ${op.operation}: ${op.status} (${Math.round(op.duration / 1000)}s)`);
+        if (op.error) {
+            console.log(chalk_1.default.red(`    Error: ${op.error}`));
+        }
+    });
+}
+function printReviewResult(result) {
+    const stats = result.statistics;
+    console.log(chalk_1.default.cyan("\n🛡️ Code Review Results\n"));
+    console.log(`📊 Total Issues: ${stats.totalIssues}`);
+    console.log(`🚨 Critical: ${stats.criticalCount}`);
+    console.log(`⚠️ Major: ${stats.majorCount}`);
+    console.log(`📝 Minor: ${stats.minorCount}`);
+    console.log(`💡 Suggestions: ${stats.suggestionCount}`);
+    console.log(`📁 Files Reviewed: ${stats.filesReviewed}`);
+    if (stats.criticalCount > 0) {
+        console.log(chalk_1.default.red("\n⛔ CRITICAL issues found - must fix before merge!"));
+    }
+    else if (stats.majorCount > 0) {
+        console.log(chalk_1.default.yellow("\n⚠️ Major issues found - should fix before merge"));
+    }
+    else if (stats.minorCount > 0) {
+        console.log(chalk_1.default.blue("\n📝 Minor improvements suggested"));
+    }
+    else {
+        console.log(chalk_1.default.green("\n✅ Code quality approved!"));
+    }
+}
+function printEnhancementResult(result) {
+    console.log(chalk_1.default.cyan("\n📝 Description Enhancement Results\n"));
+    console.log(`📏 Original Length: ${result.statistics.originalLength} characters`);
+    console.log(`📏 Enhanced Length: ${result.statistics.enhancedLength} characters`);
+    console.log(`📋 Sections Completed: ${result.statistics.completedSections}/${result.statistics.totalSections}`);
+    if (result.sectionsAdded.length > 0) {
+        console.log(`➕ Sections Added: ${result.sectionsAdded.join(", ")}`);
+    }
+    if (result.sectionsEnhanced.length > 0) {
+        console.log(`✨ Sections Enhanced: ${result.sectionsEnhanced.join(", ")}`);
+    }
+    console.log(`📎 Content Preserved: ${result.preservedItems.media} media, ${result.preservedItems.files} files, ${result.preservedItems.links} links`);
+    if (result.statistics.completedSections === result.statistics.totalSections) {
+        console.log(chalk_1.default.green("\n✅ All required sections completed!"));
+    }
+    else {
+        console.log(chalk_1.default.yellow("\n⚠️ Some required sections may still need attention"));
+    }
+}
+async function interactiveInit() {
+    console.log(chalk_1.default.cyan("\n🛡️ Yama Interactive Setup\n"));
+    await inquirer_1.default.prompt([
+        {
+            type: "input",
+            name: "workspace",
+            message: "Default Bitbucket workspace:",
+            default: "YOUR_WORKSPACE",
+        },
+        {
+            type: "input",
+            name: "baseUrl",
+            message: "Bitbucket server URL:",
+            default: "https://your-bitbucket-server.com",
+        },
+        {
+            type: "list",
+            name: "aiProvider",
+            message: "AI provider:",
+            choices: ["auto", "google-ai", "openai", "anthropic"],
+            default: "auto",
+        },
+        {
+            type: "confirm",
+            name: "enableAnalytics",
+            message: "Enable AI analytics:",
+            default: true,
+        },
+        {
+            type: "confirm",
+            name: "enableCache",
+            message: "Enable caching:",
+            default: true,
+        },
+    ]);
+    const configPath = await ConfigManager_1.configManager.createDefaultConfig();
+    console.log(chalk_1.default.green(`\n✅ Configuration created: ${configPath}`));
+    console.log(chalk_1.default.yellow("💡 Don't forget to set your environment variables:"));
+    console.log(chalk_1.default.blue("   BITBUCKET_USERNAME=your-username"));
+    console.log(chalk_1.default.blue("   BITBUCKET_TOKEN=your-token"));
+    console.log(chalk_1.default.blue("   GOOGLE_AI_API_KEY=your-api-key"));
+}
+/**
+ * Main execution
+ */
+function main() {
+    setupCLI();
+    // Parse command line arguments
+    program.parse();
+    // Show help if no command provided
+    if (!process.argv.slice(2).length) {
+        program.outputHelp();
+    }
+}
+// Handle uncaught errors
+process.on("uncaughtException", (error) => {
+    console.error(chalk_1.default.red(`\n💥 Uncaught Exception: ${error.message}`));
+    process.exit(1);
+});
+process.on("unhandledRejection", (reason) => {
+    console.error(chalk_1.default.red(`\n💥 Unhandled Rejection: ${reason}`));
+    process.exit(1);
+});
+// Run if this is the main module
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=index.js.map

package/dist/core/ContextGatherer.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Unified Context Gatherer - The foundation for all Yama operations
+ * Gathers all necessary context once and reuses it across all operations
+ */
+import { PRIdentifier, PRInfo, PRDiff, AIProviderConfig, DiffStrategyConfig } from "../types";
+import { BitbucketProvider } from "./providers/BitbucketProvider";
+export interface ProjectContext {
+    memoryBank: {
+        summary: string;
+        projectContext: string;
+        patterns: string;
+        standards: string;
+    };
+    clinerules: string;
+    filesProcessed: number;
+}
+export interface DiffStrategy {
+    strategy: "whole" | "file-by-file";
+    reason: string;
+    fileCount: number;
+    estimatedSize: string;
+}
+export interface UnifiedContext {
+    pr: PRInfo;
+    identifier: PRIdentifier;
+    projectContext: ProjectContext;
+    diffStrategy: DiffStrategy;
+    prDiff?: PRDiff;
+    fileDiffs?: Map<string, string>;
+    contextId: string;
+    gatheredAt: string;
+    cacheHits: string[];
+    gatheringDuration: number;
+}
+export declare class ContextGatherer {
+    private neurolink;
+    private bitbucketProvider;
+    private aiConfig;
+    private startTime;
+    constructor(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig);
+    /**
+     * Main context gathering method - used by all operations
+     */
+    gatherContext(identifier: PRIdentifier, options?: {
+        excludePatterns?: string[];
+        contextLines?: number;
+        forceRefresh?: boolean;
+        includeDiff?: boolean;
+        diffStrategyConfig?: DiffStrategyConfig;
+    }): Promise<UnifiedContext>;
+    /**
+     * Step 1: Find PR and get detailed information
+     */
+    private findAndGetPR;
+    /**
+     * Step 2: Gather project context (memory bank + clinerules)
+     */
+    private gatherProjectContext;
+    /**
+     * Parse project context with AI
+     */
+    private parseProjectContextWithAI;
+    /**
+     * Step 3: Determine optimal diff strategy
+     */
+    private determineDiffStrategy;
+    /**
+     * Estimate diff size based on file count
+     */
+    private estimateDiffSize;
+    /**
+     * Get whole PR diff
+     */
+    private getPRDiff;
+    /**
+     * Get file-by-file diffs for large changesets
+     */
+    private getFileByFileDiffs;
+    /**
+     * Cache the complete context for reuse
+     */
+    private cacheContext;
+    /**
+     * Get cached context if available
+     */
+    getCachedContext(identifier: PRIdentifier): Promise<UnifiedContext | null>;
+    /**
+     * Invalidate context cache for a specific PR
+     */
+    invalidateContext(identifier: PRIdentifier): void;
+    /**
+     * Generate unique context ID
+     */
+    private generateContextId;
+    /**
+     * Parse AI response utility
+     */
+    private parseAIResponse;
+    /**
+     * Get gathering statistics
+     */
+    getStats(): any;
+}
+export declare function createContextGatherer(bitbucketProvider: BitbucketProvider, aiConfig: AIProviderConfig): ContextGatherer;
+//# sourceMappingURL=ContextGatherer.d.ts.map