claude-flow 2.0.0-alpha.60 → 2.0.0-alpha.62

package/dist/memory/advanced-memory-manager.js

@@ -37,7 +37,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             persistenceEnabled: true,
             compressionThreshold: 1024, // 1KB
             backupRetention: 7, // days
-            ...config
+            ...config,
         };
         // Setup file paths
         const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -56,7 +56,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             fs.mkdir(this.dataPath, { recursive: true }),
             fs.mkdir(this.indexPath, { recursive: true }),
             fs.mkdir(this.backupPath, { recursive: true }),
-            fs.mkdir(this.archivePath, { recursive: true })
+            fs.mkdir(this.archivePath, { recursive: true }),
         ]);
         // Load persisted data
         if (this.config.persistenceEnabled) {
@@ -112,7 +112,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 compressed: processedValue.compressed,
                 checksum: this.calculateChecksum(processedValue.value),
                 references: [],
-                dependencies: []
+                dependencies: [],
             };
             // Store entry
             this.entries.set(entryId, entry);
@@ -253,12 +253,12 @@ export class AdvancedMemoryManager extends EventEmitter {
                 candidateEntries = Array.from(this.entries.values());
             }
             // Apply filters
-            let filteredEntries = candidateEntries.filter(entry => {
+            let filteredEntries = candidateEntries.filter((entry) => {
                 return this.matchesQuery(entry, options);
             });
             // Remove expired entries
             if (!options.includeExpired) {
-                filteredEntries = filteredEntries.filter(entry => {
+                filteredEntries = filteredEntries.filter((entry) => {
                     if (entry.expiresAt && entry.expiresAt < new Date()) {
                         // Schedule for deletion
                         setTimeout(() => this.deleteEntry(entry.id), 0);
@@ -286,7 +286,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             const limit = options.limit || filteredEntries.length;
             const paginatedEntries = filteredEntries.slice(offset, offset + limit);
             // Update last accessed times
-            paginatedEntries.forEach(entry => {
+            paginatedEntries.forEach((entry) => {
                 entry.lastAccessedAt = new Date();
             });
             // Generate aggregations if requested
@@ -298,7 +298,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             return {
                 entries: paginatedEntries,
                 total,
-                aggregations
+                aggregations,
             };
         }
         catch (error) {
@@ -352,18 +352,18 @@ export class AdvancedMemoryManager extends EventEmitter {
             this.logger.info('Memory export completed', {
                 entriesExported: entries.length,
                 fileSize: stats.size,
-                checksum
+                checksum,
             });
             this.emit('memory:exported', {
                 filePath,
                 entriesExported: entries.length,
-                fileSize: stats.size
+                fileSize: stats.size,
             });
             this.recordMetric('export', Date.now() - startTime);
             return {
                 entriesExported: entries.length,
                 fileSize: stats.size,
-                checksum
+                checksum,
             };
         }
         catch (error) {
@@ -408,7 +408,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 entriesImported: 0,
                 entriesSkipped: 0,
                 entriesUpdated: 0,
-                conflicts: []
+                conflicts: [],
             };
             for (const item of importData) {
                 if (options.dryRun) {
@@ -437,7 +437,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                     }
                 }
                 catch (error) {
-                    results.conflicts.push(`Error importing '${item.key}': ${(error instanceof Error ? error.message : String(error))}`);
+                    results.conflicts.push(`Error importing '${item.key}': ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
             this.logger.info('Memory import completed', results);
@@ -473,14 +473,14 @@ export class AdvancedMemoryManager extends EventEmitter {
                 entriesArchived: 0,
                 entriesCompressed: 0,
                 spaceSaved: 0,
-                actions: []
+                actions: [],
             };
             // Get all entries for processing
             const allEntries = Array.from(this.entries.values());
             const now = new Date();
             // Phase 1: Remove expired entries
             if (options.removeExpired !== false) {
-                const expiredEntries = allEntries.filter(entry => entry.expiresAt && entry.expiresAt < now);
+                const expiredEntries = allEntries.filter((entry) => entry.expiresAt && entry.expiresAt < now);
                 for (const entry of expiredEntries) {
                     if (!options.dryRun) {
                         await this.deleteEntry(entry.id);
@@ -494,8 +494,8 @@ export class AdvancedMemoryManager extends EventEmitter {
             }
             // Phase 2: Remove old entries
             if (options.removeOlderThan) {
-                const cutoffDate = new Date(now.getTime() - (options.removeOlderThan * 24 * 60 * 60 * 1000));
-                const oldEntries = allEntries.filter(entry => entry.createdAt < cutoffDate);
+                const cutoffDate = new Date(now.getTime() - options.removeOlderThan * 24 * 60 * 60 * 1000);
+                const oldEntries = allEntries.filter((entry) => entry.createdAt < cutoffDate);
                 for (const entry of oldEntries) {
                     if (!options.dryRun) {
                         await this.deleteEntry(entry.id);
@@ -509,8 +509,8 @@ export class AdvancedMemoryManager extends EventEmitter {
             }
             // Phase 3: Remove unaccessed entries
             if (options.removeUnaccessed) {
-                const cutoffDate = new Date(now.getTime() - (options.removeUnaccessed * 24 * 60 * 60 * 1000));
-                const unaccessedEntries = allEntries.filter(entry => entry.lastAccessedAt < cutoffDate);
+                const cutoffDate = new Date(now.getTime() - options.removeUnaccessed * 24 * 60 * 60 * 1000);
+                const unaccessedEntries = allEntries.filter((entry) => entry.lastAccessedAt < cutoffDate);
                 for (const entry of unaccessedEntries) {
                     if (!options.dryRun) {
                         await this.deleteEntry(entry.id);
@@ -524,10 +524,8 @@ export class AdvancedMemoryManager extends EventEmitter {
             }
             // Phase 4: Archive old entries
             if (options.archiveOld?.enabled) {
-                const cutoffDate = new Date(now.getTime() - (options.archiveOld.olderThan * 24 * 60 * 60 * 1000));
-                const archiveEntries = allEntries.filter(entry => entry.createdAt < cutoffDate &&
-                    !entry.expiresAt // Don't archive entries that will expire
-                );
+                const cutoffDate = new Date(now.getTime() - options.archiveOld.olderThan * 24 * 60 * 60 * 1000);
+                const archiveEntries = allEntries.filter((entry) => entry.createdAt < cutoffDate && !entry.expiresAt);
                 if (archiveEntries.length > 0 && !options.dryRun) {
                     await this.archiveEntries(archiveEntries, options.archiveOld.archivePath);
                 }
@@ -538,7 +536,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             }
             // Phase 5: Compress eligible entries
             if (options.compressEligible !== false && this.config.autoCompress) {
-                const uncompressedEntries = allEntries.filter(entry => !entry.compressed && entry.size > this.config.compressionThreshold);
+                const uncompressedEntries = allEntries.filter((entry) => !entry.compressed && entry.size > this.config.compressionThreshold);
                 for (const entry of uncompressedEntries) {
                     if (!options.dryRun) {
                         const originalSize = entry.size;
@@ -582,7 +580,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 }
             }
             // Rebuild index if significant changes
-            if ((results.entriesRemoved + results.entriesArchived) > 100 && !options.dryRun) {
+            if (results.entriesRemoved + results.entriesArchived > 100 && !options.dryRun) {
                 await this.rebuildIndex();
                 results.actions.push('Rebuilt search index');
             }
@@ -604,14 +602,15 @@ export class AdvancedMemoryManager extends EventEmitter {
             types: new Map(),
             namespaces: new Map(),
             owners: new Map(),
-            fullText: new Map()
+            fullText: new Map(),
         };
     }
     async processValue(value, compress) {
         let processedValue = value;
         let isCompressed = false;
         // Auto-compress if enabled and value is large enough
-        if ((compress || this.config.autoCompress) && this.calculateSize(value) > this.config.compressionThreshold) {
+        if ((compress || this.config.autoCompress) &&
+            this.calculateSize(value) > this.config.compressionThreshold) {
             processedValue = await this.compressValue(value);
             isCompressed = true;
         }
@@ -659,24 +658,24 @@ export class AdvancedMemoryManager extends EventEmitter {
         if (operation === 'delete') {
             // Remove from all indices
             this.removeFromIndex(this.index.keys, key, id);
-            tags.forEach(tag => this.removeFromIndex(this.index.tags, tag, id));
+            tags.forEach((tag) => this.removeFromIndex(this.index.tags, tag, id));
             this.removeFromIndex(this.index.types, type, id);
             this.removeFromIndex(this.index.namespaces, namespace, id);
             this.removeFromIndex(this.index.owners, owner, id);
             // Remove from full-text index
             const words = this.extractWords(value);
-            words.forEach(word => this.removeFromIndex(this.index.fullText, word, id));
+            words.forEach((word) => this.removeFromIndex(this.index.fullText, word, id));
         }
         else {
             // Add to indices
             this.addToIndex(this.index.keys, key, id);
-            tags.forEach(tag => this.addToIndex(this.index.tags, tag, id));
+            tags.forEach((tag) => this.addToIndex(this.index.tags, tag, id));
             this.addToIndex(this.index.types, type, id);
             this.addToIndex(this.index.namespaces, namespace, id);
             this.addToIndex(this.index.owners, owner, id);
             // Add to full-text index
             const words = this.extractWords(value);
-            words.forEach(word => this.addToIndex(this.index.fullText, word, id));
+            words.forEach((word) => this.addToIndex(this.index.fullText, word, id));
         }
     }
     addToIndex(indexMap, key, entryId) {
@@ -702,10 +701,11 @@ export class AdvancedMemoryManager extends EventEmitter {
     }
     extractWords(value) {
         const text = typeof value === 'string' ? value : JSON.stringify(value);
-        return text.toLowerCase()
+        return text
+            .toLowerCase()
             .replace(/[^\w\s]/g, ' ')
             .split(/\s+/)
-            .filter(word => word.length > 2);
+            .filter((word) => word.length > 2);
     }
     updateCache(key, entry) {
         if (this.cache.size >= this.config.cacheSize) {
@@ -713,7 +713,7 @@ export class AdvancedMemoryManager extends EventEmitter {
         }
         this.cache.set(key, {
             entry: { ...entry },
-            expiry: Date.now() + this.config.cacheTtl
+            expiry: Date.now() + this.config.cacheTtl,
         });
     }
     evictCache() {
@@ -737,41 +737,41 @@ export class AdvancedMemoryManager extends EventEmitter {
                 compressionRatio: 0,
                 indexSize: 0,
                 memoryUsage: 0,
-                diskUsage: 0
+                diskUsage: 0,
             },
             distribution: {
                 byNamespace: {},
                 byType: {},
                 byOwner: {},
-                byAccessLevel: {}
+                byAccessLevel: {},
             },
             temporal: {
                 entriesCreatedLast24h: 0,
                 entriesUpdatedLast24h: 0,
-                entriesAccessedLast24h: 0
+                entriesAccessedLast24h: 0,
             },
             performance: {
                 averageQueryTime: 0,
                 averageWriteTime: 0,
                 cacheHitRatio: 0,
-                indexEfficiency: 0
+                indexEfficiency: 0,
             },
             health: {
                 expiredEntries: 0,
                 orphanedReferences: 0,
                 duplicateKeys: 0,
                 corruptedEntries: 0,
-                recommendedCleanup: false
+                recommendedCleanup: false,
             },
             optimization: {
                 suggestions: [],
                 potentialSavings: {
                     compression: 0,
                     cleanup: 0,
-                    deduplication: 0
+                    deduplication: 0,
                 },
-                indexOptimization: []
-            }
+                indexOptimization: [],
+            },
         };
     }
     // === COMPLEX IMPLEMENTATION METHODS ===
@@ -791,7 +791,7 @@ export class AdvancedMemoryManager extends EventEmitter {
         if (options.accessLevel && entry.accessLevel !== options.accessLevel)
             return false;
         if (options.tags && options.tags.length > 0) {
-            const hasAllTags = options.tags.every(tag => entry.tags.includes(tag));
+            const hasAllTags = options.tags.every((tag) => entry.tags.includes(tag));
             if (!hasAllTags)
                 return false;
         }
@@ -823,13 +823,20 @@ export class AdvancedMemoryManager extends EventEmitter {
     }
     getPropertyValue(entry, property) {
         switch (property) {
-            case 'key': return entry.key;
-            case 'createdAt': return entry.createdAt.getTime();
-            case 'updatedAt': return entry.updatedAt.getTime();
-            case 'lastAccessedAt': return entry.lastAccessedAt.getTime();
-            case 'size': return entry.size;
-            case 'type': return entry.type;
-            default: return entry.key;
+            case 'key':
+                return entry.key;
+            case 'createdAt':
+                return entry.createdAt.getTime();
+            case 'updatedAt':
+                return entry.updatedAt.getTime();
+            case 'lastAccessedAt':
+                return entry.lastAccessedAt.getTime();
+            case 'size':
+                return entry.size;
+            case 'type':
+                return entry.type;
+            default:
+                return entry.key;
         }
     }
     generateAggregations(entries, aggregateBy) {
@@ -882,31 +889,31 @@ export class AdvancedMemoryManager extends EventEmitter {
                 exportedAt: new Date().toISOString(),
                 version: '1.0',
                 totalEntries: entries.length,
-                format: 'json'
+                format: 'json',
             },
             entries: options.includeMetadata
                 ? entries
-                : entries.map(entry => ({
+                : entries.map((entry) => ({
                     key: entry.key,
                     value: entry.value,
                     type: entry.type,
                     namespace: entry.namespace,
-                    tags: entry.tags
-                }))
+                    tags: entry.tags,
+                })),
         };
         return JSON.stringify(exportData, null, 2);
     }
     prepareCsvExport(entries, options) {
         // CSV export implementation
         const headers = ['key', 'value', 'type', 'namespace', 'tags'];
-        const rows = entries.map(entry => [
+        const rows = entries.map((entry) => [
             entry.key,
             JSON.stringify(entry.value),
             entry.type,
             entry.namespace,
-            entry.tags.join(';')
+            entry.tags.join(';'),
         ]);
-        return [headers, ...rows].map(row => row.join(',')).join('\n');
+        return [headers, ...rows].map((row) => row.join(',')).join('\n');
     }
     prepareXmlExport(entries, options) {
         // XML export implementation
@@ -931,7 +938,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             yaml += `    value: ${JSON.stringify(entry.value)}\n`;
             yaml += `    type: "${entry.type}"\n`;
             yaml += `    namespace: "${entry.namespace}"\n`;
-            yaml += `    tags: [${entry.tags.map(t => `"${t}"`).join(', ')}]\n`;
+            yaml += `    tags: [${entry.tags.map((t) => `"${t}"`).join(', ')}]\n`;
         }
         return yaml;
     }
@@ -971,12 +978,12 @@ export class AdvancedMemoryManager extends EventEmitter {
         throw new Error('YAML import not implemented in this example');
     }
     validateImportData(data) {
-        return data.filter(item => {
+        return data.filter((item) => {
             return item.key && item.value !== undefined;
         });
     }
     transformImportData(data, transformation) {
-        return data.map(item => {
+        return data.map((item) => {
             const transformed = { ...item };
             // Apply key mapping
             if (transformation.keyMapping) {
@@ -1010,7 +1017,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 case 'merge':
                     await this.update(item.key, item.value, {
                         namespace: item.namespace,
-                        merge: true
+                        merge: true,
                     });
                     return { action: 'updated' };
                 case 'rename':
@@ -1019,13 +1026,13 @@ export class AdvancedMemoryManager extends EventEmitter {
                         namespace: item.namespace,
                         type: item.type,
                         tags: item.tags,
-                        metadata: item.metadata
+                        metadata: item.metadata,
                     });
                     return { action: 'imported' };
                 default:
                     return {
                         action: 'conflict',
-                        message: `Key '${item.key}' already exists`
+                        message: `Key '${item.key}' already exists`,
                     };
             }
         }
@@ -1034,7 +1041,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 namespace: item.namespace || options.namespace,
                 type: item.type,
                 tags: item.tags,
-                metadata: item.metadata
+                metadata: item.metadata,
             });
             return { action: 'imported' };
         }
@@ -1043,41 +1050,45 @@ export class AdvancedMemoryManager extends EventEmitter {
     calculateStatistics() {
         const entries = Array.from(this.entries.values());
         const now = new Date();
-        const last24h = new Date(now.getTime() - (24 * 60 * 60 * 1000));
+        const last24h = new Date(now.getTime() - 24 * 60 * 60 * 1000);
         const stats = {
             overview: {
                 totalEntries: entries.length,
                 totalSize: entries.reduce((sum, entry) => sum + entry.size, 0),
-                compressedEntries: entries.filter(entry => entry.compressed).length,
+                compressedEntries: entries.filter((entry) => entry.compressed).length,
                 compressionRatio: 0,
                 indexSize: this.calculateIndexSize(),
                 memoryUsage: process.memoryUsage().heapUsed,
-                diskUsage: 0 // Would be calculated from actual file system
+                diskUsage: 0, // Would be calculated from actual file system
             },
             distribution: {
                 byNamespace: this.calculateDistribution(entries, 'namespace'),
                 byType: this.calculateDistribution(entries, 'type'),
                 byOwner: this.calculateDistribution(entries, 'owner'),
-                byAccessLevel: this.calculateDistribution(entries, 'accessLevel')
+                byAccessLevel: this.calculateDistribution(entries, 'accessLevel'),
             },
             temporal: {
-                entriesCreatedLast24h: entries.filter(e => e.createdAt >= last24h).length,
-                entriesUpdatedLast24h: entries.filter(e => e.updatedAt >= last24h).length,
-                entriesAccessedLast24h: entries.filter(e => e.lastAccessedAt >= last24h).length,
-                oldestEntry: entries.length > 0 ?
-                    entries.reduce((oldest, entry) => entry.createdAt < oldest.createdAt ? entry : oldest).createdAt : undefined,
-                newestEntry: entries.length > 0 ?
-                    entries.reduce((newest, entry) => entry.createdAt > newest.createdAt ? entry : newest).createdAt : undefined
+                entriesCreatedLast24h: entries.filter((e) => e.createdAt >= last24h).length,
+                entriesUpdatedLast24h: entries.filter((e) => e.updatedAt >= last24h).length,
+                entriesAccessedLast24h: entries.filter((e) => e.lastAccessedAt >= last24h).length,
+                oldestEntry: entries.length > 0
+                    ? entries.reduce((oldest, entry) => entry.createdAt < oldest.createdAt ? entry : oldest).createdAt
+                    : undefined,
+                newestEntry: entries.length > 0
+                    ? entries.reduce((newest, entry) => entry.createdAt > newest.createdAt ? entry : newest).createdAt
+                    : undefined,
             },
             performance: this.calculatePerformanceMetrics(),
             health: this.calculateHealthMetrics(entries, now),
-            optimization: this.generateOptimizationSuggestions(entries)
+            optimization: this.generateOptimizationSuggestions(entries),
         };
         // Calculate compression ratio
-        const uncompressedSize = entries.filter(e => !e.compressed).reduce((sum, e) => sum + e.size, 0);
-        const compressedSize = entries.filter(e => e.compressed).reduce((sum, e) => sum + e.size, 0);
-        stats.overview.compressionRatio = uncompressedSize > 0 ?
-            (uncompressedSize - compressedSize) / uncompressedSize : 0;
+        const uncompressedSize = entries
+            .filter((e) => !e.compressed)
+            .reduce((sum, e) => sum + e.size, 0);
+        const compressedSize = entries.filter((e) => e.compressed).reduce((sum, e) => sum + e.size, 0);
+        stats.overview.compressionRatio =
+            uncompressedSize > 0 ? (uncompressedSize - compressedSize) / uncompressedSize : 0;
         return stats;
     }
     calculateDistribution(entries, property) {
@@ -1108,32 +1119,32 @@ export class AdvancedMemoryManager extends EventEmitter {
             averageQueryTime: queryMetrics.count > 0 ? queryMetrics.totalTime / queryMetrics.count : 0,
             averageWriteTime: writeMetrics.count > 0 ? writeMetrics.totalTime / writeMetrics.count : 0,
             cacheHitRatio: totalRetrieves > 0 ? cacheMetrics.count / totalRetrieves : 0,
-            indexEfficiency: this.config.indexingEnabled ? 0.95 : 0 // Placeholder
+            indexEfficiency: this.config.indexingEnabled ? 0.95 : 0, // Placeholder
         };
     }
     calculateHealthMetrics(entries, now) {
-        const expiredEntries = entries.filter(e => e.expiresAt && e.expiresAt < now).length;
+        const expiredEntries = entries.filter((e) => e.expiresAt && e.expiresAt < now).length;
         const duplicateKeys = this.findDuplicateKeys(entries);
         return {
             expiredEntries,
             orphanedReferences: 0, // Would be calculated by checking references
             duplicateKeys: duplicateKeys.length,
             corruptedEntries: 0, // Would be calculated by validating checksums
-            recommendedCleanup: expiredEntries > 10 || duplicateKeys.length > 5
+            recommendedCleanup: expiredEntries > 10 || duplicateKeys.length > 5,
         };
     }
     generateOptimizationSuggestions(entries) {
         const suggestions = [];
         const potentialSavings = { compression: 0, cleanup: 0, deduplication: 0 };
         // Compression suggestions
-        const uncompressedLarge = entries.filter(e => !e.compressed && e.size > this.config.compressionThreshold);
+        const uncompressedLarge = entries.filter((e) => !e.compressed && e.size > this.config.compressionThreshold);
         if (uncompressedLarge.length > 0) {
             suggestions.push(`${uncompressedLarge.length} entries could benefit from compression`);
             potentialSavings.compression = uncompressedLarge.reduce((sum, e) => sum + e.size * 0.6, 0);
         }
         // Cleanup suggestions
         const now = new Date();
-        const oldEntries = entries.filter(e => now.getTime() - e.lastAccessedAt.getTime() > (30 * 24 * 60 * 60 * 1000));
+        const oldEntries = entries.filter((e) => now.getTime() - e.lastAccessedAt.getTime() > 30 * 24 * 60 * 60 * 1000);
         if (oldEntries.length > 0) {
             suggestions.push(`${oldEntries.length} entries haven't been accessed in 30+ days`);
             potentialSavings.cleanup = oldEntries.reduce((sum, e) => sum + e.size, 0);
@@ -1147,9 +1158,9 @@ export class AdvancedMemoryManager extends EventEmitter {
         return {
             suggestions,
             potentialSavings,
-            indexOptimization: this.config.indexingEnabled ?
-                ['Consider periodic index rebuilding for optimal performance'] :
-                ['Enable indexing for better query performance']
+            indexOptimization: this.config.indexingEnabled
+                ? ['Consider periodic index rebuilding for optimal performance']
+                : ['Enable indexing for better query performance'],
         };
     }
     findDuplicateKeys(entries) {
@@ -1184,7 +1195,7 @@ export class AdvancedMemoryManager extends EventEmitter {
             return false;
         if (policy.type && entry.type !== policy.type)
             return false;
-        if (policy.tags && !policy.tags.every(tag => entry.tags.includes(tag)))
+        if (policy.tags && !policy.tags.every((tag) => entry.tags.includes(tag)))
             return false;
         return true;
     }
@@ -1202,7 +1213,7 @@ export class AdvancedMemoryManager extends EventEmitter {
         // This is a simplified implementation
     }
     async applyRetentionPolicy(policy, dryRun) {
-        const matchingEntries = Array.from(this.entries.values()).filter(entry => {
+        const matchingEntries = Array.from(this.entries.values()).filter((entry) => {
             if (policy.namespace && entry.namespace !== policy.namespace)
                 return false;
             return true;
@@ -1211,8 +1222,8 @@ export class AdvancedMemoryManager extends EventEmitter {
         const now = new Date();
         // Apply age limit
         if (policy.maxAge) {
-            const cutoffDate = new Date(now.getTime() - (policy.maxAge * 24 * 60 * 60 * 1000));
-            toRemove = matchingEntries.filter(entry => entry.createdAt < cutoffDate);
+            const cutoffDate = new Date(now.getTime() - policy.maxAge * 24 * 60 * 60 * 1000);
+            toRemove = matchingEntries.filter((entry) => entry.createdAt < cutoffDate);
         }
         // Apply count limit
         if (policy.maxCount && matchingEntries.length > policy.maxCount) {
@@ -1267,7 +1278,7 @@ export class AdvancedMemoryManager extends EventEmitter {
     async archiveEntries(entries, archivePath) {
         const archiveData = {
             archivedAt: new Date().toISOString(),
-            entries: entries
+            entries: entries,
         };
         const archiveFile = join(archivePath, `archive-${Date.now()}.json`);
         await fs.mkdir(dirname(archiveFile), { recursive: true });
@@ -1291,7 +1302,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 await this.cleanup({
                     removeExpired: true,
                     removeUnaccessed: 7, // Remove entries not accessed in 7 days
-                    compressEligible: true
+                    compressEligible: true,
                 });
             }
             catch (error) {
@@ -1352,7 +1363,7 @@ export class AdvancedMemoryManager extends EventEmitter {
                 timestamp: new Date().toISOString(),
                 version: '1.0',
                 entries: Array.from(this.entries.values()),
-                statistics: await this.getStatistics()
+                statistics: await this.getStatistics(),
             };
             await fs.writeFile(backupFile, JSON.stringify(backup, null, 2));
             this.logger.info(`Created backup: ${backupFile}`);
@@ -1366,14 +1377,14 @@ export class AdvancedMemoryManager extends EventEmitter {
     async cleanOldBackups() {
         try {
             const files = await fs.readdir(this.backupPath);
-            const backupFiles = files.filter(f => f.startsWith('backup-') && f.endsWith('.json'));
+            const backupFiles = files.filter((f) => f.startsWith('backup-') && f.endsWith('.json'));
             if (backupFiles.length <= this.config.backupRetention) {
                 return;
             }
             // Sort by creation time and remove oldest
             const fileStats = await Promise.all(backupFiles.map(async (file) => ({
                 file,
-                stat: await fs.stat(join(this.backupPath, file))
+                stat: await fs.stat(join(this.backupPath, file)),
             })));
             fileStats.sort((a, b) => a.stat.mtime.getTime() - b.stat.mtime.getTime());
             const toDelete = fileStats.slice(0, fileStats.length - this.config.backupRetention);
@@ -1413,7 +1424,7 @@ export class AdvancedMemoryManager extends EventEmitter {
     async listTags() {
         const tags = new Set();
         for (const entry of this.entries.values()) {
-            entry.tags.forEach(tag => tags.add(tag));
+            entry.tags.forEach((tag) => tags.add(tag));
         }
         return Array.from(tags).sort();
     }
@@ -1429,9 +1440,7 @@ export class AdvancedMemoryManager extends EventEmitter {
     }
     async clear(namespace) {
         const entries = Array.from(this.entries.values());
-        const toDelete = namespace
-            ? entries.filter(entry => entry.namespace === namespace)
-            : entries;
+        const toDelete = namespace ? entries.filter((entry) => entry.namespace === namespace) : entries;
         for (const entry of toDelete) {
             await this.deleteEntry(entry.id);
         }