@juspay/yama 1.6.0 → 2.1.0

package/dist/v2/core/LearningOrchestrator.js

@@ -0,0 +1,499 @@
+/**
+ * Learning Orchestrator
+ * Main entry point for the knowledge base learning feature
+ * Orchestrates PR comment extraction, AI analysis, and knowledge base updates
+ */
+import { NeuroLink } from "@juspay/neurolink";
+import { MCPServerManager } from "./MCPServerManager.js";
+import { ConfigLoader } from "../config/ConfigLoader.js";
+import { LangfusePromptManager } from "../prompts/LangfusePromptManager.js";
+import { KnowledgeBaseManager } from "../learning/KnowledgeBaseManager.js";
+import { buildObservabilityConfigFromEnv, validateObservabilityConfig, } from "../utils/ObservabilityConfig.js";
+export class LearningOrchestrator {
+    neurolink;
+    mcpManager;
+    configLoader;
+    promptManager;
+    config;
+    initialized = false;
+    constructor() {
+        this.configLoader = new ConfigLoader();
+        this.mcpManager = new MCPServerManager();
+        this.promptManager = new LangfusePromptManager();
+    }
+    /**
+     * Initialize the learning orchestrator
+     */
+    async initialize(configPath) {
+        if (this.initialized) {
+            return;
+        }
+        console.log("🧠 Initializing Learning Orchestrator...\n");
+        try {
+            // Load configuration
+            this.config = await this.configLoader.loadConfig(configPath);
+            // Initialize NeuroLink
+            console.log("   🔧 Initializing NeuroLink AI engine...");
+            this.neurolink = this.initializeNeurolink();
+            console.log("   ✅ NeuroLink initialized\n");
+            // Setup MCP servers (need Bitbucket for PR access)
+            await this.mcpManager.setupMCPServers(this.neurolink, this.config.mcpServers);
+            console.log("   ✅ MCP servers ready\n");
+            this.initialized = true;
+            console.log("✅ Learning Orchestrator initialized\n");
+        }
+        catch (error) {
+            console.error("\n❌ Initialization failed:", error.message);
+            throw error;
+        }
+    }
+    /**
+     * Extract learnings from a merged PR
+     * Uses fully agentic AI approach - AI decides which tools to call
+     */
+    async extractLearnings(request) {
+        await this.ensureInitialized();
+        console.log("\n" + "─".repeat(60));
+        console.log(`📚 Extracting learnings from PR #${request.pullRequestId}`);
+        console.log("─".repeat(60));
+        console.log(`   Workspace: ${request.workspace}`);
+        console.log(`   Repository: ${request.repository}`);
+        console.log(`   Mode: ${request.dryRun ? "🔵 DRY RUN" : "🔴 LIVE"}`);
+        console.log("─".repeat(60) + "\n");
+        try {
+            // STEP 1: Fetch PR comments using agentic approach (with tools)
+            console.log("📥 Step 1: Fetching PR comments via Bitbucket MCP...");
+            const fetchInstructions = this.buildFetchCommentsInstructions(request);
+            const fetchResponse = await this.neurolink.generate({
+                input: { text: fetchInstructions },
+                provider: this.config.ai.provider,
+                model: this.config.ai.model,
+                temperature: 0.1,
+                maxTokens: 50000,
+                timeout: this.config.ai.timeout,
+                context: {
+                    operation: "learning-fetch-comments",
+                    prId: request.pullRequestId,
+                },
+            });
+            const commentsData = fetchResponse.content || "";
+            console.log("   ✅ PR data fetched\n");
+            // STEP 2: Extract learnings with structured schema (no tools needed)
+            console.log("🤖 Step 2: Extracting learnings with structured output...");
+            const learningPrompt = await this.promptManager.getLearningPrompt();
+            const extractionInstructions = this.buildExtractionInstructions(request, learningPrompt, commentsData);
+            // Extract learnings - disableTools since we already have the data
+            const extractResponse = await this.neurolink.generate({
+                input: { text: extractionInstructions },
+                provider: this.config.ai.provider,
+                model: this.config.ai.model,
+                temperature: 0.2,
+                maxTokens: 10000,
+                timeout: "2m",
+                disableTools: true, // No tools needed for extraction phase
+                context: {
+                    operation: "learning-extraction",
+                    prId: request.pullRequestId,
+                },
+            });
+            // Parse structured response
+            const learnings = this.parseStructuredLearnings(extractResponse, request.pullRequestId);
+            console.log(`\n📊 AI extracted ${learnings.length} learnings\n`);
+            if (learnings.length === 0) {
+                // Log extraction response for debugging
+                console.log("🔍 Extraction Response (for debugging):");
+                console.log("─".repeat(60));
+                const responsePreview = JSON.stringify(extractResponse.content || extractResponse, null, 2).slice(0, 2000);
+                console.log(responsePreview);
+                console.log("─".repeat(60) + "\n");
+                return this.createEmptyResult(request, "No actionable learnings found from PR feedback");
+            }
+            // Handle dry run vs live mode
+            if (request.dryRun) {
+                return this.handleDryRun(request, learnings);
+            }
+            // Update knowledge base
+            console.log("📝 Updating knowledge base...");
+            const kbManager = new KnowledgeBaseManager(this.config.knowledgeBase, process.cwd());
+            // Create if doesn't exist
+            if (!kbManager.exists()) {
+                console.log("   Creating new knowledge base file...");
+                await kbManager.create();
+            }
+            const addedCount = await kbManager.append(learnings);
+            const duplicateCount = learnings.length - addedCount;
+            console.log(`   ✅ Added ${addedCount} learnings`);
+            if (duplicateCount > 0) {
+                console.log(`   ⏭️  Skipped ${duplicateCount} duplicates`);
+            }
+            // Check if summarization is needed
+            let summarized = false;
+            if (request.summarize || (await kbManager.needsSummarization())) {
+                console.log("\n🔄 Running summarization...");
+                await this.runSummarization(kbManager);
+                summarized = true;
+                console.log("   ✅ Summarization complete");
+            }
+            // Commit if requested
+            let committed = false;
+            if (request.commit || this.config.knowledgeBase.autoCommit) {
+                console.log("\n📤 Committing knowledge base...");
+                await kbManager.commit(request.pullRequestId, addedCount);
+                committed = true;
+                console.log("   ✅ Changes committed");
+            }
+            // Return result
+            const result = {
+                success: true,
+                prId: request.pullRequestId,
+                learningsFound: learnings.length,
+                learningsAdded: addedCount,
+                learningsDuplicate: duplicateCount,
+                learnings,
+                knowledgeBasePath: kbManager.getFilePath(),
+                committed,
+                summarized,
+            };
+            this.logResult(result);
+            return result;
+        }
+        catch (error) {
+            console.error("\n❌ Learning extraction failed:", error.message);
+            return {
+                success: false,
+                prId: request.pullRequestId,
+                learningsFound: 0,
+                learningsAdded: 0,
+                learningsDuplicate: 0,
+                learnings: [],
+                error: error.message,
+            };
+        }
+    }
+    /**
+     * Build instructions for Step 1: Fetch PR comments
+     */
+    buildFetchCommentsInstructions(request) {
+        const aiPatterns = this.config.knowledgeBase.aiAuthorPatterns.join(", ");
+        return `
+<task>Fetch and analyze ALL PR comments for learning extraction</task>
+
+<pr-details>
+  <workspace>${request.workspace}</workspace>
+  <repository>${request.repository}</repository>
+  <pull_request_id>${request.pullRequestId}</pull_request_id>
+</pr-details>
+
+<instructions>
+1. Use get_pull_request tool to fetch the PR details including all comments/activities
+2. Look through ALL comments on the PR (both active and resolved if available)
+3. Identify AI-generated comments by:
+   - Author patterns: ${aiPatterns}
+   - Text patterns: Comments starting with "🔒 CRITICAL:", "⚠️ MAJOR:", "💡 MINOR:", "💬 SUGGESTION:", or "Yama Review"
+4. For each AI comment, look for developer replies (threaded responses or comments at same location)
+5. IMPORTANT: Also identify DEVELOPER comments that are NOT replies to AI comments
+   - These represent issues that AI MISSED and should have caught
+   - Look for inline code comments from developers (not AI) that point out bugs, issues, or improvements
+6. Output a structured summary of what you found
+</instructions>
+
+<output-format>
+Provide a detailed summary in this format:
+
+## PR Overview
+- Title: [PR title]
+- State: [merged/open/etc]
+- Total comments found: [N]
+
+## AI Comments Found
+For each AI comment, list:
+- Author: [name]
+- Severity: [CRITICAL/MAJOR/MINOR/SUGGESTION]
+- Comment text: [the comment]
+- Location: [file path and line if inline]
+
+## Developer Replies to AI Comments
+For each developer reply to an AI comment:
+- Original AI comment: [brief summary]
+- Developer reply: [the full reply text]
+- Developer name: [name]
+
+## Developer Comments (NOT replies to AI)
+IMPORTANT: List ALL developer-authored inline comments that are NOT replies to AI.
+These represent issues AI MISSED and should have caught.
+For each:
+- Developer name: [name]
+- File: [file path]
+- Line: [line number if available]
+- Comment text: [the full comment]
+- Type: [bug/issue/suggestion/question]
+
+If there are no developer comments (other than replies), state: "NO INDEPENDENT DEVELOPER COMMENTS FOUND"
+</output-format>
+
+Fetch the PR data now.
+`;
+    }
+    /**
+     * Build instructions for Step 2: Extract learnings from fetched data
+     */
+    buildExtractionInstructions(request, learningPrompt, commentsData) {
+        return `
+<task>Extract project-level learnings from PR feedback</task>
+
+<fetched-pr-data>
+${commentsData}
+</fetched-pr-data>
+
+${learningPrompt}
+
+<extraction-rules>
+Extract learnings from TWO sources:
+
+1. DEVELOPER REPLIES TO AI COMMENTS:
+   - Developer explained why AI was wrong → false_positive
+   - Developer provided context AI should know → domain_context
+   - Developer indicated team preference → style_preference
+   - Developer suggested how AI should improve → enhancement_guideline
+
+2. INDEPENDENT DEVELOPER COMMENTS (not replies to AI):
+   - These are issues AI MISSED and should have caught → missed_issue
+   - If a developer added their own inline comment about a bug/issue, AI failed to spot it
+   - Extract what type of issue it was so AI can catch similar issues in future
+
+IMPORTANT RULES:
+- Make learnings GENERIC - remove PR-specific details (file names, line numbers, variable names)
+- Focus on the underlying principle or pattern that can apply to future reviews
+- If BOTH "NO DEVELOPER REPLIES" AND "NO INDEPENDENT DEVELOPER COMMENTS", return empty learnings
+
+Categories:
+- false_positive: Developer explained why AI was wrong
+- missed_issue: Developer pointed out something AI should have caught (including independent comments)
+- style_preference: Team conventions that differ from general practice
+- domain_context: Project-specific knowledge AI needs
+- enhancement_guideline: How AI should provide better suggestions
+</extraction-rules>
+
+<output-format>
+Return a JSON object in this exact format (wrapped in a json code block):
+
+\`\`\`json
+{
+  "learnings": [
+    {
+      "category": "false_positive|missed_issue|style_preference|domain_context|enhancement_guideline",
+      "subcategory": "Optional grouping (e.g., 'Async Patterns', 'Error Handling')",
+      "learning": "The GENERIC, PROJECT-LEVEL guideline",
+      "filePatterns": ["Optional array of file patterns where this applies"],
+      "reasoning": "Why this learning was extracted"
+    }
+  ],
+  "summary": {
+    "totalAIComments": 0,
+    "totalDeveloperReplies": 0,
+    "totalIndependentDevComments": 0,
+    "actionablePairsFound": 0
+  }
+}
+\`\`\`
+
+If no actionable feedback found, return empty learnings array with appropriate summary counts.
+</output-format>
+
+Analyze the PR data above and extract learnings.
+`;
+    }
+    /**
+     * Parse structured response from AI output
+     */
+    parseStructuredLearnings(response, prId) {
+        try {
+            const content = (response.content || "");
+            // Find JSON in response (may be in code block)
+            const jsonMatch = content.match(/```json\s*([\s\S]*?)\s*```/) ||
+                content.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.log("   ⚠️ No JSON found in extraction response");
+                return [];
+            }
+            const jsonStr = jsonMatch[1] || jsonMatch[0];
+            const parsed = JSON.parse(jsonStr);
+            // Log summary if available
+            if (parsed.summary) {
+                const devComments = parsed.summary.totalIndependentDevComments || 0;
+                console.log(`   📊 Summary: ${parsed.summary.totalAIComments} AI comments, ${parsed.summary.totalDeveloperReplies} dev replies, ${devComments} independent dev comments`);
+            }
+            if (!parsed.learnings || !Array.isArray(parsed.learnings)) {
+                return [];
+            }
+            const kbManager = new KnowledgeBaseManager(this.config.knowledgeBase, process.cwd());
+            return parsed.learnings.map((item) => ({
+                id: kbManager.generateLearningId(item.learning),
+                category: item.category,
+                subcategory: item.subcategory,
+                learning: item.learning,
+                filePatterns: item.filePatterns,
+                sourceInfo: {
+                    prId,
+                    timestamp: new Date().toISOString(),
+                },
+            }));
+        }
+        catch (error) {
+            console.warn("   ⚠️ Failed to parse structured output:", error.message);
+            return [];
+        }
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    /**
+     * Initialize NeuroLink with observability
+     */
+    initializeNeurolink() {
+        const observabilityConfig = buildObservabilityConfigFromEnv();
+        const neurolinkConfig = {
+            conversationMemory: this.config.ai.conversationMemory,
+        };
+        if (observabilityConfig &&
+            validateObservabilityConfig(observabilityConfig)) {
+            neurolinkConfig.observability = observabilityConfig;
+        }
+        return new NeuroLink(neurolinkConfig);
+    }
+    /**
+     * Ensure orchestrator is initialized
+     */
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
+    }
+    /**
+     * Handle dry run mode
+     */
+    handleDryRun(request, learnings) {
+        console.log("\n📋 DRY RUN - Extracted learnings preview:\n");
+        if (request.outputFormat === "json") {
+            console.log(JSON.stringify({
+                prId: request.pullRequestId,
+                learningsFound: learnings.length,
+                learnings: learnings.map((l) => ({
+                    category: l.category,
+                    subcategory: l.subcategory,
+                    learning: l.learning,
+                })),
+            }, null, 2));
+        }
+        else {
+            // Markdown format
+            const byCategory = new Map();
+            for (const learning of learnings) {
+                const cat = learning.category;
+                if (!byCategory.has(cat)) {
+                    byCategory.set(cat, []);
+                }
+                byCategory.get(cat).push(learning);
+            }
+            for (const [category, items] of byCategory) {
+                console.log(`## ${category.replace(/_/g, " ").toUpperCase()}`);
+                for (const item of items) {
+                    console.log(`- ${item.learning}`);
+                }
+                console.log("");
+            }
+            console.log("─".repeat(60));
+            console.log("Run without --dry-run to commit these learnings.");
+        }
+        return {
+            success: true,
+            prId: request.pullRequestId,
+            learningsFound: learnings.length,
+            learningsAdded: 0,
+            learningsDuplicate: 0,
+            learnings,
+        };
+    }
+    /**
+     * Run AI-powered summarization
+     */
+    async runSummarization(kbManager) {
+        const currentContent = await kbManager.getForPrompt();
+        if (!currentContent) {
+            return;
+        }
+        const systemPrompt = await this.promptManager.getSummarizationPrompt();
+        const prompt = `
+${systemPrompt}
+
+<current-knowledge-base>
+${currentContent}
+</current-knowledge-base>
+
+Consolidate the learnings as instructed. Return the complete updated knowledge base in markdown format.
+`;
+        const response = await this.neurolink.generate({
+            input: { text: prompt },
+            provider: this.config.ai.provider,
+            model: this.config.ai.model,
+            temperature: 0.2,
+            maxTokens: 30000,
+        });
+        // Parse and update the knowledge base
+        const newContent = (response.content || "");
+        // Extract markdown content (may be in code block)
+        let markdownContent = newContent;
+        const mdMatch = newContent.match(/```(?:markdown|md)?\s*([\s\S]*?)```/);
+        if (mdMatch) {
+            markdownContent = mdMatch[1].trim();
+        }
+        // Verify it looks like valid markdown KB
+        if (markdownContent.includes("# Project Knowledge Base")) {
+            // Write the summarized content directly to file
+            await kbManager.writeRaw(markdownContent);
+        }
+    }
+    /**
+     * Create empty result for cases with no learnings
+     */
+    createEmptyResult(request, reason) {
+        console.log(`\n⚠️ ${reason}\n`);
+        return {
+            success: true,
+            prId: request.pullRequestId,
+            learningsFound: 0,
+            learningsAdded: 0,
+            learningsDuplicate: 0,
+            learnings: [],
+        };
+    }
+    /**
+     * Log the final result
+     */
+    logResult(result) {
+        console.log("\n" + "═".repeat(60));
+        console.log("✅ Learning Extraction Complete");
+        console.log("═".repeat(60));
+        console.log(`   PR: #${result.prId}`);
+        console.log(`   Learnings found: ${result.learningsFound}`);
+        console.log(`   Learnings added: ${result.learningsAdded}`);
+        console.log(`   Duplicates skipped: ${result.learningsDuplicate}`);
+        if (result.knowledgeBasePath) {
+            console.log(`   Knowledge base: ${result.knowledgeBasePath}`);
+        }
+        if (result.committed) {
+            console.log(`   📤 Changes committed`);
+        }
+        if (result.summarized) {
+            console.log(`   🔄 Knowledge base summarized`);
+        }
+        console.log("═".repeat(60) + "\n");
+    }
+}
+/**
+ * Factory function to create LearningOrchestrator
+ */
+export function createLearningOrchestrator() {
+    return new LearningOrchestrator();
+}
+//# sourceMappingURL=LearningOrchestrator.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,100 @@
+/**
+ * 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, config.bitbucket?.blockedTools);
+        // Setup Jira MCP (optional)
+        if (config.jira.enabled) {
+            await this.setupJiraMCP(neurolink, config.jira.blockedTools);
+        }
+        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, blockedTools) {
+        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,
+                },
+                blockedTools: blockedTools || [],
+            });
+            console.log("   ✅ Bitbucket MCP server registered and tools available");
+            if (blockedTools && blockedTools.length > 0) {
+                console.log(`   🚫 Blocked tools: ${blockedTools.join(", ")}`);
+            }
+        }
+        catch (error) {
+            throw new MCPServerError(`Failed to setup Bitbucket MCP server: ${error.message}`);
+        }
+    }
+    /**
+     * Setup Jira MCP server (hardcoded, optionally enabled)
+     */
+    async setupJiraMCP(neurolink, blockedTools) {
+        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,
+                },
+                blockedTools: blockedTools || [],
+            });
+            console.log("   ✅ Jira MCP server registered and tools available");
+            if (blockedTools && blockedTools.length > 0) {
+                console.log(`   🚫 Blocked tools: ${blockedTools.join(", ")}`);
+            }
+        }
+        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