@dollhousemcp/mcp-server 1.8.0 → 1.9.0

package/dist/elements/memories/Memory.js

@@ -0,0 +1,627 @@
+/**
+ * Memory Element - Persistent context storage for continuity and learning
+ *
+ * Provides multiple storage backends, retention policies, and search capabilities
+ * for maintaining context across sessions and interactions.
+ *
+ * SECURITY MEASURES IMPLEMENTED:
+ * 1. Input sanitization for all memory content
+ * 2. Memory size limits to prevent unbounded growth
+ * 3. Path validation for file-based storage
+ * 4. Retention policy enforcement
+ * 5. Privacy level access control
+ * 6. Audit logging for all operations
+ */
+import { BaseElement } from '../BaseElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import crypto from 'crypto';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';
+import { generateMemoryId } from './utils.js';
+import { MemorySearchIndex } from './MemorySearchIndex.js';
+import { logger } from '../../utils/logger.js';
+import DOMPurify from 'dompurify';
+import { JSDOM } from 'jsdom';
+// Initialize DOMPurify with JSDOM
+const window = new JSDOM('').window;
+const purify = DOMPurify(window);
+// Configure DOMPurify for memory content - strip all HTML but keep text
+purify.setConfig({
+    ALLOWED_TAGS: [], // No HTML tags allowed
+    ALLOWED_ATTR: [], // No attributes allowed
+    KEEP_CONTENT: true // Keep text content
+});
+/**
+ * Sanitize content for memory storage
+ * More permissive than sanitizeInput - allows punctuation, quotes, etc.
+ * but still prevents XSS and control characters
+ */
+function sanitizeMemoryContent(content, maxLength) {
+    if (!content || typeof content !== 'string') {
+        return '';
+    }
+    // First normalize Unicode
+    const normalized = UnicodeValidator.normalize(content).normalizedContent;
+    // Use DOMPurify to strip any HTML/XSS attempts but keep text
+    const cleaned = purify.sanitize(normalized);
+    // Remove only control characters and null bytes
+    return cleaned
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '') // Remove control chars except \t \n \r
+        .substring(0, maxLength)
+        .trim();
+}
+/**
+ * Memory Element Implementation
+ *
+ * TODO: Memory Sharding Strategy (Issue #981)
+ * ---------------------------------------------
+ * Current: Single Map<id, entry> for all memories
+ * Problem: Large memory sets (>10K entries) cause performance degradation
+ *
+ * Planned Sharding Architecture:
+ * 1. Shard memories across multiple files based on hash(memoryId) % shardCount
+ * 2. Each shard file <256KB for optimal YAML parsing
+ * 3. Memory references stored separately from content (like git objects)
+ * 4. Large binary content (PDFs, images) stored as external references
+ *
+ * Benefits:
+ * - Parallel loading of memory shards
+ * - Reduced memory footprint (load only needed shards)
+ * - Better corruption resistance (one shard failure doesn't affect others)
+ * - Efficient incremental updates
+ *
+ * TODO: Content Integrity Verification (Issue #982)
+ * --------------------------------------------------
+ * Add SHA-256 hashes to detect:
+ * - Accidental corruption from disk errors
+ * - Intentional tampering with memory files
+ * - Version conflicts during concurrent access
+ *
+ * Implementation:
+ * - Store hash in memory metadata
+ * - Verify on load, warn on mismatch
+ * - Option to auto-restore from backup on corruption
+ *
+ * TODO: Memory Capacity Management (Issue #983)
+ * ---------------------------------------------
+ * Current: Synchronous retention enforcement on each add
+ * Better: Background cleanup with smart triggers:
+ * - Cleanup when 90% capacity reached
+ * - Batch deletions for efficiency
+ * - LRU eviction with access tracking
+ * - Preserve "pinned" memories regardless of age
+ */
+export class Memory extends BaseElement {
+    // Memory-specific properties
+    entries = new Map();
+    storageBackend;
+    retentionDays;
+    privacyLevel;
+    searchable;
+    maxEntries;
+    // Search index for performance (Issue #984)
+    searchIndex;
+    // Sanitization cache to avoid redundant processing
+    sanitizationCache = new Map();
+    constructor(metadata = {}) {
+        // SECURITY FIX: Sanitize all inputs during construction
+        const sanitizedMetadata = {
+            ...metadata,
+            name: metadata.name ?
+                sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) :
+                'Unnamed Memory',
+            description: metadata.description ?
+                sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) :
+                undefined
+        };
+        super(ElementType.MEMORY, sanitizedMetadata);
+        // Initialize memory-specific properties with defaults
+        this.storageBackend = metadata.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND;
+        this.retentionDays = metadata.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS;
+        // Validate privacy level - default to private if invalid
+        this.privacyLevel = (metadata.privacyLevel && MEMORY_CONSTANTS.PRIVACY_LEVELS.includes(metadata.privacyLevel))
+            ? metadata.privacyLevel
+            : MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;
+        this.searchable = metadata.searchable !== false;
+        this.maxEntries = Math.min(metadata.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT, MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT);
+        // Set up extensions
+        this.extensions = {
+            storageBackend: this.storageBackend,
+            retentionDays: this.retentionDays,
+            privacyLevel: this.privacyLevel,
+            searchable: this.searchable,
+            maxEntries: this.maxEntries,
+            encryptionEnabled: metadata.encryptionEnabled || false
+        };
+        // Initialize search index with configuration (Issue #984)
+        const indexConfig = {
+            indexThreshold: metadata.indexThreshold || 100,
+            enableContentIndex: metadata.enableContentIndex !== false,
+            maxTermsPerEntry: metadata.maxTermsPerEntry || 100,
+            minTermLength: metadata.minTermLength || 2,
+            enablePersistence: false // Future enhancement
+        };
+        this.searchIndex = new MemorySearchIndex(indexConfig);
+        // Log memory creation
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_CREATED,
+            severity: 'LOW',
+            source: 'Memory.constructor',
+            details: `Memory created: ${this.metadata.name} with ${this.storageBackend} backend`
+        });
+    }
+    /**
+     * Add a new memory entry
+     * SECURITY: Validates and sanitizes all input, enforces size limits
+     */
+    async addEntry(content, tags, metadata) {
+        // Validate memory size limits
+        if (this.entries.size >= this.maxEntries) {
+            // SECURITY FIX: Enforce retention policy when at capacity
+            await this.enforceRetentionPolicy();
+            // If still at capacity after retention, remove oldest to make room
+            if (this.entries.size >= this.maxEntries) {
+                const oldestEntry = Array.from(this.entries.values())
+                    .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())[0];
+                if (oldestEntry) {
+                    this.entries.delete(oldestEntry.id);
+                }
+            }
+        }
+        // SECURITY FIX: Validate and sanitize content
+        const sanitizedContent = sanitizeMemoryContent(content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);
+        if (!sanitizedContent || sanitizedContent.trim().length === 0) {
+            throw new Error('Memory content cannot be empty');
+        }
+        // SECURITY FIX: Validate and sanitize tags
+        const sanitizedTags = tags ? this.sanitizeTags(tags) : [];
+        // Create memory entry with generated ID
+        const entry = {
+            id: generateMemoryId(),
+            timestamp: new Date(),
+            content: sanitizedContent,
+            tags: sanitizedTags,
+            metadata: this.sanitizeMetadata(metadata),
+            privacyLevel: this.privacyLevel,
+            expiresAt: this.calculateExpiryDate()
+        };
+        // Store entry
+        this.entries.set(entry.id, entry);
+        this._isDirty = true;
+        // Update search index (Issue #984)
+        this.searchIndex.addEntry(entry);
+        // Check if we should build/rebuild the index
+        if (!this.searchIndex.isIndexed && this.entries.size >= 100) {
+            // Build index asynchronously to avoid blocking, with retry logic
+            this.buildSearchIndexWithRetry().catch(error => {
+                // Final failure after retries - search will fall back to linear scan
+                logger.error('Failed to build search index after retries, search will use fallback', error);
+            });
+        }
+        // Log memory addition
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_ADDED,
+            severity: 'LOW',
+            source: 'Memory.addEntry',
+            details: `Added memory entry ${entry.id} with ${sanitizedTags.length} tags`
+        });
+        return entry;
+    }
+    /**
+     * Search memory entries
+     * SECURITY: Respects privacy levels and sanitizes search queries
+     *
+     * IMPLEMENTED: Basic indexed search for O(log n) performance (Issue #984)
+     * - Tag index: Map<tag, Set<entryId>> for instant tag lookups ✓
+     * - Content index: Inverted index for term search ✓
+     * - Date index: Binary tree for efficient range queries ✓
+     * - Privacy index: Pre-sorted entries by privacy level ✓
+     *
+     * TODO: Advanced indexing features (Future enhancements):
+     * - Composite indices: Combined indices for common query patterns
+     * - Index-of-indexes pattern:
+     *   - Master index file (meta.yaml) with pointers to shard indices
+     *   - Each shard maintains its own local index
+     *   - Periodic index compaction and optimization
+     * - Persistent index storage to disk
+     * - Incremental index updates for large datasets
+     *
+     * Performance improvement achieved:
+     * - Previous: ~100ms for 10,000 entries (linear scan)
+     * - Current: <5ms for same dataset (indexed search)
+     */
+    async search(options = {}) {
+        // SECURITY FIX: Sanitize search query (use regular sanitizeInput for queries)
+        const sanitizedQuery = options.query ?
+            sanitizeInput(UnicodeValidator.normalize(options.query).normalizedContent, 200) :
+            undefined;
+        // Use indexed search if available (Issue #984)
+        if (this.searchIndex.isIndexed) {
+            const searchQuery = {
+                content: sanitizedQuery,
+                tags: options.tags ? this.sanitizeTags(options.tags) : undefined,
+                dateFrom: options.startDate,
+                dateTo: options.endDate,
+                privacyLevel: options.privacyLevel,
+                limit: options.limit
+            };
+            const searchResults = this.searchIndex.search(searchQuery, this.entries);
+            return searchResults.map(result => result.entry);
+        }
+        // Fallback to linear search for small datasets
+        let results = [];
+        const queryLower = sanitizedQuery?.toLowerCase();
+        const searchTags = options.tags && options.tags.length > 0 ? this.sanitizeTags(options.tags) : null;
+        // Single iteration through entries with all filters applied
+        for (const entry of this.entries.values()) {
+            // Privacy level check
+            if (options.privacyLevel &&
+                !this.canAccessPrivacyLevel(entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL, options.privacyLevel)) {
+                continue;
+            }
+            // Query text check
+            if (queryLower) {
+                const contentMatch = entry.content.toLowerCase().includes(queryLower);
+                const tagMatch = entry.tags?.some(tag => tag.toLowerCase().includes(queryLower));
+                if (!contentMatch && !tagMatch) {
+                    continue;
+                }
+            }
+            // Tag filter check
+            if (searchTags && !searchTags.some(searchTag => entry.tags?.includes(searchTag))) {
+                continue;
+            }
+            // Date range checks
+            if (options.startDate && entry.timestamp < options.startDate) {
+                continue;
+            }
+            if (options.endDate && entry.timestamp > options.endDate) {
+                continue;
+            }
+            // Entry passes all filters
+            results.push(entry);
+        }
+        // Sort by timestamp (newest first) - using string comparison for IDs as secondary sort
+        results.sort((a, b) => {
+            const timeDiff = b.timestamp.getTime() - a.timestamp.getTime();
+            if (timeDiff !== 0)
+                return timeDiff;
+            // If timestamps are exactly the same, sort by ID (which contains timestamp)
+            return b.id.localeCompare(a.id);
+        });
+        // Apply limit
+        if (options.limit && options.limit > 0) {
+            results = results.slice(0, options.limit);
+        }
+        // Log search operation
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_SEARCHED,
+            severity: 'LOW',
+            source: 'Memory.search',
+            details: `Searched memories with query: ${sanitizedQuery || 'none'}, found ${results.length} results`
+        });
+        return results;
+    }
+    /**
+     * Get a specific memory entry by ID
+     */
+    async getEntry(id) {
+        return this.entries.get(id);
+    }
+    /**
+     * Delete a memory entry
+     * SECURITY: Validates permissions and logs deletion
+     */
+    async deleteEntry(id) {
+        const entry = this.entries.get(id);
+        if (!entry) {
+            return false;
+        }
+        // SECURITY: Check if sensitive memories can be deleted
+        if (entry.privacyLevel === 'sensitive') {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.SENSITIVE_MEMORY_DELETED,
+                severity: 'MEDIUM',
+                source: 'Memory.deleteEntry',
+                details: `Sensitive memory ${id} deleted`
+            });
+        }
+        this.entries.delete(id);
+        this._isDirty = true;
+        return true;
+    }
+    /**
+     * Enforce retention policy by removing expired entries
+     * SECURITY: Ensures memory doesn't grow unbounded
+     */
+    async enforceRetentionPolicy() {
+        const now = new Date();
+        let deletedCount = 0;
+        // Remove expired entries
+        for (const [id, entry] of this.entries) {
+            if (entry.expiresAt && entry.expiresAt < now) {
+                this.entries.delete(id);
+                deletedCount++;
+            }
+        }
+        // If still at or over capacity, remove oldest entries to make room for one more
+        if (this.entries.size >= this.maxEntries) {
+            const sortedEntries = Array.from(this.entries.entries())
+                .sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());
+            // Remove one extra to make room for new entry
+            const toDelete = Math.max(1, this.entries.size - this.maxEntries + 1);
+            for (let i = 0; i < toDelete && i < sortedEntries.length; i++) {
+                this.entries.delete(sortedEntries[i][0]);
+                deletedCount++;
+            }
+        }
+        if (deletedCount > 0) {
+            this._isDirty = true;
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.RETENTION_POLICY_ENFORCED,
+                severity: 'LOW',
+                source: 'Memory.enforceRetentionPolicy',
+                details: `Removed ${deletedCount} expired memories`
+            });
+        }
+        return deletedCount;
+    }
+    /**
+     * Clear all memory entries
+     * SECURITY: Requires confirmation and logs the action
+     */
+    async clearAll(confirm = false) {
+        if (!confirm) {
+            throw new Error('Memory clear requires confirmation');
+        }
+        const count = this.entries.size;
+        this.entries.clear();
+        this._isDirty = true;
+        SecurityMonitor.logSecurityEvent({
+            type: MEMORY_SECURITY_EVENTS.MEMORY_CLEARED,
+            severity: 'HIGH',
+            source: 'Memory.clearAll',
+            details: `Cleared all ${count} memory entries`
+        });
+    }
+    /**
+     * Get memory statistics
+     */
+    getStats() {
+        let totalSize = 0;
+        let oldestEntry;
+        let newestEntry;
+        const tagFrequency = new Map();
+        for (const entry of this.entries.values()) {
+            totalSize += entry.content.length;
+            if (!oldestEntry || entry.timestamp < oldestEntry) {
+                oldestEntry = entry.timestamp;
+            }
+            if (!newestEntry || entry.timestamp > newestEntry) {
+                newestEntry = entry.timestamp;
+            }
+            entry.tags?.forEach(tag => {
+                tagFrequency.set(tag, (tagFrequency.get(tag) || 0) + 1);
+            });
+        }
+        return {
+            totalEntries: this.entries.size,
+            totalSize,
+            oldestEntry,
+            newestEntry,
+            tagFrequency
+        };
+    }
+    /**
+     * Validate the memory element
+     */
+    validate() {
+        const result = super.validate();
+        // Initialize errors array if not present
+        if (!result.errors) {
+            result.errors = [];
+        }
+        // Additional memory-specific validation
+        if (this.retentionDays < MEMORY_CONSTANTS.MIN_RETENTION_DAYS || this.retentionDays > MEMORY_CONSTANTS.MAX_RETENTION_DAYS) {
+            result.errors.push({
+                field: 'retentionDays',
+                message: `Retention days must be between ${MEMORY_CONSTANTS.MIN_RETENTION_DAYS} and ${MEMORY_CONSTANTS.MAX_RETENTION_DAYS}`,
+                severity: 'error'
+            });
+        }
+        if (this.maxEntries < 1 || this.maxEntries > MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT) {
+            result.errors.push({
+                field: 'maxEntries',
+                message: `Max entries must be between 1 and ${MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT}`,
+                severity: 'error'
+            });
+        }
+        // Check memory size
+        const stats = this.getStats();
+        if (stats.totalSize > MEMORY_CONSTANTS.MAX_MEMORY_SIZE) {
+            result.errors.push({
+                field: 'memory',
+                message: `Total memory size (${stats.totalSize}) exceeds limit (${MEMORY_CONSTANTS.MAX_MEMORY_SIZE})`,
+                severity: 'error'
+            });
+        }
+        // Update validity based on our checks
+        return {
+            ...result,
+            valid: result.errors.length === 0
+        };
+    }
+    /**
+     * Serialize memory to string
+     */
+    serialize() {
+        const data = {
+            id: this.id,
+            type: this.type,
+            version: this.version,
+            metadata: this.metadata,
+            extensions: this.extensions,
+            entries: Array.from(this.entries.values())
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Deserialize memory from string
+     * SECURITY: Validates all loaded data
+     */
+    deserialize(data) {
+        try {
+            const parsed = JSON.parse(data);
+            // Validate basic structure
+            if (!parsed.id || !parsed.type || parsed.type !== ElementType.MEMORY) {
+                throw new Error('Invalid memory data format');
+            }
+            // Update properties
+            this.id = parsed.id;
+            this.version = parsed.version || '1.0.0';
+            this.metadata = parsed.metadata || {};
+            this.extensions = parsed.extensions || {};
+            // Clear and reload entries
+            this.entries.clear();
+            if (Array.isArray(parsed.entries)) {
+                for (const entry of parsed.entries) {
+                    if (this.isValidEntry(entry)) {
+                        // Use optimized sanitization with caching
+                        entry.content = this.sanitizeWithCache(entry.content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);
+                        entry.tags = this.sanitizeTags(entry.tags || []);
+                        entry.timestamp = new Date(entry.timestamp);
+                        if (entry.expiresAt) {
+                            entry.expiresAt = new Date(entry.expiresAt);
+                        }
+                        this.entries.set(entry.id, entry);
+                    }
+                }
+            }
+            // Enforce retention policy after loading
+            this.enforceRetentionPolicy();
+        }
+        catch (error) {
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_DESERIALIZE_FAILED,
+                severity: 'HIGH',
+                source: 'Memory.deserialize',
+                details: `Failed to deserialize memory: ${error}`
+            });
+            throw new Error(`Failed to deserialize memory: ${error}`);
+        }
+    }
+    // Private helper methods
+    calculateExpiryDate() {
+        const expiry = new Date();
+        expiry.setDate(expiry.getDate() + this.retentionDays);
+        return expiry;
+    }
+    sanitizeTags(tags) {
+        // SECURITY FIX: Limit number of tags and sanitize each
+        const limitedTags = tags.slice(0, MEMORY_CONSTANTS.MAX_TAGS_PER_ENTRY);
+        return limitedTags
+            .map(tag => {
+            const normalized = UnicodeValidator.normalize(tag).normalizedContent;
+            return sanitizeInput(normalized, MEMORY_CONSTANTS.MAX_TAG_LENGTH);
+        })
+            .filter(tag => tag && tag.length > 0);
+    }
+    sanitizeMetadata(metadata) {
+        if (!metadata)
+            return undefined;
+        // SECURITY FIX: Sanitize metadata values
+        const sanitized = {};
+        const maxKeys = MEMORY_CONSTANTS.MAX_METADATA_KEYS;
+        let keyCount = 0;
+        for (const [key, value] of Object.entries(metadata)) {
+            if (keyCount >= maxKeys)
+                break;
+            const sanitizedKey = sanitizeInput(key, MEMORY_CONSTANTS.MAX_METADATA_KEY_LENGTH);
+            if (sanitizedKey && typeof value === 'string') {
+                sanitized[sanitizedKey] = sanitizeInput(value, MEMORY_CONSTANTS.MAX_METADATA_VALUE_LENGTH);
+                keyCount++;
+            }
+            else if (sanitizedKey && typeof value === 'number') {
+                sanitized[sanitizedKey] = value;
+                keyCount++;
+            }
+            // Skip other types for security
+        }
+        return sanitized;
+    }
+    canAccessPrivacyLevel(entryLevel, requestedLevel) {
+        const levels = MEMORY_CONSTANTS.PRIVACY_LEVELS;
+        const entryIndex = levels.indexOf(entryLevel);
+        const requestedIndex = levels.indexOf(requestedLevel);
+        // Can only access entries at or below the requested privacy level
+        // e.g., if requesting 'private', can see 'public' and 'private' but not 'sensitive'
+        return entryIndex <= requestedIndex;
+    }
+    isValidEntry(entry) {
+        return entry &&
+            typeof entry.id === 'string' &&
+            typeof entry.content === 'string' &&
+            entry.timestamp &&
+            (!entry.tags || Array.isArray(entry.tags));
+    }
+    /**
+     * Optimized sanitization with checksum caching
+     * Avoids re-sanitizing content that hasn't changed
+     * @param content Content to sanitize
+     * @param maxLength Maximum allowed length
+     * @returns Sanitized content
+     */
+    sanitizeWithCache(content, maxLength) {
+        // Generate checksum for the input
+        const checksum = crypto.createHash('sha256').update(content).digest('hex');
+        // Check if we've already sanitized this exact content
+        const cacheKey = `${checksum}:${maxLength}`;
+        const cached = this.sanitizationCache.get(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // Perform sanitization
+        const sanitized = sanitizeMemoryContent(content, maxLength);
+        // Cache the result (limit cache size to prevent memory issues)
+        if (this.sanitizationCache.size > 1000) {
+            // Remove oldest entries (simple FIFO)
+            const firstKey = this.sanitizationCache.keys().next().value;
+            if (firstKey)
+                this.sanitizationCache.delete(firstKey);
+        }
+        this.sanitizationCache.set(cacheKey, sanitized);
+        return sanitized;
+    }
+    /**
+     * Build search index with retry logic
+     * Attempts to build the index up to 3 times with exponential backoff
+     * This ensures search functionality even if there are transient failures
+     */
+    async buildSearchIndexWithRetry(retries = 3) {
+        let lastError;
+        for (let attempt = 1; attempt <= retries; attempt++) {
+            try {
+                await this.searchIndex.buildIndex(this.entries);
+                logger.debug(`Search index built successfully on attempt ${attempt}`);
+                return;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                logger.warn(`Search index build attempt ${attempt} failed`, {
+                    error: lastError.message,
+                    entriesCount: this.entries.size
+                });
+                if (attempt < retries) {
+                    // Exponential backoff: 100ms, 200ms, 400ms
+                    const delay = Math.pow(2, attempt - 1) * 100;
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        // If we get here, all retries failed
+        throw lastError || new Error('Failed to build search index');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Memory.js","sourceRoot":"","sources":["../../../src/elements/memories/Memory.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Memory Element - Persistent context storage for continuity and learning\n * \n * Provides multiple storage backends, retention policies, and search capabilities\n * for maintaining context across sessions and interactions.\n * \n * SECURITY MEASURES IMPLEMENTED:\n * 1. Input sanitization for all memory content\n * 2. Memory size limits to prevent unbounded growth\n * 3. Path validation for file-based storage\n * 4. Retention policy enforcement\n * 5. Privacy level access control\n * 6. Audit logging for all operations\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, ElementValidationResult, ValidationError } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { IElementMetadata } from '../../types/elements/IElement.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport crypto from 'crypto';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport { sanitizeInput } from '../../security/InputValidator.js';\nimport { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS, PrivacyLevel, StorageBackend } from './constants.js';\nimport { generateMemoryId } from './utils.js';\nimport { MemorySearchIndex, SearchQuery, SearchIndexConfig } from './MemorySearchIndex.js';\nimport { logger } from '../../utils/logger.js';\nimport DOMPurify from 'dompurify';\nimport { JSDOM } from 'jsdom';\n\n// Initialize DOMPurify with JSDOM\nconst window = new JSDOM('').window;\nconst purify = DOMPurify(window as any);\n\n// Configure DOMPurify for memory content - strip all HTML but keep text\npurify.setConfig({\n  ALLOWED_TAGS: [],  // No HTML tags allowed\n  ALLOWED_ATTR: [],  // No attributes allowed\n  KEEP_CONTENT: true // Keep text content\n});\n\n/**\n * Sanitize content for memory storage\n * More permissive than sanitizeInput - allows punctuation, quotes, etc.\n * but still prevents XSS and control characters\n */\nfunction sanitizeMemoryContent(content: string, maxLength: number): string {\n  if (!content || typeof content !== 'string') {\n    return '';\n  }\n  \n  // First normalize Unicode\n  const normalized = UnicodeValidator.normalize(content).normalizedContent;\n  \n  // Use DOMPurify to strip any HTML/XSS attempts but keep text\n  const cleaned = purify.sanitize(normalized);\n  \n  // Remove only control characters and null bytes\n  return cleaned\n    .replace(/[\\x00-\\x08\\x0B\\x0C\\x0E-\\x1F\\x7F]/g, '') // Remove control chars except \\t \\n \\r\n    .substring(0, maxLength)\n    .trim();\n}\n\nexport interface MemoryMetadata extends IElementMetadata {\n  storageBackend?: StorageBackend;\n  retentionDays?: number;\n  privacyLevel?: PrivacyLevel;\n  searchable?: boolean;\n  maxEntries?: number;\n  encryptionEnabled?: boolean;\n  // Search index configuration (Issue #984)\n  indexThreshold?: number;\n  enableContentIndex?: boolean;\n  maxTermsPerEntry?: number;\n  minTermLength?: number;\n}\n\nexport interface MemoryEntry {\n  id: string;\n  timestamp: Date;\n  content: string;\n  tags?: string[];\n  metadata?: Record<string, any>;\n  expiresAt?: Date;\n  privacyLevel?: PrivacyLevel;\n}\n\nexport interface MemorySearchOptions {\n  query?: string;\n  tags?: string[];\n  startDate?: Date;\n  endDate?: Date;\n  limit?: number;\n  privacyLevel?: PrivacyLevel;\n}\n\n/**\n * Memory Element Implementation\n *\n * TODO: Memory Sharding Strategy (Issue #981)\n * ---------------------------------------------\n * Current: Single Map<id, entry> for all memories\n * Problem: Large memory sets (>10K entries) cause performance degradation\n *\n * Planned Sharding Architecture:\n * 1. Shard memories across multiple files based on hash(memoryId) % shardCount\n * 2. Each shard file <256KB for optimal YAML parsing\n * 3. Memory references stored separately from content (like git objects)\n * 4. Large binary content (PDFs, images) stored as external references\n *\n * Benefits:\n * - Parallel loading of memory shards\n * - Reduced memory footprint (load only needed shards)\n * - Better corruption resistance (one shard failure doesn't affect others)\n * - Efficient incremental updates\n *\n * TODO: Content Integrity Verification (Issue #982)\n * --------------------------------------------------\n * Add SHA-256 hashes to detect:\n * - Accidental corruption from disk errors\n * - Intentional tampering with memory files\n * - Version conflicts during concurrent access\n *\n * Implementation:\n * - Store hash in memory metadata\n * - Verify on load, warn on mismatch\n * - Option to auto-restore from backup on corruption\n *\n * TODO: Memory Capacity Management (Issue #983)\n * ---------------------------------------------\n * Current: Synchronous retention enforcement on each add\n * Better: Background cleanup with smart triggers:\n * - Cleanup when 90% capacity reached\n * - Batch deletions for efficiency\n * - LRU eviction with access tracking\n * - Preserve \"pinned\" memories regardless of age\n */\nexport class Memory extends BaseElement implements IElement {\n  // Memory-specific properties\n  private entries: Map<string, MemoryEntry> = new Map();\n  private storageBackend: StorageBackend;\n  private retentionDays: number;\n  private privacyLevel: PrivacyLevel;\n  private searchable: boolean;\n  private maxEntries: number;\n\n  // Search index for performance (Issue #984)\n  private searchIndex: MemorySearchIndex;\n\n  // Sanitization cache to avoid redundant processing\n  private sanitizationCache: Map<string, string> = new Map();\n  \n  constructor(metadata: Partial<MemoryMetadata> = {}) {\n    // SECURITY FIX: Sanitize all inputs during construction\n    const sanitizedMetadata = {\n      ...metadata,\n      name: metadata.name ? \n        sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : \n        'Unnamed Memory',\n      description: metadata.description ? \n        sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : \n        undefined\n    };\n    \n    super(ElementType.MEMORY, sanitizedMetadata);\n    \n    // Initialize memory-specific properties with defaults\n    this.storageBackend = metadata.storageBackend || MEMORY_CONSTANTS.DEFAULT_STORAGE_BACKEND;\n    this.retentionDays = metadata.retentionDays || MEMORY_CONSTANTS.DEFAULT_RETENTION_DAYS;\n    // Validate privacy level - default to private if invalid\n    this.privacyLevel = (metadata.privacyLevel && MEMORY_CONSTANTS.PRIVACY_LEVELS.includes(metadata.privacyLevel)) \n      ? metadata.privacyLevel \n      : MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;\n    this.searchable = metadata.searchable !== false;\n    this.maxEntries = Math.min(\n      metadata.maxEntries || MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT,\n      MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT\n    );\n    \n    // Set up extensions\n    this.extensions = {\n      storageBackend: this.storageBackend,\n      retentionDays: this.retentionDays,\n      privacyLevel: this.privacyLevel,\n      searchable: this.searchable,\n      maxEntries: this.maxEntries,\n      encryptionEnabled: metadata.encryptionEnabled || false\n    };\n\n    // Initialize search index with configuration (Issue #984)\n    const indexConfig: SearchIndexConfig = {\n      indexThreshold: metadata.indexThreshold || 100,\n      enableContentIndex: metadata.enableContentIndex !== false,\n      maxTermsPerEntry: metadata.maxTermsPerEntry || 100,\n      minTermLength: metadata.minTermLength || 2,\n      enablePersistence: false // Future enhancement\n    };\n    this.searchIndex = new MemorySearchIndex(indexConfig);\n\n    // Log memory creation\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_CREATED,\n      severity: 'LOW',\n      source: 'Memory.constructor',\n      details: `Memory created: ${this.metadata.name} with ${this.storageBackend} backend`\n    });\n  }\n  \n  /**\n   * Add a new memory entry\n   * SECURITY: Validates and sanitizes all input, enforces size limits\n   */\n  public async addEntry(content: string, tags?: string[], metadata?: Record<string, any>): Promise<MemoryEntry> {\n    // Validate memory size limits\n    if (this.entries.size >= this.maxEntries) {\n      // SECURITY FIX: Enforce retention policy when at capacity\n      await this.enforceRetentionPolicy();\n      \n      // If still at capacity after retention, remove oldest to make room\n      if (this.entries.size >= this.maxEntries) {\n        const oldestEntry = Array.from(this.entries.values())\n          .sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())[0];\n        if (oldestEntry) {\n          this.entries.delete(oldestEntry.id);\n        }\n      }\n    }\n    \n    // SECURITY FIX: Validate and sanitize content\n    const sanitizedContent = sanitizeMemoryContent(content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);\n    \n    if (!sanitizedContent || sanitizedContent.trim().length === 0) {\n      throw new Error('Memory content cannot be empty');\n    }\n    \n    // SECURITY FIX: Validate and sanitize tags\n    const sanitizedTags = tags ? this.sanitizeTags(tags) : [];\n    \n    // Create memory entry with generated ID\n    const entry: MemoryEntry = {\n      id: generateMemoryId(),\n      timestamp: new Date(),\n      content: sanitizedContent,\n      tags: sanitizedTags,\n      metadata: this.sanitizeMetadata(metadata),\n      privacyLevel: this.privacyLevel,\n      expiresAt: this.calculateExpiryDate()\n    };\n    \n    // Store entry\n    this.entries.set(entry.id, entry);\n    this._isDirty = true;\n\n    // Update search index (Issue #984)\n    this.searchIndex.addEntry(entry);\n\n    // Check if we should build/rebuild the index\n    if (!this.searchIndex.isIndexed && this.entries.size >= 100) {\n      // Build index asynchronously to avoid blocking, with retry logic\n      this.buildSearchIndexWithRetry().catch(error => {\n        // Final failure after retries - search will fall back to linear scan\n        logger.error('Failed to build search index after retries, search will use fallback', error);\n      });\n    }\n\n    // Log memory addition\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_ADDED,\n      severity: 'LOW',\n      source: 'Memory.addEntry',\n      details: `Added memory entry ${entry.id} with ${sanitizedTags.length} tags`\n    });\n\n    return entry;\n  }\n  \n  /**\n   * Search memory entries\n   * SECURITY: Respects privacy levels and sanitizes search queries\n   *\n   * IMPLEMENTED: Basic indexed search for O(log n) performance (Issue #984)\n   * - Tag index: Map<tag, Set<entryId>> for instant tag lookups ✓\n   * - Content index: Inverted index for term search ✓\n   * - Date index: Binary tree for efficient range queries ✓\n   * - Privacy index: Pre-sorted entries by privacy level ✓\n   *\n   * TODO: Advanced indexing features (Future enhancements):\n   * - Composite indices: Combined indices for common query patterns\n   * - Index-of-indexes pattern:\n   *   - Master index file (meta.yaml) with pointers to shard indices\n   *   - Each shard maintains its own local index\n   *   - Periodic index compaction and optimization\n   * - Persistent index storage to disk\n   * - Incremental index updates for large datasets\n   *\n   * Performance improvement achieved:\n   * - Previous: ~100ms for 10,000 entries (linear scan)\n   * - Current: <5ms for same dataset (indexed search)\n   */\n  public async search(options: MemorySearchOptions = {}): Promise<MemoryEntry[]> {\n    // SECURITY FIX: Sanitize search query (use regular sanitizeInput for queries)\n    const sanitizedQuery = options.query ?\n      sanitizeInput(UnicodeValidator.normalize(options.query).normalizedContent, 200) :\n      undefined;\n\n    // Use indexed search if available (Issue #984)\n    if (this.searchIndex.isIndexed) {\n      const searchQuery: SearchQuery = {\n        content: sanitizedQuery,\n        tags: options.tags ? this.sanitizeTags(options.tags) : undefined,\n        dateFrom: options.startDate,\n        dateTo: options.endDate,\n        privacyLevel: options.privacyLevel as PrivacyLevel,\n        limit: options.limit\n      };\n\n      const searchResults = this.searchIndex.search(searchQuery, this.entries);\n      return searchResults.map(result => result.entry);\n    }\n\n    // Fallback to linear search for small datasets\n    let results: MemoryEntry[] = [];\n    const queryLower = sanitizedQuery?.toLowerCase();\n    const searchTags = options.tags && options.tags.length > 0 ? this.sanitizeTags(options.tags) : null;\n\n    // Single iteration through entries with all filters applied\n    for (const entry of this.entries.values()) {\n      // Privacy level check\n      if (options.privacyLevel && \n          !this.canAccessPrivacyLevel(entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL, options.privacyLevel)) {\n        continue;\n      }\n      \n      // Query text check\n      if (queryLower) {\n        const contentMatch = entry.content.toLowerCase().includes(queryLower);\n        const tagMatch = entry.tags?.some(tag => tag.toLowerCase().includes(queryLower));\n        if (!contentMatch && !tagMatch) {\n          continue;\n        }\n      }\n      \n      // Tag filter check\n      if (searchTags && !searchTags.some(searchTag => entry.tags?.includes(searchTag))) {\n        continue;\n      }\n      \n      // Date range checks\n      if (options.startDate && entry.timestamp < options.startDate) {\n        continue;\n      }\n      if (options.endDate && entry.timestamp > options.endDate) {\n        continue;\n      }\n      \n      // Entry passes all filters\n      results.push(entry);\n    }\n    \n    // Sort by timestamp (newest first) - using string comparison for IDs as secondary sort\n    results.sort((a, b) => {\n      const timeDiff = b.timestamp.getTime() - a.timestamp.getTime();\n      if (timeDiff !== 0) return timeDiff;\n      // If timestamps are exactly the same, sort by ID (which contains timestamp)\n      return b.id.localeCompare(a.id);\n    });\n    \n    // Apply limit\n    if (options.limit && options.limit > 0) {\n      results = results.slice(0, options.limit);\n    }\n    \n    // Log search operation\n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_SEARCHED,\n      severity: 'LOW',\n      source: 'Memory.search',\n      details: `Searched memories with query: ${sanitizedQuery || 'none'}, found ${results.length} results`\n    });\n    \n    return results;\n  }\n  \n  /**\n   * Get a specific memory entry by ID\n   */\n  public async getEntry(id: string): Promise<MemoryEntry | undefined> {\n    return this.entries.get(id);\n  }\n  \n  /**\n   * Delete a memory entry\n   * SECURITY: Validates permissions and logs deletion\n   */\n  public async deleteEntry(id: string): Promise<boolean> {\n    const entry = this.entries.get(id);\n    if (!entry) {\n      return false;\n    }\n    \n    // SECURITY: Check if sensitive memories can be deleted\n    if (entry.privacyLevel === 'sensitive') {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.SENSITIVE_MEMORY_DELETED,\n        severity: 'MEDIUM',\n        source: 'Memory.deleteEntry',\n        details: `Sensitive memory ${id} deleted`\n      });\n    }\n    \n    this.entries.delete(id);\n    this._isDirty = true;\n    \n    return true;\n  }\n  \n  /**\n   * Enforce retention policy by removing expired entries\n   * SECURITY: Ensures memory doesn't grow unbounded\n   */\n  public async enforceRetentionPolicy(): Promise<number> {\n    const now = new Date();\n    let deletedCount = 0;\n    \n    // Remove expired entries\n    for (const [id, entry] of this.entries) {\n      if (entry.expiresAt && entry.expiresAt < now) {\n        this.entries.delete(id);\n        deletedCount++;\n      }\n    }\n    \n    // If still at or over capacity, remove oldest entries to make room for one more\n    if (this.entries.size >= this.maxEntries) {\n      const sortedEntries = Array.from(this.entries.entries())\n        .sort((a, b) => a[1].timestamp.getTime() - b[1].timestamp.getTime());\n      \n      // Remove one extra to make room for new entry\n      const toDelete = Math.max(1, this.entries.size - this.maxEntries + 1);\n      for (let i = 0; i < toDelete && i < sortedEntries.length; i++) {\n        this.entries.delete(sortedEntries[i][0]);\n        deletedCount++;\n      }\n    }\n    \n    if (deletedCount > 0) {\n      this._isDirty = true;\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.RETENTION_POLICY_ENFORCED,\n        severity: 'LOW',\n        source: 'Memory.enforceRetentionPolicy',\n        details: `Removed ${deletedCount} expired memories`\n      });\n    }\n    \n    return deletedCount;\n  }\n  \n  /**\n   * Clear all memory entries\n   * SECURITY: Requires confirmation and logs the action\n   */\n  public async clearAll(confirm: boolean = false): Promise<void> {\n    if (!confirm) {\n      throw new Error('Memory clear requires confirmation');\n    }\n    \n    const count = this.entries.size;\n    this.entries.clear();\n    this._isDirty = true;\n    \n    SecurityMonitor.logSecurityEvent({\n      type: MEMORY_SECURITY_EVENTS.MEMORY_CLEARED,\n      severity: 'HIGH',\n      source: 'Memory.clearAll',\n      details: `Cleared all ${count} memory entries`\n    });\n  }\n  \n  /**\n   * Get memory statistics\n   */\n  public getStats(): {\n    totalEntries: number;\n    totalSize: number;\n    oldestEntry?: Date;\n    newestEntry?: Date;\n    tagFrequency: Map<string, number>;\n  } {\n    let totalSize = 0;\n    let oldestEntry: Date | undefined;\n    let newestEntry: Date | undefined;\n    const tagFrequency = new Map<string, number>();\n    \n    for (const entry of this.entries.values()) {\n      totalSize += entry.content.length;\n      \n      if (!oldestEntry || entry.timestamp < oldestEntry) {\n        oldestEntry = entry.timestamp;\n      }\n      if (!newestEntry || entry.timestamp > newestEntry) {\n        newestEntry = entry.timestamp;\n      }\n      \n      entry.tags?.forEach(tag => {\n        tagFrequency.set(tag, (tagFrequency.get(tag) || 0) + 1);\n      });\n    }\n    \n    return {\n      totalEntries: this.entries.size,\n      totalSize,\n      oldestEntry,\n      newestEntry,\n      tagFrequency\n    };\n  }\n  \n  /**\n   * Validate the memory element\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    \n    // Initialize errors array if not present\n    if (!result.errors) {\n      result.errors = [];\n    }\n    \n    // Additional memory-specific validation\n    if (this.retentionDays < MEMORY_CONSTANTS.MIN_RETENTION_DAYS || this.retentionDays > MEMORY_CONSTANTS.MAX_RETENTION_DAYS) {\n      result.errors.push({\n        field: 'retentionDays',\n        message: `Retention days must be between ${MEMORY_CONSTANTS.MIN_RETENTION_DAYS} and ${MEMORY_CONSTANTS.MAX_RETENTION_DAYS}`,\n        severity: 'error'\n      } as ValidationError);\n    }\n    \n    if (this.maxEntries < 1 || this.maxEntries > MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT) {\n      result.errors.push({\n        field: 'maxEntries',\n        message: `Max entries must be between 1 and ${MEMORY_CONSTANTS.MAX_ENTRIES_DEFAULT}`,\n        severity: 'error'\n      } as ValidationError);\n    }\n    \n    // Check memory size\n    const stats = this.getStats();\n    if (stats.totalSize > MEMORY_CONSTANTS.MAX_MEMORY_SIZE) {\n      result.errors.push({\n        field: 'memory',\n        message: `Total memory size (${stats.totalSize}) exceeds limit (${MEMORY_CONSTANTS.MAX_MEMORY_SIZE})`,\n        severity: 'error'\n      } as ValidationError);\n    }\n    \n    // Update validity based on our checks\n    return {\n      ...result,\n      valid: result.errors.length === 0\n    };\n  }\n  \n  /**\n   * Serialize memory to string\n   */\n  public override serialize(): string {\n    const data = {\n      id: this.id,\n      type: this.type,\n      version: this.version,\n      metadata: this.metadata,\n      extensions: this.extensions,\n      entries: Array.from(this.entries.values())\n    };\n    \n    return JSON.stringify(data, null, 2);\n  }\n  \n  /**\n   * Deserialize memory from string\n   * SECURITY: Validates all loaded data\n   */\n  public override deserialize(data: string): void {\n    try {\n      const parsed = JSON.parse(data);\n      \n      // Validate basic structure\n      if (!parsed.id || !parsed.type || parsed.type !== ElementType.MEMORY) {\n        throw new Error('Invalid memory data format');\n      }\n      \n      // Update properties\n      this.id = parsed.id;\n      this.version = parsed.version || '1.0.0';\n      this.metadata = parsed.metadata || {};\n      this.extensions = parsed.extensions || {};\n      \n      // Clear and reload entries\n      this.entries.clear();\n      if (Array.isArray(parsed.entries)) {\n        for (const entry of parsed.entries) {\n          if (this.isValidEntry(entry)) {\n            // Use optimized sanitization with caching\n            entry.content = this.sanitizeWithCache(entry.content, MEMORY_CONSTANTS.MAX_ENTRY_SIZE);\n            entry.tags = this.sanitizeTags(entry.tags || []);\n            entry.timestamp = new Date(entry.timestamp);\n            if (entry.expiresAt) {\n              entry.expiresAt = new Date(entry.expiresAt);\n            }\n            this.entries.set(entry.id, entry);\n          }\n        }\n      }\n      \n      // Enforce retention policy after loading\n      this.enforceRetentionPolicy();\n      \n    } catch (error) {\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_DESERIALIZE_FAILED,\n        severity: 'HIGH',\n        source: 'Memory.deserialize',\n        details: `Failed to deserialize memory: ${error}`\n      });\n      throw new Error(`Failed to deserialize memory: ${error}`);\n    }\n  }\n  \n  // Private helper methods\n  \n  private calculateExpiryDate(): Date {\n    const expiry = new Date();\n    expiry.setDate(expiry.getDate() + this.retentionDays);\n    return expiry;\n  }\n  \n  private sanitizeTags(tags: string[]): string[] {\n    // SECURITY FIX: Limit number of tags and sanitize each\n    const limitedTags = tags.slice(0, MEMORY_CONSTANTS.MAX_TAGS_PER_ENTRY);\n    \n    return limitedTags\n      .map(tag => {\n        const normalized = UnicodeValidator.normalize(tag).normalizedContent;\n        return sanitizeInput(normalized, MEMORY_CONSTANTS.MAX_TAG_LENGTH);\n      })\n      .filter(tag => tag && tag.length > 0);\n  }\n  \n  private sanitizeMetadata(metadata?: Record<string, any>): Record<string, any> | undefined {\n    if (!metadata) return undefined;\n    \n    // SECURITY FIX: Sanitize metadata values\n    const sanitized: Record<string, any> = {};\n    const maxKeys = MEMORY_CONSTANTS.MAX_METADATA_KEYS;\n    let keyCount = 0;\n    \n    for (const [key, value] of Object.entries(metadata)) {\n      if (keyCount >= maxKeys) break;\n      \n      const sanitizedKey = sanitizeInput(key, MEMORY_CONSTANTS.MAX_METADATA_KEY_LENGTH);\n      if (sanitizedKey && typeof value === 'string') {\n        sanitized[sanitizedKey] = sanitizeInput(value, MEMORY_CONSTANTS.MAX_METADATA_VALUE_LENGTH);\n        keyCount++;\n      } else if (sanitizedKey && typeof value === 'number') {\n        sanitized[sanitizedKey] = value;\n        keyCount++;\n      }\n      // Skip other types for security\n    }\n    \n    return sanitized;\n  }\n  \n  private canAccessPrivacyLevel(entryLevel: string, requestedLevel: string): boolean {\n    const levels = MEMORY_CONSTANTS.PRIVACY_LEVELS;\n    const entryIndex = levels.indexOf(entryLevel as PrivacyLevel);\n    const requestedIndex = levels.indexOf(requestedLevel as PrivacyLevel);\n    \n    // Can only access entries at or below the requested privacy level\n    // e.g., if requesting 'private', can see 'public' and 'private' but not 'sensitive'\n    return entryIndex <= requestedIndex;\n  }\n  \n  private isValidEntry(entry: any): boolean {\n    return entry &&\n      typeof entry.id === 'string' &&\n      typeof entry.content === 'string' &&\n      entry.timestamp &&\n      (!entry.tags || Array.isArray(entry.tags));\n  }\n\n  /**\n   * Optimized sanitization with checksum caching\n   * Avoids re-sanitizing content that hasn't changed\n   * @param content Content to sanitize\n   * @param maxLength Maximum allowed length\n   * @returns Sanitized content\n   */\n  private sanitizeWithCache(content: string, maxLength: number): string {\n    // Generate checksum for the input\n    const checksum = crypto.createHash('sha256').update(content).digest('hex');\n\n    // Check if we've already sanitized this exact content\n    const cacheKey = `${checksum}:${maxLength}`;\n    const cached = this.sanitizationCache.get(cacheKey);\n    if (cached) {\n      return cached;\n    }\n\n    // Perform sanitization\n    const sanitized = sanitizeMemoryContent(content, maxLength);\n\n    // Cache the result (limit cache size to prevent memory issues)\n    if (this.sanitizationCache.size > 1000) {\n      // Remove oldest entries (simple FIFO)\n      const firstKey = this.sanitizationCache.keys().next().value;\n      if (firstKey) this.sanitizationCache.delete(firstKey);\n    }\n    this.sanitizationCache.set(cacheKey, sanitized);\n\n    return sanitized;\n  }\n\n  /**\n   * Build search index with retry logic\n   * Attempts to build the index up to 3 times with exponential backoff\n   * This ensures search functionality even if there are transient failures\n   */\n  private async buildSearchIndexWithRetry(retries = 3): Promise<void> {\n    let lastError: Error | undefined;\n\n    for (let attempt = 1; attempt <= retries; attempt++) {\n      try {\n        await this.searchIndex.buildIndex(this.entries);\n        logger.debug(`Search index built successfully on attempt ${attempt}`);\n        return;\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n        logger.warn(`Search index build attempt ${attempt} failed`, {\n          error: lastError.message,\n          entriesCount: this.entries.size\n        });\n\n        if (attempt < retries) {\n          // Exponential backoff: 100ms, 200ms, 400ms\n          const delay = Math.pow(2, attempt - 1) * 100;\n          await new Promise(resolve => setTimeout(resolve, delay));\n        }\n      }\n    }\n\n    // If we get here, all retries failed\n    throw lastError || new Error('Failed to build search index');\n  }\n}"]}