@juspay/yama 1.6.0 → 2.1.0

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