optivise/dist/services/cache-service.d.ts

Optivise - The Ultimate Optimizely Development Assistant with AI-powered features, zero-config setup, and comprehensive development support

/**
 * Advanced Caching and Performance Optimization Service
 * Provides intelligent caching with TTL, LRU eviction, and performance monitoring
 */
import { EventEmitter } from 'events';
import type { Logger } from '../types/index.js';
export interface CacheEntry<T = any> {
    value: T;
    timestamp: number;
    ttl: number;
    accessCount: number;
    lastAccessed: number;
    size: number;
}
export interface CacheStats {
    hits: number;
    misses: number;
    evictions: number;
    entries: number;
    memoryUsage: number;
    hitRate: number;
    avgAccessTime: number;
}
export interface CacheConfig {
    maxEntries: number;
    maxMemoryMB: number;
    defaultTTL: number;
    cleanupInterval: number;
    enableMetrics: boolean;
}
export declare class CacheService extends EventEmitter {
    private cache;
    private accessTimes;
    private stats;
    private cleanupTimer?;
    private logger;
    private config;
    constructor(logger: Logger, config?: Partial<CacheConfig>);
    /**
     * Store value in cache with optional TTL
     */
    set<T>(key: string, value: T, ttlMs?: number): boolean;
    /**
     * Retrieve value from cache
     */
    get<T>(key: string): T | null;
    /**
     * Check if key exists in cache (without accessing)
     */
    has(key: string): boolean;
    /**
     * Delete specific key from cache
     */
    delete(key: string): boolean;
    /**
     * Clear all cache entries
     */
    clear(): void;
    /**
     * Get cache statistics
     */
    getStats(): CacheStats;
    /**
     * Get cache configuration
     */
    getConfig(): CacheConfig;
    /**
     * Update cache configuration
     */
    updateConfig(config: Partial<CacheConfig>): void;
    /**
     * Get cache keys with optional filtering
     */
    getKeys(pattern?: RegExp): string[];
    /**
     * Get memory usage breakdown by key patterns
     */
    getMemoryBreakdown(): Record<string, {
        entries: number;
        memory: number;
    }>;
    /**
     * Manually trigger cache cleanup
     */
    cleanup(): number;
    /**
     * Preload cache with key-value pairs
     */
    preload(entries: Array<{
        key: string;
        value: any;
        ttl?: number;
    }>): Promise<number>;
    /**
     * Export cache contents for backup
     */
    export(): Array<{
        key: string;
        value: any;
        ttl: number;
        timestamp: number;
    }>;
    /**
     * Start cleanup timer
     */
    private startCleanupTimer;
    /**
     * Stop cleanup timer
     */
    private stopCleanupTimer;
    /**
     * Check if entry has expired
     */
    private isExpired;
    /**
     * Estimate size of value in bytes
     */
    private estimateSize;
    /**
     * Check if adding entry would exceed memory limit
     */
    private wouldExceedMemoryLimit;
    /**
     * Evict least recently used entries
     */
    private evictLRUEntries;
    /**
     * Update hit rate statistics
     */
    private updateHitRate;
    /**
     * Record access time for performance metrics
     */
    private recordAccessTime;
    /**
     * Categorize cache key for memory breakdown
     */
    private categorizeKey;
    /**
     * Cleanup resources
     */
    destroy(): void;
}
export declare const analysisCache: (logger: Logger) => CacheService;
export declare const documentationCache: (logger: Logger) => CacheService;
export declare const embeddingCache: (logger: Logger) => CacheService;
//# sourceMappingURL=cache-service.d.ts.map