@re-shell/cli/dist/utils/plugin-command-cache.d.ts

Full-stack development platform uniting microservices and microfrontends. Build complete applications with .NET (ASP.NET Core Web API, Minimal API), Java (Spring Boot, Quarkus, Micronaut, Vert.x), Rust (Actix-Web, Warp, Rocket, Axum), Python (FastAPI, Dja

import { EventEmitter } from 'events';
import { PluginCommandContext } from './plugin-command-registry';
export declare enum CacheStorageStrategy {
    MEMORY = "memory",
    FILE_SYSTEM = "file-system",
    HYBRID = "hybrid",
    DATABASE = "database"
}
export declare enum CacheInvalidationStrategy {
    TTL = "ttl",
    LRU = "lru",
    LFU = "lfu",
    FIFO = "fifo",
    MANUAL = "manual",
    EVENT_BASED = "event-based"
}
export declare enum PerformanceMonitoringLevel {
    NONE = "none",
    BASIC = "basic",
    DETAILED = "detailed",
    VERBOSE = "verbose"
}
export interface CacheEntry<T = any> {
    key: string;
    value: T;
    metadata: CacheEntryMetadata;
    createdAt: number;
    lastAccessedAt: number;
    accessCount: number;
    expiresAt?: number;
    size: number;
    tags: string[];
}
export interface CacheEntryMetadata {
    commandId: string;
    argumentsHash: string;
    optionsHash: string;
    contextHash: string;
    executionTime: number;
    success: boolean;
    errorInfo?: {
        type: string;
        message: string;
        stack?: string;
    };
    dependencies: string[];
    invalidators: string[];
}
export interface CacheConfiguration {
    enabled: boolean;
    strategy: CacheStorageStrategy;
    invalidationStrategy: CacheInvalidationStrategy;
    maxSize: number;
    maxMemoryUsage: number;
    defaultTTL: number;
    cleanupInterval: number;
    compressionEnabled: boolean;
    encryptionEnabled: boolean;
    persistToDisk: boolean;
    diskCachePath?: string;
    performanceMonitoring: PerformanceMonitoringLevel;
}
export interface PerformanceMetrics {
    totalExecutions: number;
    cacheHits: number;
    cacheMisses: number;
    hitRate: number;
    averageExecutionTime: number;
    averageCachedExecutionTime: number;
    totalMemoryUsage: number;
    totalDiskUsage: number;
    slowestCommands: Array<{
        commandId: string;
        averageTime: number;
        executionCount: number;
    }>;
    mostCachedCommands: Array<{
        commandId: string;
        cacheHits: number;
        hitRate: number;
    }>;
    errorRate: number;
    lastCleanupAt: number;
}
export interface CacheOperationResult<T = any> {
    hit: boolean;
    value?: T;
    metadata?: CacheEntryMetadata;
    executionTime: number;
    source: 'cache' | 'execution';
    error?: Error;
}
export declare class PluginCommandCacheManager extends EventEmitter {
    private memoryCache;
    private accessOrder;
    private accessFrequency;
    private config;
    private metrics;
    private cleanupTimer?;
    private encryptionKey?;
    constructor(config?: Partial<CacheConfiguration>);
    private initialize;
    executeWithCache<T = any>(commandId: string, args: Record<string, any>, options: Record<string, any>, context: PluginCommandContext, executor: () => Promise<T>): Promise<CacheOperationResult<T>>;
    private generateCacheKey;
    private getCacheEntry;
    private setCacheEntry;
    private isExpired;
    private updateAccessTracking;
    private updateAccessOrder;
    private ensureCapacity;
    private evictEntries;
    private evictEntriesBySize;
    invalidateEntry(key: string): Promise<boolean>;
    invalidateByTags(tags: string[]): Promise<number>;
    invalidateByCommand(commandId: string): Promise<number>;
    clearAll(): Promise<void>;
    private performCleanup;
    private loadCacheFromDisk;
    private loadCacheEntryFromDisk;
    private saveCacheEntryToDisk;
    private deleteCacheEntryFromDisk;
    private updateDiskCacheIndex;
    private clearDiskCache;
    private encrypt;
    private decrypt;
    private calculateSize;
    private calculateTotalMemoryUsage;
    private generateTags;
    private extractDependencies;
    private extractInvalidators;
    private hashObject;
    private hashContext;
    private normalizeForHashing;
    private updateMetrics;
    private resetMetrics;
    getMetrics(): PerformanceMetrics;
    getConfiguration(): CacheConfiguration;
    updateConfiguration(updates: Partial<CacheConfiguration>): void;
    getCacheStats(): any;
    private findOldestEntry;
    private findNewestEntry;
    private findMostAccessedEntry;
    private findLargestEntry;
    destroy(): Promise<void>;
}
export declare function createCommandCacheManager(config?: Partial<CacheConfiguration>): PluginCommandCacheManager;
export declare function formatCacheSize(bytes: number): string;
export declare function formatCacheHitRate(hitRate: number): string;
export declare function formatExecutionTime(time: number): string;