@juspay/yama 1.5.1 → 2.0.0

package/dist/v2/config/DefaultConfig.js

@@ -0,0 +1,191 @@
+/**
+ * Default Configuration for Yama V2
+ * Provides sensible defaults when no config file is present
+ */
+export class DefaultConfig {
+    static get() {
+        return {
+            version: 2,
+            configType: "yama-v2",
+            display: {
+                showBanner: true,
+                streamingMode: false,
+                verboseToolCalls: false,
+                showAIThinking: false,
+            },
+            ai: {
+                provider: "auto",
+                model: "gemini-2.5-pro",
+                temperature: 0.2,
+                maxTokens: 128000,
+                enableAnalytics: true,
+                enableEvaluation: false,
+                timeout: "15m",
+                retryAttempts: 3,
+                conversationMemory: {
+                    enabled: true,
+                    store: "memory",
+                    maxSessions: 50,
+                    maxTurnsPerSession: 300,
+                    enableSummarization: false,
+                },
+            },
+            mcpServers: {
+                jira: {
+                    enabled: false, // Opt-in: users must explicitly enable Jira integration
+                },
+            },
+            review: {
+                enabled: true,
+                workflowInstructions: `Follow the autonomous review workflow defined in the base system prompt.`,
+                focusAreas: [
+                    {
+                        name: "Security Analysis",
+                        priority: "CRITICAL",
+                        description: `
+- SQL/NoSQL injection vulnerabilities
+- Cross-Site Scripting (XSS)
+- Authentication/Authorization flaws
+- Hardcoded secrets, API keys, passwords
+- Input validation and sanitization
+- Data exposure and privacy violations
+- Insecure dependencies
+            `.trim(),
+                    },
+                    {
+                        name: "Performance Review",
+                        priority: "MAJOR",
+                        description: `
+- N+1 database query patterns
+- Missing indexes on queries
+- Memory leaks and resource management
+- Algorithm complexity (O(n²) or worse)
+- Inefficient loops and iterations
+- Missing caching opportunities
+- Blocking I/O in async contexts
+            `.trim(),
+                    },
+                    {
+                        name: "Code Quality",
+                        priority: "MAJOR",
+                        description: `
+- SOLID principle violations
+- Poor error handling
+- Missing edge case handling
+- Code duplication (DRY violations)
+- Poor naming conventions
+- Lack of modularity
+- Insufficient logging
+            `.trim(),
+                    },
+                ],
+                blockingCriteria: [
+                    {
+                        condition: "ANY CRITICAL severity issue",
+                        action: "BLOCK",
+                        reason: "Security or data loss risk",
+                    },
+                    {
+                        condition: "3 or more MAJOR severity issues",
+                        action: "BLOCK",
+                        reason: "Too many significant bugs/performance issues",
+                    },
+                    {
+                        condition: "Jira requirement coverage < 70% (only when Jira is enabled)",
+                        action: "BLOCK",
+                        reason: "Incomplete implementation of requirements",
+                    },
+                ],
+                excludePatterns: [
+                    "*.lock",
+                    "*.svg",
+                    "*.min.js",
+                    "*.map",
+                    "package-lock.json",
+                    "pnpm-lock.yaml",
+                    "yarn.lock",
+                ],
+                contextLines: 3,
+                maxFilesPerReview: 100,
+                fileAnalysisTimeout: "2m",
+                toolPreferences: {
+                    lazyLoading: true,
+                    cacheToolResults: true,
+                    parallelToolCalls: false,
+                    maxToolCallsPerFile: 20,
+                    enableCodeSearch: true,
+                    enableDirectoryListing: true,
+                },
+            },
+            descriptionEnhancement: {
+                enabled: true,
+                instructions: `Enhance the PR description using Jira requirements and diff analysis.`,
+                requiredSections: [
+                    {
+                        key: "summary",
+                        name: "📋 Summary",
+                        required: true,
+                        description: "Clear overview of what this PR accomplishes",
+                    },
+                    {
+                        key: "changes",
+                        name: "🔧 Changes Made",
+                        required: true,
+                        description: "Specific technical changes with file references",
+                    },
+                    {
+                        key: "jira",
+                        name: "🎫 Jira Reference",
+                        required: false,
+                        description: "Link to Jira ticket and requirement coverage",
+                    },
+                    {
+                        key: "testing",
+                        name: "🧪 Testing Strategy",
+                        required: true,
+                        description: "How changes were tested and validation approach",
+                    },
+                ],
+                preserveContent: true,
+                autoFormat: true,
+            },
+            memoryBank: {
+                enabled: true,
+                path: "memory-bank",
+                fallbackPaths: ["docs/memory-bank", ".memory-bank"],
+                standardFiles: [
+                    "project-overview.md",
+                    "architecture.md",
+                    "coding-standards.md",
+                    "security-guidelines.md",
+                ],
+            },
+            projectStandards: {
+                customPromptsPath: "config/prompts/",
+                additionalFocusAreas: [],
+                customBlockingRules: [],
+                severityOverrides: {},
+            },
+            monitoring: {
+                enabled: true,
+                logToolCalls: true,
+                logAIDecisions: true,
+                logTokenUsage: true,
+                exportFormat: "json",
+                exportPath: ".yama/analytics/",
+            },
+            performance: {
+                maxReviewDuration: "15m",
+                tokenBudget: {
+                    maxTokensPerReview: 500000,
+                    warningThreshold: 400000,
+                },
+                costControls: {
+                    maxCostPerReview: 2.0,
+                    warningThreshold: 1.5,
+                },
+            },
+        };
+    }
+}
+//# sourceMappingURL=DefaultConfig.js.map

package/dist/v2/core/MCPServerManager.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP Server Manager for Yama V2
+ * Manages lifecycle and health of Bitbucket and Jira MCP servers
+ */
+import { MCPServersConfig } from "../types/config.types.js";
+export declare class MCPServerManager {
+    private initialized;
+    /**
+     * Setup all MCP servers in NeuroLink
+     * Bitbucket is always enabled, Jira is optional based on config
+     */
+    setupMCPServers(neurolink: any, config: MCPServersConfig): Promise<void>;
+    /**
+     * Setup Bitbucket MCP server (hardcoded, always enabled)
+     */
+    private setupBitbucketMCP;
+    /**
+     * Setup Jira MCP server (hardcoded, optionally enabled)
+     */
+    private setupJiraMCP;
+}
+//# sourceMappingURL=MCPServerManager.d.ts.map

package/dist/v2/core/MCPServerManager.js

@@ -0,0 +1,92 @@
+/**
+ * MCP Server Manager for Yama V2
+ * Manages lifecycle and health of Bitbucket and Jira MCP servers
+ */
+import { MCPServerError } from "../types/v2.types.js";
+export class MCPServerManager {
+    // MCP servers are managed entirely by NeuroLink
+    // No need to track tools locally
+    initialized = false;
+    /**
+     * Setup all MCP servers in NeuroLink
+     * Bitbucket is always enabled, Jira is optional based on config
+     */
+    async setupMCPServers(neurolink, config) {
+        console.log("🔌 Setting up MCP servers...");
+        // Setup Bitbucket MCP (always enabled)
+        await this.setupBitbucketMCP(neurolink);
+        // Setup Jira MCP (optional)
+        if (config.jira.enabled) {
+            await this.setupJiraMCP(neurolink);
+        }
+        else {
+            console.log("   ⏭️  Jira MCP disabled in config");
+        }
+        this.initialized = true;
+        console.log("✅ MCP servers configured\n");
+    }
+    /**
+     * Setup Bitbucket MCP server (hardcoded, always enabled)
+     */
+    async setupBitbucketMCP(neurolink) {
+        try {
+            console.log("   🔧 Registering Bitbucket MCP server...");
+            // Verify environment variables
+            if (!process.env.BITBUCKET_USERNAME ||
+                !process.env.BITBUCKET_TOKEN ||
+                !process.env.BITBUCKET_BASE_URL) {
+                throw new MCPServerError("Missing required environment variables: BITBUCKET_USERNAME, BITBUCKET_TOKEN, or BITBUCKET_BASE_URL");
+            }
+            // Hardcoded Bitbucket MCP configuration
+            await neurolink.addExternalMCPServer("bitbucket", {
+                command: "npx",
+                args: ["-y", "@nexus2520/bitbucket-mcp-server"],
+                transport: "stdio",
+                env: {
+                    BITBUCKET_USERNAME: process.env.BITBUCKET_USERNAME,
+                    BITBUCKET_TOKEN: process.env.BITBUCKET_TOKEN,
+                    BITBUCKET_BASE_URL: process.env.BITBUCKET_BASE_URL,
+                },
+            });
+            console.log("   ✅ Bitbucket MCP server registered and tools available");
+        }
+        catch (error) {
+            throw new MCPServerError(`Failed to setup Bitbucket MCP server: ${error.message}`);
+        }
+    }
+    /**
+     * Setup Jira MCP server (hardcoded, optionally enabled)
+     */
+    async setupJiraMCP(neurolink) {
+        try {
+            console.log("   🔧 Registering Jira MCP server...");
+            // Validate required Jira environment variables
+            const jiraEmail = process.env.JIRA_EMAIL;
+            const jiraToken = process.env.JIRA_API_TOKEN;
+            const jiraBaseUrl = process.env.JIRA_BASE_URL;
+            if (!jiraEmail || !jiraToken || !jiraBaseUrl) {
+                console.warn("   ⚠️  Missing Jira environment variables (JIRA_EMAIL, JIRA_API_TOKEN, or JIRA_BASE_URL)");
+                console.warn("   Skipping Jira integration...");
+                return;
+            }
+            // Hardcoded Jira MCP configuration
+            await neurolink.addExternalMCPServer("jira", {
+                command: "npx",
+                args: ["-y", "@nexus2520/jira-mcp-server"],
+                transport: "stdio",
+                env: {
+                    JIRA_EMAIL: process.env.JIRA_EMAIL,
+                    JIRA_API_TOKEN: process.env.JIRA_API_TOKEN,
+                    JIRA_BASE_URL: process.env.JIRA_BASE_URL,
+                },
+            });
+            console.log("   ✅ Jira MCP server registered and tools available");
+        }
+        catch (error) {
+            // Jira is optional, so we warn instead of throwing
+            console.warn(`   ⚠️  Failed to setup Jira MCP server: ${error.message}`);
+            console.warn("   Continuing without Jira integration...");
+        }
+    }
+}
+//# sourceMappingURL=MCPServerManager.js.map

package/dist/v2/core/SessionManager.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Session Manager for Yama V2
+ * Tracks review sessions, tool calls, and maintains state
+ */
+import { ReviewSession, ReviewRequest, ReviewResult, SessionMetadata } from "../types/v2.types.js";
+export declare class SessionManager {
+    private sessions;
+    private maxSessions;
+    /**
+     * Create a new review session
+     */
+    createSession(request: ReviewRequest): string;
+    /**
+     * Get session by ID
+     */
+    getSession(sessionId: string): ReviewSession;
+    /**
+     * Record a tool call in the session
+     */
+    recordToolCall(sessionId: string, toolName: string, args: any, result: any, duration: number, error?: string): void;
+    /**
+     * Update session metadata
+     */
+    updateMetadata(sessionId: string, updates: Partial<SessionMetadata>): void;
+    /**
+     * Mark session as completed
+     */
+    completeSession(sessionId: string, result: ReviewResult): void;
+    /**
+     * Mark session as failed
+     */
+    failSession(sessionId: string, error: Error): void;
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions(): ReviewSession[];
+    /**
+     * Get session statistics
+     */
+    getSessionStats(sessionId: string): {
+        duration: number;
+        toolCallCount: number;
+        uniqueTools: number;
+        averageToolCallDuration: number;
+        toolCallsByName: Record<string, number>;
+    };
+    /**
+     * Generate unique session ID
+     */
+    private generateSessionId;
+    /**
+     * Clean up old sessions (keep most recent 100)
+     */
+    private cleanupOldSessions;
+    /**
+     * Export session data for debugging
+     */
+    exportSession(sessionId: string): any;
+    /**
+     * Summarize tool result for logging
+     */
+    private summarizeToolResult;
+    /**
+     * Clear all sessions
+     */
+    clearAll(): void;
+    /**
+     * Get session count
+     */
+    getSessionCount(): number;
+}
+//# sourceMappingURL=SessionManager.d.ts.map

package/dist/v2/core/SessionManager.js

@@ -0,0 +1,200 @@
+/**
+ * Session Manager for Yama V2
+ * Tracks review sessions, tool calls, and maintains state
+ */
+import { randomBytes } from "crypto";
+export class SessionManager {
+    sessions = new Map();
+    maxSessions = 100;
+    /**
+     * Create a new review session
+     */
+    createSession(request) {
+        const sessionId = this.generateSessionId();
+        const session = {
+            sessionId,
+            request,
+            startTime: new Date(),
+            status: "running",
+            toolCalls: [],
+            metadata: {
+                yamaVersion: "2.0.0",
+                aiProvider: "auto",
+                aiModel: "unknown",
+                totalTokens: 0,
+                totalCost: 0,
+                cacheHitRatio: 0,
+            },
+        };
+        this.sessions.set(sessionId, session);
+        // Clean up old sessions if we exceed max
+        if (this.sessions.size > this.maxSessions) {
+            this.cleanupOldSessions();
+        }
+        return sessionId;
+    }
+    /**
+     * Get session by ID
+     */
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Session not found: ${sessionId}`);
+        }
+        return session;
+    }
+    /**
+     * Record a tool call in the session
+     */
+    recordToolCall(sessionId, toolName, args, result, duration, error) {
+        const session = this.getSession(sessionId);
+        const toolCall = {
+            timestamp: new Date(),
+            toolName,
+            args,
+            result,
+            error,
+            duration,
+        };
+        session.toolCalls.push(toolCall);
+    }
+    /**
+     * Update session metadata
+     */
+    updateMetadata(sessionId, updates) {
+        const session = this.getSession(sessionId);
+        session.metadata = {
+            ...session.metadata,
+            ...updates,
+        };
+    }
+    /**
+     * Mark session as completed
+     */
+    completeSession(sessionId, result) {
+        const session = this.getSession(sessionId);
+        session.status = "completed";
+        session.endTime = new Date();
+        session.result = result;
+    }
+    /**
+     * Mark session as failed
+     */
+    failSession(sessionId, error) {
+        const session = this.getSession(sessionId);
+        session.status = "failed";
+        session.endTime = new Date();
+        session.error = error;
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.sessions.values()).filter((s) => s.status === "running");
+    }
+    /**
+     * Get session statistics
+     */
+    getSessionStats(sessionId) {
+        const session = this.getSession(sessionId);
+        const duration = session.endTime
+            ? session.endTime.getTime() - session.startTime.getTime()
+            : Date.now() - session.startTime.getTime();
+        const toolCallsByName = {};
+        let totalToolDuration = 0;
+        session.toolCalls.forEach((tc) => {
+            toolCallsByName[tc.toolName] = (toolCallsByName[tc.toolName] || 0) + 1;
+            totalToolDuration += tc.duration;
+        });
+        return {
+            duration: Math.round(duration / 1000), // seconds
+            toolCallCount: session.toolCalls.length,
+            uniqueTools: Object.keys(toolCallsByName).length,
+            averageToolCallDuration: session.toolCalls.length > 0
+                ? Math.round(totalToolDuration / session.toolCalls.length)
+                : 0,
+            toolCallsByName,
+        };
+    }
+    /**
+     * Generate unique session ID
+     */
+    generateSessionId() {
+        const timestamp = Date.now().toString(36);
+        const random = randomBytes(4).toString("hex");
+        return `yama-v2-${timestamp}-${random}`;
+    }
+    /**
+     * Clean up old sessions (keep most recent 100)
+     */
+    cleanupOldSessions() {
+        const sessions = Array.from(this.sessions.entries());
+        // Sort by start time (oldest first)
+        sessions.sort((a, b) => {
+            return a[1].startTime.getTime() - b[1].startTime.getTime();
+        });
+        // Remove oldest sessions
+        const toRemove = sessions.length - this.maxSessions;
+        for (let i = 0; i < toRemove; i++) {
+            this.sessions.delete(sessions[i][0]);
+        }
+    }
+    /**
+     * Export session data for debugging
+     */
+    exportSession(sessionId) {
+        const session = this.getSession(sessionId);
+        const stats = this.getSessionStats(sessionId);
+        return {
+            session: {
+                sessionId: session.sessionId,
+                request: session.request,
+                startTime: session.startTime.toISOString(),
+                endTime: session.endTime?.toISOString(),
+                status: session.status,
+                metadata: session.metadata,
+                result: session.result,
+                error: session.error?.message,
+            },
+            statistics: stats,
+            toolCalls: session.toolCalls.map((tc) => ({
+                timestamp: tc.timestamp.toISOString(),
+                toolName: tc.toolName,
+                args: tc.args,
+                duration: tc.duration,
+                error: tc.error,
+                // Don't include full result in export (can be very large)
+                resultSummary: this.summarizeToolResult(tc.result),
+            })),
+        };
+    }
+    /**
+     * Summarize tool result for logging
+     */
+    summarizeToolResult(result) {
+        if (!result) {
+            return "null";
+        }
+        if (typeof result === "string") {
+            return result.length > 100 ? `${result.substring(0, 100)}...` : result;
+        }
+        if (typeof result === "object") {
+            const keys = Object.keys(result);
+            return `{${keys.slice(0, 5).join(", ")}${keys.length > 5 ? ", ..." : ""}}`;
+        }
+        return String(result);
+    }
+    /**
+     * Clear all sessions
+     */
+    clearAll() {
+        this.sessions.clear();
+    }
+    /**
+     * Get session count
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+}
+//# sourceMappingURL=SessionManager.js.map

package/dist/v2/core/YamaV2Orchestrator.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Yama V2 Orchestrator
+ * Main entry point for AI-native autonomous code review
+ */
+import { ReviewRequest, ReviewResult, ReviewUpdate } from "../types/v2.types.js";
+export declare class YamaV2Orchestrator {
+    private neurolink;
+    private mcpManager;
+    private configLoader;
+    private promptBuilder;
+    private sessionManager;
+    private config;
+    private initialized;
+    constructor();
+    /**
+     * Initialize Yama V2 with configuration and MCP servers
+     */
+    initialize(configPath?: string): Promise<void>;
+    /**
+     * Start autonomous AI review
+     */
+    startReview(request: ReviewRequest): Promise<ReviewResult>;
+    /**
+     * Stream review with real-time updates (for verbose mode)
+     */
+    streamReview(request: ReviewRequest): AsyncIterableIterator<ReviewUpdate>;
+    /**
+     * Start review and then enhance description in the same session
+     * This allows the AI to use knowledge gained during review to write better descriptions
+     */
+    startReviewAndEnhance(request: ReviewRequest): Promise<ReviewResult>;
+    /**
+     * Enhance PR description only (without full review)
+     */
+    enhanceDescription(request: ReviewRequest): Promise<any>;
+    /**
+     * Get session information
+     */
+    getSession(sessionId: string): import("../types/v2.types.js").ReviewSession;
+    /**
+     * Get session statistics
+     */
+    getSessionStats(sessionId: string): {
+        duration: number;
+        toolCallCount: number;
+        uniqueTools: number;
+        averageToolCallDuration: number;
+        toolCallsByName: Record<string, number>;
+    };
+    /**
+     * Export session data
+     */
+    exportSession(sessionId: string): any;
+    /**
+     * Create tool context for AI
+     */
+    private createToolContext;
+    /**
+     * Parse AI response into structured review result
+     */
+    private parseReviewResult;
+    /**
+     * Extract decision from AI response
+     */
+    private extractDecision;
+    /**
+     * Calculate statistics from session
+     */
+    private calculateStatistics;
+    /**
+     * Extract issue counts from comment tool calls
+     */
+    private extractIssueCountsFromComments;
+    /**
+     * Extract summary from AI response
+     */
+    private extractSummary;
+    /**
+     * Calculate cost estimate from token usage
+     */
+    private calculateCost;
+    /**
+     * Generate userId for NeuroLink context from repository and branch/PR
+     */
+    private generateUserId;
+    /**
+     * Initialize NeuroLink with observability configuration
+     */
+    private initializeNeurolink;
+    /**
+     * Ensure orchestrator is initialized
+     */
+    private ensureInitialized;
+    /**
+     * Show Yama V2 banner
+     */
+    private showBanner;
+    /**
+     * Log review start
+     */
+    private logReviewStart;
+    /**
+     * Log review completion
+     */
+    private logReviewComplete;
+    /**
+     * Format decision for display
+     */
+    private formatDecision;
+}
+export declare function createYamaV2(): YamaV2Orchestrator;
+//# sourceMappingURL=YamaV2Orchestrator.d.ts.map