@juspay/yama 1.1.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,537 @@
+#!/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