mcp-context-engineering
Version:
The intelligent context optimization system for AI coding assistants. Built with Cole's PRP methodology, Context Portal knowledge graphs, and production-ready MongoDB architecture.
350 lines (349 loc) • 10.8 kB
TypeScript
import { z } from 'zod';
/**
* Cache Manager - Octocode-inspired intelligent caching
*
* Implements sophisticated caching patterns:
* - Semantic cache keys with intelligent invalidation
* - Context-aware caching that understands equivalence
* - 80-90% token reduction through smart content compression
* - Proactive invalidation based on related changes
* - Multi-layer caching (memory, persistent, distributed)
*/
export declare const CacheConfigSchema: z.ZodObject<{
memory_cache: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
max_size_mb: z.ZodDefault<z.ZodNumber>;
ttl_seconds: z.ZodDefault<z.ZodNumber>;
max_entries: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
max_size_mb: number;
ttl_seconds: number;
max_entries: number;
}, {
enabled?: boolean | undefined;
max_size_mb?: number | undefined;
ttl_seconds?: number | undefined;
max_entries?: number | undefined;
}>;
persistent_cache: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
storage_path: z.ZodDefault<z.ZodString>;
ttl_seconds: z.ZodDefault<z.ZodNumber>;
compression: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
ttl_seconds: number;
storage_path: string;
compression: boolean;
}, {
enabled?: boolean | undefined;
ttl_seconds?: number | undefined;
storage_path?: string | undefined;
compression?: boolean | undefined;
}>;
semantic_caching: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
similarity_threshold: z.ZodDefault<z.ZodNumber>;
context_window: z.ZodDefault<z.ZodNumber>;
embedding_cache_size: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
context_window: number;
similarity_threshold: number;
embedding_cache_size: number;
}, {
enabled?: boolean | undefined;
context_window?: number | undefined;
similarity_threshold?: number | undefined;
embedding_cache_size?: number | undefined;
}>;
invalidation: z.ZodObject<{
enabled: z.ZodDefault<z.ZodBoolean>;
proactive: z.ZodDefault<z.ZodBoolean>;
batch_size: z.ZodDefault<z.ZodNumber>;
max_related_depth: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
enabled: boolean;
proactive: boolean;
batch_size: number;
max_related_depth: number;
}, {
enabled?: boolean | undefined;
proactive?: boolean | undefined;
batch_size?: number | undefined;
max_related_depth?: number | undefined;
}>;
}, "strip", z.ZodTypeAny, {
memory_cache: {
enabled: boolean;
max_size_mb: number;
ttl_seconds: number;
max_entries: number;
};
persistent_cache: {
enabled: boolean;
ttl_seconds: number;
storage_path: string;
compression: boolean;
};
semantic_caching: {
enabled: boolean;
context_window: number;
similarity_threshold: number;
embedding_cache_size: number;
};
invalidation: {
enabled: boolean;
proactive: boolean;
batch_size: number;
max_related_depth: number;
};
}, {
memory_cache: {
enabled?: boolean | undefined;
max_size_mb?: number | undefined;
ttl_seconds?: number | undefined;
max_entries?: number | undefined;
};
persistent_cache: {
enabled?: boolean | undefined;
ttl_seconds?: number | undefined;
storage_path?: string | undefined;
compression?: boolean | undefined;
};
semantic_caching: {
enabled?: boolean | undefined;
context_window?: number | undefined;
similarity_threshold?: number | undefined;
embedding_cache_size?: number | undefined;
};
invalidation: {
enabled?: boolean | undefined;
proactive?: boolean | undefined;
batch_size?: number | undefined;
max_related_depth?: number | undefined;
};
}>;
export type CacheConfig = z.infer<typeof CacheConfigSchema>;
export declare const CacheEntrySchema: z.ZodObject<{
key: z.ZodString;
value: z.ZodAny;
created_at: z.ZodDate;
last_accessed: z.ZodDate;
access_count: z.ZodDefault<z.ZodNumber>;
ttl_seconds: z.ZodNumber;
expires_at: z.ZodDate;
semantic_key: z.ZodOptional<z.ZodString>;
embedding: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
context_tokens: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
depends_on: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
invalidates: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
compression_ratio: z.ZodOptional<z.ZodNumber>;
token_reduction: z.ZodOptional<z.ZodNumber>;
generation_time_ms: z.ZodOptional<z.ZodNumber>;
content_type: z.ZodString;
content_size_bytes: z.ZodNumber;
hit_count: z.ZodDefault<z.ZodNumber>;
}, "strip", z.ZodTypeAny, {
depends_on: string[];
created_at: Date;
last_accessed: Date;
access_count: number;
key: string;
ttl_seconds: number;
expires_at: Date;
context_tokens: string[];
invalidates: string[];
content_type: string;
content_size_bytes: number;
hit_count: number;
value?: any;
embedding?: number[] | undefined;
semantic_key?: string | undefined;
compression_ratio?: number | undefined;
token_reduction?: number | undefined;
generation_time_ms?: number | undefined;
}, {
created_at: Date;
last_accessed: Date;
key: string;
ttl_seconds: number;
expires_at: Date;
content_type: string;
content_size_bytes: number;
value?: any;
depends_on?: string[] | undefined;
embedding?: number[] | undefined;
access_count?: number | undefined;
semantic_key?: string | undefined;
context_tokens?: string[] | undefined;
invalidates?: string[] | undefined;
compression_ratio?: number | undefined;
token_reduction?: number | undefined;
generation_time_ms?: number | undefined;
hit_count?: number | undefined;
}>;
export type CacheEntry = z.infer<typeof CacheEntrySchema>;
export declare const CacheStatsSchema: z.ZodObject<{
hits: z.ZodDefault<z.ZodNumber>;
misses: z.ZodDefault<z.ZodNumber>;
invalidations: z.ZodDefault<z.ZodNumber>;
avg_hit_time_ms: z.ZodDefault<z.ZodNumber>;
avg_miss_time_ms: z.ZodDefault<z.ZodNumber>;
token_savings: z.ZodDefault<z.ZodNumber>;
memory_usage_mb: z.ZodDefault<z.ZodNumber>;
entry_count: z.ZodDefault<z.ZodNumber>;
hit_rate: z.ZodDefault<z.ZodNumber>;
compression_effectiveness: z.ZodDefault<z.ZodNumber>;
last_reset: z.ZodDate;
}, "strip", z.ZodTypeAny, {
hits: number;
misses: number;
invalidations: number;
avg_hit_time_ms: number;
avg_miss_time_ms: number;
token_savings: number;
memory_usage_mb: number;
entry_count: number;
hit_rate: number;
compression_effectiveness: number;
last_reset: Date;
}, {
last_reset: Date;
hits?: number | undefined;
misses?: number | undefined;
invalidations?: number | undefined;
avg_hit_time_ms?: number | undefined;
avg_miss_time_ms?: number | undefined;
token_savings?: number | undefined;
memory_usage_mb?: number | undefined;
entry_count?: number | undefined;
hit_rate?: number | undefined;
compression_effectiveness?: number | undefined;
}>;
export type CacheStats = z.infer<typeof CacheStatsSchema>;
/**
* Intelligent Cache Manager with Semantic Understanding
*/
export declare class CacheManager {
private config;
private memoryCache;
private embeddingCache;
private stats;
private cleanupInterval?;
constructor(config?: Partial<CacheConfig>);
/**
* Generate semantic cache key with context awareness
*/
generateSemanticKey(content: string, context: {
workspace_id?: string;
project_id?: string;
agent_type?: string;
feature_type?: string;
tech_stack?: string[];
}): string;
/**
* Store item in cache with intelligent metadata
*/
set<T>(key: string, value: T, options?: {
ttl_seconds?: number;
content_type?: string;
depends_on?: string[];
invalidates?: string[];
semantic_context?: any;
embedding?: number[];
}): Promise<void>;
/**
* Retrieve item from cache with semantic fallback
*/
get<T>(key: string, semanticContext?: any): Promise<{
value: T;
hit_type: 'exact' | 'semantic' | 'miss';
} | null>;
/**
* Find semantic match using embedding similarity
*/
private findSemanticMatch;
/**
* Proactive cache invalidation based on relationships
*/
invalidate(keys: string | string[], reason?: 'expired' | 'manual' | 'dependency' | 'proactive'): Promise<void>;
/**
* Recursive key invalidation with dependency tracking
*/
private invalidateKey;
/**
* Smart content compression with token optimization
*/
private compressValue;
/**
* Decompress cached value
*/
private decompressValue;
/**
* Remove redundant data from objects
*/
private removeRedundantData;
/**
* Compress repetitive patterns
*/
private compressPatterns;
/**
* Normalize content for semantic comparison
*/
private normalizeContent;
/**
* Create context signature for semantic keys
*/
private createContextSignature;
/**
* Calculate cosine similarity between embeddings
*/
private calculateCosineSimilarity;
/**
* Update running average
*/
private updateAverage;
/**
* Enforce memory cache limits
*/
private enforceMemoryLimits;
/**
* Start periodic cleanup
*/
private startCleanupInterval;
/**
* Clean up expired entries
*/
private cleanupExpiredEntries;
/**
* Persist cache entry to disk (simplified implementation)
*/
private persistToDisk;
/**
* Load cache entry from disk (simplified implementation)
*/
private loadFromDisk;
/**
* Remove cache entry from disk (simplified implementation)
*/
private removeFromDisk;
/**
* Get cache statistics
*/
getStats(): CacheStats;
/**
* Get memory usage estimate
*/
private getMemoryUsage;
/**
* Clear all cache entries
*/
clear(): Promise<void>;
/**
* Shutdown cache manager
*/
shutdown(): void;
}
export declare const cacheManager: CacheManager;