il2cpp-dump-analyzer-mcp/dist/agent/mcp-context-manager.d.ts

Agentic RAG system for analyzing IL2CPP dump.cs files from Unity games

/**
 * @fileoverview Enhanced MCP Context Management
 * Provides context preservation, intelligent caching, and session management
 * for complex IL2CPP analysis workflows within the MCP framework
 */
import { ToolExecutionContext } from '../mcp/base-tool-handler';
import { AnalysisSession, ContextData, SessionCache, SessionMetrics, SessionPreferences, ContextRecommendation, ContextCompressionConfig, ToolExecutionResult } from './types';
/**
 * Configuration options for the MCP Context Manager
 */
export interface ContextManagerConfig {
    /** Maximum memory per session in MB */
    maxSessionMemoryMB: number;
    /** Session TTL in milliseconds */
    sessionTTLMs: number;
    /** Enable context compression */
    enableCompression: boolean;
    /** Compression threshold in bytes */
    compressionThreshold: number;
    /** Maximum number of active sessions */
    maxActiveSessions: number;
    /** Cache configuration */
    cacheConfig?: {
        maxSizeMB: number;
        ttlMs: number;
        maxEntries: number;
    };
    /** Compression configuration */
    compressionConfig?: ContextCompressionConfig;
}
/**
 * Enhanced MCP Context Management System
 * Provides intelligent context preservation and correlation across MCP tool calls
 */
export declare class MCPContextManager {
    private context;
    private config;
    private sessions;
    private globalCorrelation;
    private compressionStats;
    constructor(context: ToolExecutionContext, config?: Partial<ContextManagerConfig>);
    /**
     * Create a new analysis session
     */
    createSession(originalRequest: string, options?: {
        sessionTTLMs?: number;
        preferences?: SessionPreferences;
        compressionConfig?: ContextCompressionConfig;
    }): Promise<AnalysisSession>;
    /**
     * Retrieve an existing session
     */
    getSession(sessionId: string): Promise<AnalysisSession | null>;
    /**
     * Update session activity timestamp
     */
    updateSessionActivity(sessionId: string): Promise<void>;
    /**
     * Store context data in a session
     */
    storeContext(sessionId: string, contextData: ContextData): Promise<void>;
    /**
     * Retrieve context data from a session
     */
    getContext(sessionId: string, contextId: string): Promise<ContextData | null>;
    /**
     * Get all contexts for a session
     */
    getAllContexts(sessionId: string): Promise<ContextData[]>;
    /**
     * Update existing context data
     */
    updateContext(sessionId: string, contextId: string, newData: any): Promise<void>;
    /**
     * Cache tool result with intelligent correlation
     */
    cacheToolResult(sessionId: string, toolResult: {
        toolName: string;
        parameters: Record<string, any>;
        result: ToolExecutionResult;
    }): Promise<void>;
    /**
     * Generate unique session ID
     */
    private generateSessionId;
    /**
     * Initialize session cache
     */
    private initializeSessionCache;
    /**
     * Initialize session metrics
     */
    private initializeSessionMetrics;
    /**
     * Initialize global correlation system
     */
    private initializeCorrelation;
    /**
     * Get cached tool result
     */
    getCachedResult(sessionId: string, toolName: string, parameters: Record<string, any>): Promise<{
        result: ToolExecutionResult;
    } | null>;
    /**
     * Get cache statistics for a session
     */
    getCacheStats(sessionId: string): Promise<SessionCache['stats'] & {
        maxSizeMB: number;
    }>;
    /**
     * Find correlations based on search term
     */
    findCorrelations(sessionId: string, searchTerm: string): Promise<ContextData[]>;
    /**
     * Add entity to session
     */
    addEntity(sessionId: string, entity: {
        name: string;
        type: string;
        relationships?: Array<{
            type: string;
            target: string;
            confidence?: number;
        }>;
    }): Promise<void>;
    /**
     * Get entity relationship graph for session
     */
    getEntityGraph(sessionId: string): Promise<Map<string, Set<string>>>;
    /**
     * Get context-aware recommendations
     */
    getRecommendations(sessionId: string): Promise<ContextRecommendation[]>;
    /**
     * Record tool execution in session
     */
    recordToolExecution(sessionId: string, execution: {
        toolName: string;
        parameters: Record<string, any>;
        result: ToolExecutionResult;
        timestamp: number;
    }): Promise<void>;
    /**
     * Get tool recommendations based on context
     */
    getToolRecommendations(sessionId: string): Promise<ContextRecommendation[]>;
    /**
     * Get session metrics
     */
    getSessionMetrics(sessionId: string): Promise<SessionMetrics>;
    /**
     * Get session statistics
     */
    getSessionStats(): Promise<{
        activeSessions: number;
        totalSessions: number;
        averageSessionDuration: number;
        memoryUsage: number;
    }>;
    /**
     * Get memory statistics for a session
     */
    getMemoryStats(sessionId: string): Promise<SessionMetrics['memoryMetrics']>;
    /**
     * Optimize memory usage for a session
     */
    optimizeMemory(sessionId: string): Promise<void>;
    /**
     * Get compression configuration for a session
     */
    getCompressionConfig(sessionId: string): Promise<ContextCompressionConfig>;
    /**
     * Clean up expired sessions
     */
    cleanupExpiredSessions(): Promise<void>;
    /**
     * Clean up all sessions and resources
     */
    cleanup(): Promise<void>;
    /**
     * Calculate data size in bytes
     */
    private calculateDataSize;
    /**
     * Compress context data
     */
    private compressContextData;
    /**
     * Decompress context data
     */
    private decompressContextData;
    /**
     * Generate cache key for tool and parameters
     */
    private generateCacheKey;
    /**
     * Extract semantic tags from tool result
     */
    private extractSemanticTags;
    /**
     * Check if cache should evict entries
     */
    private shouldEvictCache;
    /**
     * Evict cache entries using LRU strategy
     */
    private evictCacheEntries;
    /**
     * Update cache correlation index
     */
    private updateCacheCorrelation;
    /**
     * Update correlation index with new context
     */
    private updateCorrelationIndex;
    /**
     * Update tool usage patterns
     */
    private updateToolPatterns;
    /**
     * Extract entity name from tool parameters
     */
    private extractEntityFromParameters;
    /**
     * Calculate total memory usage for a session
     */
    private calculateSessionMemoryUsage;
    /**
     * Evict least recently used contexts from session
     */
    private evictLeastRecentlyUsedContexts;
    /**
     * Expire a session
     */
    private expireSession;
    /**
     * Evict oldest session to make room for new one
     */
    private evictOldestSession;
    /**
     * Start cleanup interval for expired sessions
     */
    private startCleanupInterval;
}