ms365-mcp-server 1.1.16 → 1.1.18

package/dist/utils/intelligent-cache.js

@@ -0,0 +1,379 @@
+import { logger } from './api.js';
+export class IntelligentCache {
+    constructor(maxSize = 50 * 1024 * 1024, // 50MB default
+    maxEntries = 10000, defaultTTL = 5 * 60 * 1000 // 5 minutes default
+    ) {
+        this.cache = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            entries: 0,
+            size: 0,
+            hitRate: 0,
+            evictions: 0
+        };
+        this.maxSize = maxSize;
+        this.maxEntries = maxEntries;
+        this.defaultTTL = defaultTTL;
+        // Cleanup expired entries every minute
+        setInterval(() => this.cleanup(), 60000);
+    }
+    /**
+     * Get value from cache
+     */
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            this.updateHitRate();
+            return undefined;
+        }
+        // Check if entry is expired
+        if (this.isExpired(entry)) {
+            this.cache.delete(key);
+            this.stats.misses++;
+            this.stats.entries--;
+            this.stats.size -= entry.size;
+            this.updateHitRate();
+            return undefined;
+        }
+        // Update access statistics
+        entry.accessCount++;
+        entry.lastAccessed = Date.now();
+        this.stats.hits++;
+        this.updateHitRate();
+        return entry.value;
+    }
+    /**
+     * Set value in cache
+     */
+    set(key, value, options = {}) {
+        const now = Date.now();
+        const size = this.estimateSize(value);
+        const ttl = options.ttl || this.defaultTTL;
+        // Check if we need to evict entries
+        if (this.shouldEvict(size)) {
+            this.evictEntries(size);
+        }
+        // Create cache entry
+        const entry = {
+            key,
+            value,
+            timestamp: now,
+            accessCount: 1,
+            lastAccessed: now,
+            ttl,
+            size,
+            tags: options.tags || []
+        };
+        // Remove existing entry if it exists
+        if (this.cache.has(key)) {
+            const existingEntry = this.cache.get(key);
+            this.stats.size -= existingEntry.size;
+            this.stats.entries--;
+        }
+        // Add new entry
+        this.cache.set(key, entry);
+        this.stats.size += size;
+        this.stats.entries++;
+        return true;
+    }
+    /**
+     * Delete entry from cache
+     */
+    delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.cache.delete(key);
+            this.stats.size -= entry.size;
+            this.stats.entries--;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Clear cache by tags
+     */
+    clearByTags(tags) {
+        let cleared = 0;
+        for (const [key, entry] of this.cache) {
+            if (entry.tags.some(tag => tags.includes(tag))) {
+                this.cache.delete(key);
+                this.stats.size -= entry.size;
+                this.stats.entries--;
+                cleared++;
+            }
+        }
+        if (cleared > 0) {
+            logger.log(`🗑️ Cleared ${cleared} cache entries by tags: ${tags.join(', ')}`);
+        }
+        return cleared;
+    }
+    /**
+     * Clear all cache
+     */
+    clear() {
+        this.cache.clear();
+        this.stats.entries = 0;
+        this.stats.size = 0;
+        logger.log('🗑️ Cache cleared');
+    }
+    /**
+     * Get cache statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Get cache entries for debugging
+     */
+    getEntries() {
+        const now = Date.now();
+        return Array.from(this.cache.entries()).map(([key, entry]) => ({
+            key,
+            size: entry.size,
+            age: now - entry.timestamp,
+            accessCount: entry.accessCount,
+            tags: entry.tags
+        }));
+    }
+    /**
+     * Check if entry is expired
+     */
+    isExpired(entry) {
+        return Date.now() - entry.timestamp > entry.ttl;
+    }
+    /**
+     * Estimate size of object
+     */
+    estimateSize(obj) {
+        try {
+            return JSON.stringify(obj).length * 2; // Rough estimate (UTF-16)
+        }
+        catch {
+            return 1024; // Default size if can't stringify
+        }
+    }
+    /**
+     * Check if we should evict entries
+     */
+    shouldEvict(newEntrySize) {
+        return (this.stats.size + newEntrySize > this.maxSize ||
+            this.stats.entries >= this.maxEntries);
+    }
+    /**
+     * Evict entries using LRU strategy
+     */
+    evictEntries(spaceNeeded) {
+        const entries = Array.from(this.cache.entries());
+        // Sort by last accessed time (LRU)
+        entries.sort((a, b) => a[1].lastAccessed - b[1].lastAccessed);
+        let freedSpace = 0;
+        let evicted = 0;
+        for (const [key, entry] of entries) {
+            if (freedSpace >= spaceNeeded && this.stats.entries < this.maxEntries) {
+                break;
+            }
+            this.cache.delete(key);
+            freedSpace += entry.size;
+            this.stats.size -= entry.size;
+            this.stats.entries--;
+            evicted++;
+        }
+        this.stats.evictions += evicted;
+        if (evicted > 0) {
+            logger.log(`🗑️ Evicted ${evicted} cache entries (freed ${freedSpace} bytes)`);
+        }
+    }
+    /**
+     * Cleanup expired entries
+     */
+    cleanup() {
+        const now = Date.now();
+        let cleaned = 0;
+        for (const [key, entry] of this.cache) {
+            if (this.isExpired(entry)) {
+                this.cache.delete(key);
+                this.stats.size -= entry.size;
+                this.stats.entries--;
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            logger.log(`🧹 Cleaned up ${cleaned} expired cache entries`);
+        }
+    }
+    /**
+     * Update hit rate
+     */
+    updateHitRate() {
+        const total = this.stats.hits + this.stats.misses;
+        this.stats.hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+    }
+}
+export class MS365CacheManager {
+    constructor() {
+        // Different cache configurations for different data types
+        this.searchCache = new IntelligentCache(20 * 1024 * 1024, // 20MB for search results
+        5000, // 5000 entries max
+        10 * 60 * 1000 // 10 minutes TTL
+        );
+        this.emailCache = new IntelligentCache(30 * 1024 * 1024, // 30MB for email content
+        3000, // 3000 entries max
+        15 * 60 * 1000 // 15 minutes TTL
+        );
+        this.metadataCache = new IntelligentCache(10 * 1024 * 1024, // 10MB for metadata
+        10000, // 10000 entries max
+        30 * 60 * 1000 // 30 minutes TTL
+        );
+        this.attachmentCache = new IntelligentCache(100 * 1024 * 1024, // 100MB for attachments
+        1000, // 1000 entries max
+        60 * 60 * 1000 // 1 hour TTL
+        );
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new MS365CacheManager();
+        }
+        return this.instance;
+    }
+    /**
+     * Cache search results
+     */
+    cacheSearchResults(query, results, folder = 'inbox') {
+        const cacheKey = this.generateSearchKey(query, folder);
+        this.searchCache.set(cacheKey, results, {
+            ttl: 5 * 60 * 1000, // 5 minutes for search results
+            tags: ['search', folder],
+            priority: 'high'
+        });
+    }
+    /**
+     * Get cached search results
+     */
+    getCachedSearchResults(query, folder = 'inbox') {
+        const cacheKey = this.generateSearchKey(query, folder);
+        return this.searchCache.get(cacheKey);
+    }
+    /**
+     * Cache email content
+     */
+    cacheEmail(email) {
+        this.emailCache.set(email.id, email, {
+            ttl: 15 * 60 * 1000, // 15 minutes for email content
+            tags: ['email', email.from.address],
+            priority: 'medium'
+        });
+    }
+    /**
+     * Get cached email
+     */
+    getCachedEmail(emailId) {
+        return this.emailCache.get(emailId);
+    }
+    /**
+     * Cache email metadata
+     */
+    cacheEmailMetadata(emailId, metadata) {
+        this.metadataCache.set(`metadata:${emailId}`, metadata, {
+            ttl: 30 * 60 * 1000, // 30 minutes for metadata
+            tags: ['metadata'],
+            priority: 'low'
+        });
+    }
+    /**
+     * Get cached email metadata
+     */
+    getCachedEmailMetadata(emailId) {
+        return this.metadataCache.get(`metadata:${emailId}`);
+    }
+    /**
+     * Cache attachment data
+     */
+    cacheAttachment(messageId, attachmentId, attachmentData) {
+        const cacheKey = `attachment:${messageId}:${attachmentId}`;
+        this.attachmentCache.set(cacheKey, attachmentData, {
+            ttl: 60 * 60 * 1000, // 1 hour for attachments
+            tags: ['attachment', messageId],
+            priority: 'medium'
+        });
+    }
+    /**
+     * Get cached attachment
+     */
+    getCachedAttachment(messageId, attachmentId) {
+        const cacheKey = `attachment:${messageId}:${attachmentId}`;
+        return this.attachmentCache.get(cacheKey);
+    }
+    /**
+     * Invalidate caches when emails are modified
+     */
+    invalidateEmailCaches(emailId) {
+        this.emailCache.delete(emailId);
+        this.metadataCache.delete(`metadata:${emailId}`);
+        this.attachmentCache.clearByTags([emailId]);
+        this.searchCache.clearByTags(['search']); // Clear search cache as it might be outdated
+    }
+    /**
+     * Invalidate folder-specific caches
+     */
+    invalidateFolderCaches(folder) {
+        this.searchCache.clearByTags([folder]);
+    }
+    /**
+     * Get comprehensive cache statistics
+     */
+    getStats() {
+        const searchStats = this.searchCache.getStats();
+        const emailStats = this.emailCache.getStats();
+        const metadataStats = this.metadataCache.getStats();
+        const attachmentStats = this.attachmentCache.getStats();
+        const totalSize = searchStats.size + emailStats.size + metadataStats.size + attachmentStats.size;
+        const totalEntries = searchStats.entries + emailStats.entries + metadataStats.entries + attachmentStats.entries;
+        const totalHits = searchStats.hits + emailStats.hits + metadataStats.hits + attachmentStats.hits;
+        const totalMisses = searchStats.misses + emailStats.misses + metadataStats.misses + attachmentStats.misses;
+        const totalHitRate = totalHits + totalMisses > 0 ? (totalHits / (totalHits + totalMisses)) * 100 : 0;
+        return {
+            search: searchStats,
+            email: emailStats,
+            metadata: metadataStats,
+            attachment: attachmentStats,
+            total: {
+                size: totalSize,
+                entries: totalEntries,
+                hitRate: totalHitRate
+            }
+        };
+    }
+    /**
+     * Clear all caches
+     */
+    clearAll() {
+        this.searchCache.clear();
+        this.emailCache.clear();
+        this.metadataCache.clear();
+        this.attachmentCache.clear();
+        logger.log('🗑️ All caches cleared');
+    }
+    /**
+     * Generate cache key for search
+     */
+    generateSearchKey(query, folder) {
+        // Create a normalized cache key that's case-insensitive and handles variations
+        const normalizedQuery = query.toLowerCase().trim().replace(/\s+/g, ' ');
+        return `search:${folder}:${normalizedQuery}`;
+    }
+    /**
+     * Optimize cache performance
+     */
+    optimize() {
+        // Force cleanup of expired entries
+        this.searchCache['cleanup']();
+        this.emailCache['cleanup']();
+        this.metadataCache['cleanup']();
+        this.attachmentCache['cleanup']();
+        logger.log('🔧 Cache optimization completed');
+    }
+}
+// Export singleton instance
+export const ms365Cache = MS365CacheManager.getInstance();