@dollhousemcp/mcp-server 1.8.0 → 1.9.0

package/dist/elements/memories/MemorySearchIndex.js

@@ -0,0 +1,690 @@
+/**
+ * Memory Search Index - High-performance indexed search for Memory elements
+ *
+ * Addresses issue #984: Implement search indexing for Memory element scalability
+ *
+ * Features:
+ * - Tag index for O(1) tag-based queries
+ * - Content index using inverted index pattern
+ * - Temporal index for date range queries
+ * - Privacy level index for filtered access
+ * - Incremental index updates
+ * - Optional persistence
+ * - Configurable thresholds
+ */
+import { MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';
+import { logger } from '../../utils/logger.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+/**
+ * Inverted index for content search
+ */
+class ContentIndex {
+    termToEntries = new Map();
+    entryToTerms = new Map();
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Add an entry to the content index
+     */
+    addEntry(entryId, content) {
+        const terms = this.extractTerms(content, { entryId });
+        // Store terms for this entry
+        this.entryToTerms.set(entryId, terms);
+        // Update inverted index
+        for (const term of terms) {
+            let entries = this.termToEntries.get(term);
+            if (!entries) {
+                entries = new Set();
+                this.termToEntries.set(term, entries);
+            }
+            entries.add(entryId);
+        }
+    }
+    /**
+     * Remove an entry from the index
+     */
+    removeEntry(entryId) {
+        const terms = this.entryToTerms.get(entryId);
+        if (!terms)
+            return;
+        // Remove from inverted index
+        for (const term of terms) {
+            const entries = this.termToEntries.get(term);
+            if (entries) {
+                entries.delete(entryId);
+                if (entries.size === 0) {
+                    this.termToEntries.delete(term);
+                }
+            }
+        }
+        // Remove entry terms
+        this.entryToTerms.delete(entryId);
+    }
+    /**
+     * Search for entries containing query terms
+     */
+    search(query) {
+        const queryTerms = this.extractTerms(query);
+        const scores = new Map();
+        for (const term of queryTerms) {
+            const entries = this.termToEntries.get(term);
+            if (entries) {
+                for (const entryId of entries) {
+                    scores.set(entryId, (scores.get(entryId) || 0) + 1);
+                }
+            }
+        }
+        return scores;
+    }
+    /**
+     * Extract searchable terms from content
+     * SECURITY FIX: Added audit logging for Unicode validation operations
+     */
+    extractTerms(content, context) {
+        // Normalize for security
+        const normalized = UnicodeValidator.normalize(content);
+        if (!normalized.isValid) {
+            logger.warn('Invalid Unicode in content for indexing', {
+                entryId: context?.entryId
+            });
+            // SECURITY FIX: Log security event for audit trail (DMCP-SEC-006)
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,
+                severity: 'LOW',
+                source: 'MemorySearchIndex.extractTerms',
+                details: `Invalid Unicode detected during term extraction${context?.entryId ? ` for entry ${context.entryId}` : ''}`,
+                metadata: {
+                    entryId: context?.entryId,
+                    issueCount: 0 // UnicodeValidationResult doesn't expose issues
+                }
+            });
+            return new Set();
+        }
+        const text = normalized.normalizedContent.toLowerCase();
+        const terms = new Set();
+        // Simple tokenization (can be improved with better NLP)
+        const words = text.match(/\b\w+\b/g) || [];
+        let termCount = 0;
+        for (const word of words) {
+            if (word.length >= (this.config.minTermLength || 2)) {
+                terms.add(word);
+                termCount++;
+                if (termCount >= (this.config.maxTermsPerEntry || 100)) {
+                    break;
+                }
+            }
+        }
+        return terms;
+    }
+    clear() {
+        this.termToEntries.clear();
+        this.entryToTerms.clear();
+    }
+    get size() {
+        return this.termToEntries.size;
+    }
+}
+/**
+ * Date range index using sorted array for efficient range queries
+ */
+class TemporalIndex {
+    entries = [];
+    addEntry(entryId, date) {
+        const timestamp = date.getTime();
+        // Binary search for insertion point
+        let left = 0;
+        let right = this.entries.length;
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (this.entries[mid].timestamp < timestamp) {
+                left = mid + 1;
+            }
+            else {
+                right = mid;
+            }
+        }
+        // Insert at correct position to maintain sort
+        this.entries.splice(left, 0, { id: entryId, timestamp });
+    }
+    removeEntry(entryId) {
+        const index = this.entries.findIndex(e => e.id === entryId);
+        if (index >= 0) {
+            this.entries.splice(index, 1);
+        }
+    }
+    /**
+     * Find entries within date range
+     */
+    searchRange(from, to) {
+        const results = new Set();
+        const fromTime = from?.getTime() || 0;
+        const toTime = to?.getTime() || Date.now();
+        // Binary search for start
+        let start = 0;
+        let end = this.entries.length;
+        while (start < end) {
+            const mid = Math.floor((start + end) / 2);
+            if (this.entries[mid].timestamp < fromTime) {
+                start = mid + 1;
+            }
+            else {
+                end = mid;
+            }
+        }
+        // Collect all entries in range
+        for (let i = start; i < this.entries.length; i++) {
+            const entry = this.entries[i];
+            if (entry.timestamp > toTime)
+                break;
+            results.add(entry.id);
+        }
+        return results;
+    }
+    clear() {
+        this.entries = [];
+    }
+    get size() {
+        return this.entries.length;
+    }
+    serialize() {
+        return this.entries;
+    }
+    deserialize(data) {
+        this.entries = data || [];
+    }
+}
+/**
+ * Main search index for Memory elements
+ */
+export class MemorySearchIndex {
+    config;
+    // Indexes
+    tagIndex = new Map();
+    privacyIndex = new Map();
+    contentIndex = null;
+    temporalIndex = new TemporalIndex();
+    // Cached entries for scoring
+    entriesCache = new Map();
+    // Index state
+    isBuilt = false;
+    isBuilding = false;
+    buildQueue = null;
+    stats = {
+        isIndexed: false,
+        entryCount: 0,
+        tagCount: 0,
+        termCount: 0,
+        memoryUsageBytes: 0
+    };
+    // Memory management
+    maxMemoryBytes;
+    memoryUsageBytes = 0;
+    constructor(config = {}) {
+        this.config = {
+            indexThreshold: config.indexThreshold || 100,
+            enableContentIndex: config.enableContentIndex !== false,
+            maxTermsPerEntry: config.maxTermsPerEntry || 100,
+            minTermLength: config.minTermLength || 2,
+            enablePersistence: config.enablePersistence || false,
+            maxMemoryMB: config.maxMemoryMB || 100,
+            enableLRUEviction: config.enableLRUEviction !== false
+        };
+        // Configure memory limit (default 100MB, configurable)
+        this.maxMemoryBytes = (this.config.maxMemoryMB || 100) * 1024 * 1024;
+        if (this.config.enableContentIndex) {
+            this.contentIndex = new ContentIndex(this.config);
+        }
+        logger.debug('MemorySearchIndex created', this.config);
+    }
+    /**
+     * Build or rebuild the index from entries
+     * FIX: Added race condition protection with isBuilding flag and build queue
+     */
+    async buildIndex(entries) {
+        // If already building, wait for the current build to complete
+        if (this.isBuilding && this.buildQueue) {
+            logger.debug('Index build already in progress, waiting...');
+            return this.buildQueue;
+        }
+        // Create build promise to handle concurrent calls
+        this.buildQueue = this._doBuildIndex(entries);
+        return this.buildQueue;
+    }
+    async _doBuildIndex(entries) {
+        // Prevent concurrent builds
+        if (this.isBuilding) {
+            logger.warn('Attempted concurrent index build, skipping');
+            return;
+        }
+        this.isBuilding = true;
+        const startTime = Date.now();
+        try {
+            // Clear existing indexes
+            this.clear();
+            // Check if we should index based on threshold
+            if (entries.size < (this.config.indexThreshold || 100)) {
+                logger.debug('Not building index - below threshold', {
+                    entryCount: entries.size,
+                    threshold: this.config.indexThreshold
+                });
+                return;
+            }
+            // Build indexes
+            for (const [id, entry] of entries) {
+                this.addToIndex(id, entry);
+            }
+            // Calculate memory usage
+            this.updateMemoryUsage();
+            // SECURITY FIX: Log security event for index build operation (DMCP-SEC-006)
+            SecurityMonitor.logSecurityEvent({
+                type: MEMORY_SECURITY_EVENTS.MEMORY_CREATED, // Using CREATED for index build
+                severity: 'LOW',
+                source: 'MemorySearchIndex.buildIndex',
+                details: `Memory search index built successfully with ${entries.size} entries`,
+                metadata: {
+                    entryCount: entries.size,
+                    tagCount: this.tagIndex.size,
+                    memoryUsageBytes: this.memoryUsageBytes
+                }
+            });
+            // Update stats
+            const buildTime = Date.now() - startTime;
+            this.stats = {
+                isIndexed: true,
+                entryCount: entries.size,
+                tagCount: this.tagIndex.size,
+                termCount: this.contentIndex?.size || 0,
+                lastBuilt: new Date(),
+                buildTimeMs: buildTime,
+                memoryUsageBytes: this.memoryUsageBytes
+            };
+            this.isBuilt = true;
+            logger.info('Memory search index built', this.stats);
+        }
+        catch (error) {
+            logger.error('Failed to build memory search index', error);
+            // Reset state on failure
+            this.clear();
+            throw error;
+        }
+        finally {
+            this.isBuilding = false;
+            this.buildQueue = null;
+        }
+    }
+    /**
+     * Add a single entry to the index (incremental update)
+     */
+    addEntry(entry) {
+        if (!this.isBuilt)
+            return;
+        this.addToIndex(entry.id, entry);
+        this.stats.entryCount++;
+        logger.debug('Entry added to index', { id: entry.id });
+    }
+    /**
+     * Remove an entry from the index
+     */
+    removeEntry(entryId) {
+        if (!this.isBuilt)
+            return;
+        const entry = this.entriesCache.get(entryId);
+        if (!entry)
+            return;
+        // Remove from tag index
+        if (entry.metadata?.tags) {
+            for (const tag of entry.metadata.tags) {
+                const entries = this.tagIndex.get(tag);
+                if (entries) {
+                    entries.delete(entryId);
+                    if (entries.size === 0) {
+                        this.tagIndex.delete(tag);
+                    }
+                }
+            }
+        }
+        // Remove from privacy index
+        const privacyLevel = entry.metadata?.privacyLevel || entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;
+        const privacyEntries = this.privacyIndex.get(privacyLevel);
+        if (privacyEntries) {
+            privacyEntries.delete(entryId);
+        }
+        // Remove from content index
+        this.contentIndex?.removeEntry(entryId);
+        // Remove from temporal index
+        this.temporalIndex.removeEntry(entryId);
+        // Remove from cache
+        this.entriesCache.delete(entryId);
+        this.stats.entryCount--;
+        logger.debug('Entry removed from index', { id: entryId });
+    }
+    /**
+     * Search the index with multiple criteria
+     */
+    search(query, entries) {
+        if (!this.isBuilt) {
+            logger.debug('Index not built, falling back to linear search');
+            return this.linearSearch(query, entries);
+        }
+        // Start with all entries or filtered by privacy
+        let candidateIds = null;
+        // Filter by privacy level
+        if (query.privacyLevel) {
+            candidateIds = new Set(this.privacyIndex.get(query.privacyLevel) || []);
+        }
+        // Filter by tags (intersection)
+        if (query.tags && query.tags.length > 0) {
+            const tagResults = new Set();
+            for (const tag of query.tags) {
+                const entries = this.tagIndex.get(tag.toLowerCase());
+                if (entries) {
+                    if (candidateIds) {
+                        // Intersection with existing candidates
+                        for (const id of entries) {
+                            if (candidateIds.has(id)) {
+                                tagResults.add(id);
+                            }
+                        }
+                    }
+                    else {
+                        // First filter
+                        entries.forEach(id => tagResults.add(id));
+                    }
+                }
+            }
+            candidateIds = tagResults;
+        }
+        // Filter by date range
+        if (query.dateFrom || query.dateTo) {
+            const dateResults = this.temporalIndex.searchRange(query.dateFrom, query.dateTo);
+            if (candidateIds) {
+                // Intersection
+                const intersection = new Set();
+                for (const id of candidateIds) {
+                    if (dateResults.has(id)) {
+                        intersection.add(id);
+                    }
+                }
+                candidateIds = intersection;
+            }
+            else {
+                candidateIds = dateResults;
+            }
+        }
+        // Score by content if provided
+        const contentScores = query.content && this.contentIndex
+            ? this.contentIndex.search(query.content)
+            : new Map();
+        // Build results
+        const results = [];
+        const searchEntries = candidateIds || new Set(entries.keys());
+        for (const id of searchEntries) {
+            const entry = entries.get(id);
+            if (!entry)
+                continue;
+            // Calculate score
+            let score = 1;
+            // Content relevance score
+            if (contentScores.has(id)) {
+                score += contentScores.get(id) * 2;
+            }
+            // Tag match bonus
+            if (query.tags && entry.metadata?.tags) {
+                const matchedTags = query.tags.filter(tag => entry.metadata?.tags?.includes(tag));
+                score += matchedTags.length;
+            }
+            results.push({
+                entry,
+                score,
+                matches: {
+                    tags: query.tags?.filter(tag => entry.metadata?.tags?.includes(tag)),
+                    terms: query.content ? ['indexed'] : undefined
+                }
+            });
+        }
+        // Sort by score and apply pagination
+        results.sort((a, b) => b.score - a.score);
+        const offset = query.offset || 0;
+        const limit = query.limit || 100;
+        return results.slice(offset, offset + limit);
+    }
+    /**
+     * Fallback linear search when index is not available
+     */
+    linearSearch(query, entries) {
+        const results = [];
+        for (const [id, entry] of entries) {
+            // Check privacy level
+            if (query.privacyLevel && entry.metadata?.privacyLevel !== query.privacyLevel) {
+                continue;
+            }
+            // Check date range
+            if (query.dateFrom && entry.metadata?.timestamp && entry.metadata.timestamp < query.dateFrom) {
+                continue;
+            }
+            if (query.dateTo && entry.metadata?.timestamp && entry.metadata.timestamp > query.dateTo) {
+                continue;
+            }
+            // Check tags
+            if (query.tags && query.tags.length > 0) {
+                const hasAllTags = query.tags.every(tag => entry.metadata?.tags?.includes(tag));
+                if (!hasAllTags)
+                    continue;
+            }
+            // Check content (simple substring match)
+            let score = 1;
+            if (query.content) {
+                const normalized = UnicodeValidator.normalize(query.content);
+                if (normalized.isValid) {
+                    const searchTerm = normalized.normalizedContent.toLowerCase();
+                    if (entry.content.toLowerCase().includes(searchTerm)) {
+                        score += 2;
+                    }
+                }
+            }
+            results.push({
+                entry,
+                score,
+                matches: {
+                    tags: query.tags?.filter(tag => entry.metadata?.tags?.includes(tag))
+                }
+            });
+        }
+        // Sort and paginate
+        results.sort((a, b) => b.score - a.score);
+        const offset = query.offset || 0;
+        const limit = query.limit || 100;
+        return results.slice(offset, offset + limit);
+    }
+    /**
+     * Internal helper to add entry to all indexes
+     */
+    addToIndex(id, entry) {
+        // Cache entry
+        this.entriesCache.set(id, entry);
+        // Add to tag index
+        if (entry.metadata?.tags) {
+            for (const tag of entry.metadata.tags) {
+                const normalizedTag = tag.toLowerCase();
+                let entries = this.tagIndex.get(normalizedTag);
+                if (!entries) {
+                    entries = new Set();
+                    this.tagIndex.set(normalizedTag, entries);
+                }
+                entries.add(id);
+            }
+        }
+        // Add to privacy index
+        const privacyLevel = entry.metadata?.privacyLevel || entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;
+        let privacyEntries = this.privacyIndex.get(privacyLevel);
+        if (!privacyEntries) {
+            privacyEntries = new Set();
+            this.privacyIndex.set(privacyLevel, privacyEntries);
+        }
+        privacyEntries.add(id);
+        // Add to content index
+        if (this.contentIndex) {
+            this.contentIndex.addEntry(id, entry.content);
+        }
+        // Add to temporal index
+        this.temporalIndex.addEntry(id, entry.metadata?.timestamp || entry.timestamp);
+    }
+    /**
+     * Clear all indexes
+     */
+    clear() {
+        this.tagIndex.clear();
+        this.privacyIndex.clear();
+        this.contentIndex?.clear();
+        this.temporalIndex.clear();
+        this.entriesCache.clear();
+        this.isBuilt = false;
+        this.stats = {
+            isIndexed: false,
+            entryCount: 0,
+            tagCount: 0,
+            termCount: 0
+        };
+    }
+    /**
+     * Get index statistics
+     */
+    getStats() {
+        return { ...this.stats };
+    }
+    /**
+     * Check if index is built
+     */
+    get isIndexed() {
+        return this.isBuilt;
+    }
+    /**
+     * Calculate and update memory usage
+     * FIX: Added memory monitoring for content index
+     */
+    updateMemoryUsage() {
+        let totalBytes = 0;
+        // Estimate tag index memory
+        for (const [tag, entries] of this.tagIndex) {
+            totalBytes += tag.length * 2; // UTF-16 encoding
+            totalBytes += entries.size * 32; // Estimated ID size
+        }
+        // Estimate content index memory
+        if (this.contentIndex) {
+            // Rough estimate: each term + entry IDs
+            totalBytes += this.contentIndex.size * 100;
+        }
+        // Estimate temporal index memory
+        totalBytes += this.temporalIndex.size * 48; // Date + ID
+        // Estimate cache memory
+        for (const entry of this.entriesCache.values()) {
+            totalBytes += JSON.stringify(entry).length * 2;
+        }
+        this.memoryUsageBytes = totalBytes;
+        // Check if we're exceeding memory limit
+        if (totalBytes > this.maxMemoryBytes) {
+            logger.warn('Memory search index exceeding limit', {
+                usedMB: Math.round(totalBytes / 1024 / 1024),
+                limitMB: Math.round(this.maxMemoryBytes / 1024 / 1024)
+            });
+            // Trigger LRU eviction if enabled
+            if (this.config.enableLRUEviction) {
+                this.evictLRUEntries();
+            }
+        }
+    }
+    /**
+     * Evict least recently used entries to free memory
+     * FIX: Added LRU eviction for memory management
+     */
+    evictLRUEntries() {
+        // Get entries sorted by access time (would need to track this)
+        // For now, evict oldest 20% of entries
+        const entriesToEvict = Math.floor(this.entriesCache.size * 0.2);
+        const entriesArray = Array.from(this.entriesCache.keys());
+        for (let i = 0; i < entriesToEvict; i++) {
+            const idToEvict = entriesArray[i];
+            this.removeEntry(idToEvict);
+        }
+        logger.info('Evicted LRU entries', {
+            evictedCount: entriesToEvict,
+            remainingCount: this.entriesCache.size
+        });
+    }
+    /**
+     * Serialize index to JSON for persistence
+     * FIX: Added index serialization for cold start optimization
+     */
+    serialize() {
+        if (!this.isBuilt) {
+            throw new Error('Cannot serialize unbuilt index');
+        }
+        const indexData = {
+            version: '1.0.0',
+            stats: this.stats,
+            tagIndex: Array.from(this.tagIndex.entries()).map(([tag, ids]) => ({
+                tag,
+                ids: Array.from(ids)
+            })),
+            privacyIndex: Array.from(this.privacyIndex.entries()).map(([level, ids]) => ({
+                level,
+                ids: Array.from(ids)
+            })),
+            temporalIndex: this.temporalIndex.serialize(),
+            // Note: Content index is not serialized due to size
+            // It will be rebuilt on load if needed
+        };
+        return JSON.stringify(indexData);
+    }
+    /**
+     * Deserialize index from JSON
+     * FIX: Added index deserialization for faster startup
+     */
+    deserialize(data, entries) {
+        try {
+            const indexData = JSON.parse(data);
+            // Validate version
+            if (indexData.version !== '1.0.0') {
+                throw new Error(`Unsupported index version: ${indexData.version}`);
+            }
+            // Clear existing indexes
+            this.clear();
+            // Restore tag index
+            for (const { tag, ids } of indexData.tagIndex) {
+                this.tagIndex.set(tag, new Set(ids));
+            }
+            // Restore privacy index
+            for (const { level, ids } of indexData.privacyIndex) {
+                this.privacyIndex.set(level, new Set(ids));
+            }
+            // Restore temporal index
+            this.temporalIndex.deserialize(indexData.temporalIndex);
+            // Restore entries cache from provided entries
+            for (const [id, entry] of entries) {
+                if (indexData.tagIndex.some((item) => item.ids.includes(id))) {
+                    this.entriesCache.set(id, entry);
+                }
+            }
+            // Rebuild content index if enabled (can't serialize efficiently)
+            if (this.config.enableContentIndex) {
+                this.contentIndex = new ContentIndex(this.config);
+                for (const [id, entry] of this.entriesCache) {
+                    this.contentIndex.addEntry(id, entry.content);
+                }
+            }
+            // Update stats
+            this.stats = indexData.stats;
+            this.isBuilt = true;
+            logger.info('Memory search index deserialized', this.stats);
+        }
+        catch (error) {
+            logger.error('Failed to deserialize index, rebuilding', error);
+            // Fall back to building from scratch
+            this.buildIndex(entries);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemorySearchIndex.js","sourceRoot":"","sources":["../../../src/elements/memories/MemorySearchIndex.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Memory Search Index - High-performance indexed search for Memory elements\n *\n * Addresses issue #984: Implement search indexing for Memory element scalability\n *\n * Features:\n * - Tag index for O(1) tag-based queries\n * - Content index using inverted index pattern\n * - Temporal index for date range queries\n * - Privacy level index for filtered access\n * - Incremental index updates\n * - Optional persistence\n * - Configurable thresholds\n */\n\nimport { MemoryEntry } from './Memory.js';\nimport { PrivacyLevel, MEMORY_CONSTANTS, MEMORY_SECURITY_EVENTS } from './constants.js';\nimport { logger } from '../../utils/logger.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\n\nexport interface SearchIndexConfig {\n  /**\n   * Enable indexing when memory has more than this many entries\n   * Default: 100\n   */\n  indexThreshold?: number;\n\n  /**\n   * Enable content index (more memory intensive)\n   * Default: true\n   */\n  enableContentIndex?: boolean;\n\n  /**\n   * Maximum number of terms to index per entry\n   * Default: 100\n   */\n  maxTermsPerEntry?: number;\n\n  /**\n   * Minimum term length to index\n   * Default: 2\n   */\n  minTermLength?: number;\n\n  /**\n   * Enable index persistence to disk\n   * Default: false\n   */\n  enablePersistence?: boolean;\n\n  /**\n   * Maximum memory usage in MB\n   * Default: 100\n   */\n  maxMemoryMB?: number;\n\n  /**\n   * Enable LRU eviction when memory limit is reached\n   * Default: true\n   */\n  enableLRUEviction?: boolean;\n}\n\nexport interface SearchIndexStats {\n  isIndexed: boolean;\n  entryCount: number;\n  tagCount: number;\n  termCount: number;\n  lastBuilt?: Date;\n  buildTimeMs?: number;\n  memoryUsageBytes?: number;\n}\n\nexport interface SearchQuery {\n  tags?: string[];\n  content?: string;\n  dateFrom?: Date;\n  dateTo?: Date;\n  privacyLevel?: PrivacyLevel;\n  limit?: number;\n  offset?: number;\n}\n\nexport interface SearchResult {\n  entry: MemoryEntry;\n  score: number;\n  matches: {\n    tags?: string[];\n    terms?: string[];\n  };\n}\n\n/**\n * Inverted index for content search\n */\nclass ContentIndex {\n  private termToEntries = new Map<string, Set<string>>();\n  private entryToTerms = new Map<string, Set<string>>();\n  private readonly config: SearchIndexConfig;\n\n  constructor(config: SearchIndexConfig) {\n    this.config = config;\n  }\n\n  /**\n   * Add an entry to the content index\n   */\n  addEntry(entryId: string, content: string): void {\n    const terms = this.extractTerms(content, { entryId });\n\n    // Store terms for this entry\n    this.entryToTerms.set(entryId, terms);\n\n    // Update inverted index\n    for (const term of terms) {\n      let entries = this.termToEntries.get(term);\n      if (!entries) {\n        entries = new Set();\n        this.termToEntries.set(term, entries);\n      }\n      entries.add(entryId);\n    }\n  }\n\n  /**\n   * Remove an entry from the index\n   */\n  removeEntry(entryId: string): void {\n    const terms = this.entryToTerms.get(entryId);\n    if (!terms) return;\n\n    // Remove from inverted index\n    for (const term of terms) {\n      const entries = this.termToEntries.get(term);\n      if (entries) {\n        entries.delete(entryId);\n        if (entries.size === 0) {\n          this.termToEntries.delete(term);\n        }\n      }\n    }\n\n    // Remove entry terms\n    this.entryToTerms.delete(entryId);\n  }\n\n  /**\n   * Search for entries containing query terms\n   */\n  search(query: string): Map<string, number> {\n    const queryTerms = this.extractTerms(query);\n    const scores = new Map<string, number>();\n\n    for (const term of queryTerms) {\n      const entries = this.termToEntries.get(term);\n      if (entries) {\n        for (const entryId of entries) {\n          scores.set(entryId, (scores.get(entryId) || 0) + 1);\n        }\n      }\n    }\n\n    return scores;\n  }\n\n  /**\n   * Extract searchable terms from content\n   * SECURITY FIX: Added audit logging for Unicode validation operations\n   */\n  private extractTerms(content: string, context?: { entryId?: string }): Set<string> {\n    // Normalize for security\n    const normalized = UnicodeValidator.normalize(content);\n    if (!normalized.isValid) {\n      logger.warn('Invalid Unicode in content for indexing', {\n        entryId: context?.entryId\n      });\n\n      // SECURITY FIX: Log security event for audit trail (DMCP-SEC-006)\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_UNICODE_VALIDATION_FAILED,\n        severity: 'LOW',\n        source: 'MemorySearchIndex.extractTerms',\n        details: `Invalid Unicode detected during term extraction${context?.entryId ? ` for entry ${context.entryId}` : ''}`,\n        metadata: {\n          entryId: context?.entryId,\n          issueCount: 0  // UnicodeValidationResult doesn't expose issues\n        }\n      });\n\n      return new Set();\n    }\n\n    const text = normalized.normalizedContent.toLowerCase();\n    const terms = new Set<string>();\n\n    // Simple tokenization (can be improved with better NLP)\n    const words = text.match(/\\b\\w+\\b/g) || [];\n\n    let termCount = 0;\n    for (const word of words) {\n      if (word.length >= (this.config.minTermLength || 2)) {\n        terms.add(word);\n        termCount++;\n        if (termCount >= (this.config.maxTermsPerEntry || 100)) {\n          break;\n        }\n      }\n    }\n\n    return terms;\n  }\n\n  clear(): void {\n    this.termToEntries.clear();\n    this.entryToTerms.clear();\n  }\n\n  get size(): number {\n    return this.termToEntries.size;\n  }\n}\n\n/**\n * Date range index using sorted array for efficient range queries\n */\nclass TemporalIndex {\n  private entries: Array<{ id: string; timestamp: number }> = [];\n\n  addEntry(entryId: string, date: Date): void {\n    const timestamp = date.getTime();\n\n    // Binary search for insertion point\n    let left = 0;\n    let right = this.entries.length;\n\n    while (left < right) {\n      const mid = Math.floor((left + right) / 2);\n      if (this.entries[mid].timestamp < timestamp) {\n        left = mid + 1;\n      } else {\n        right = mid;\n      }\n    }\n\n    // Insert at correct position to maintain sort\n    this.entries.splice(left, 0, { id: entryId, timestamp });\n  }\n\n  removeEntry(entryId: string): void {\n    const index = this.entries.findIndex(e => e.id === entryId);\n    if (index >= 0) {\n      this.entries.splice(index, 1);\n    }\n  }\n\n  /**\n   * Find entries within date range\n   */\n  searchRange(from?: Date, to?: Date): Set<string> {\n    const results = new Set<string>();\n    const fromTime = from?.getTime() || 0;\n    const toTime = to?.getTime() || Date.now();\n\n    // Binary search for start\n    let start = 0;\n    let end = this.entries.length;\n\n    while (start < end) {\n      const mid = Math.floor((start + end) / 2);\n      if (this.entries[mid].timestamp < fromTime) {\n        start = mid + 1;\n      } else {\n        end = mid;\n      }\n    }\n\n    // Collect all entries in range\n    for (let i = start; i < this.entries.length; i++) {\n      const entry = this.entries[i];\n      if (entry.timestamp > toTime) break;\n      results.add(entry.id);\n    }\n\n    return results;\n  }\n\n  clear(): void {\n    this.entries = [];\n  }\n\n  get size(): number {\n    return this.entries.length;\n  }\n\n  serialize(): any {\n    return this.entries;\n  }\n\n  deserialize(data: any): void {\n    this.entries = data || [];\n  }\n}\n\n/**\n * Main search index for Memory elements\n */\nexport class MemorySearchIndex {\n  private readonly config: SearchIndexConfig;\n\n  // Indexes\n  private tagIndex = new Map<string, Set<string>>();\n  private privacyIndex = new Map<PrivacyLevel, Set<string>>();\n  private contentIndex: ContentIndex | null = null;\n  private temporalIndex = new TemporalIndex();\n\n  // Cached entries for scoring\n  private entriesCache = new Map<string, MemoryEntry>();\n\n  // Index state\n  private isBuilt = false;\n  private isBuilding = false;\n  private buildQueue: Promise<void> | null = null;\n  private stats: SearchIndexStats = {\n    isIndexed: false,\n    entryCount: 0,\n    tagCount: 0,\n    termCount: 0,\n    memoryUsageBytes: 0\n  };\n\n  // Memory management\n  private readonly maxMemoryBytes: number;\n  private memoryUsageBytes = 0;\n\n  constructor(config: SearchIndexConfig = {}) {\n    this.config = {\n      indexThreshold: config.indexThreshold || 100,\n      enableContentIndex: config.enableContentIndex !== false,\n      maxTermsPerEntry: config.maxTermsPerEntry || 100,\n      minTermLength: config.minTermLength || 2,\n      enablePersistence: config.enablePersistence || false,\n      maxMemoryMB: config.maxMemoryMB || 100,\n      enableLRUEviction: config.enableLRUEviction !== false\n    };\n\n    // Configure memory limit (default 100MB, configurable)\n    this.maxMemoryBytes = (this.config.maxMemoryMB || 100) * 1024 * 1024;\n\n    if (this.config.enableContentIndex) {\n      this.contentIndex = new ContentIndex(this.config);\n    }\n\n    logger.debug('MemorySearchIndex created', this.config);\n  }\n\n  /**\n   * Build or rebuild the index from entries\n   * FIX: Added race condition protection with isBuilding flag and build queue\n   */\n  async buildIndex(entries: Map<string, MemoryEntry>): Promise<void> {\n    // If already building, wait for the current build to complete\n    if (this.isBuilding && this.buildQueue) {\n      logger.debug('Index build already in progress, waiting...');\n      return this.buildQueue;\n    }\n\n    // Create build promise to handle concurrent calls\n    this.buildQueue = this._doBuildIndex(entries);\n    return this.buildQueue;\n  }\n\n  private async _doBuildIndex(entries: Map<string, MemoryEntry>): Promise<void> {\n    // Prevent concurrent builds\n    if (this.isBuilding) {\n      logger.warn('Attempted concurrent index build, skipping');\n      return;\n    }\n\n    this.isBuilding = true;\n    const startTime = Date.now();\n\n    try {\n      // Clear existing indexes\n      this.clear();\n\n      // Check if we should index based on threshold\n      if (entries.size < (this.config.indexThreshold || 100)) {\n        logger.debug('Not building index - below threshold', {\n          entryCount: entries.size,\n          threshold: this.config.indexThreshold\n        });\n        return;\n      }\n\n      // Build indexes\n      for (const [id, entry] of entries) {\n        this.addToIndex(id, entry);\n      }\n\n      // Calculate memory usage\n      this.updateMemoryUsage();\n\n      // SECURITY FIX: Log security event for index build operation (DMCP-SEC-006)\n      SecurityMonitor.logSecurityEvent({\n        type: MEMORY_SECURITY_EVENTS.MEMORY_CREATED as any,  // Using CREATED for index build\n        severity: 'LOW',\n        source: 'MemorySearchIndex.buildIndex',\n        details: `Memory search index built successfully with ${entries.size} entries`,\n        metadata: {\n          entryCount: entries.size,\n          tagCount: this.tagIndex.size,\n          memoryUsageBytes: this.memoryUsageBytes\n        }\n      });\n\n      // Update stats\n      const buildTime = Date.now() - startTime;\n      this.stats = {\n        isIndexed: true,\n        entryCount: entries.size,\n        tagCount: this.tagIndex.size,\n        termCount: this.contentIndex?.size || 0,\n        lastBuilt: new Date(),\n        buildTimeMs: buildTime,\n        memoryUsageBytes: this.memoryUsageBytes\n      };\n\n      this.isBuilt = true;\n\n      logger.info('Memory search index built', this.stats);\n    } catch (error) {\n      logger.error('Failed to build memory search index', error);\n      // Reset state on failure\n      this.clear();\n      throw error;\n    } finally {\n      this.isBuilding = false;\n      this.buildQueue = null;\n    }\n  }\n\n  /**\n   * Add a single entry to the index (incremental update)\n   */\n  addEntry(entry: MemoryEntry): void {\n    if (!this.isBuilt) return;\n\n    this.addToIndex(entry.id, entry);\n    this.stats.entryCount++;\n\n    logger.debug('Entry added to index', { id: entry.id });\n  }\n\n  /**\n   * Remove an entry from the index\n   */\n  removeEntry(entryId: string): void {\n    if (!this.isBuilt) return;\n\n    const entry = this.entriesCache.get(entryId);\n    if (!entry) return;\n\n    // Remove from tag index\n    if (entry.metadata?.tags) {\n      for (const tag of entry.metadata.tags) {\n        const entries = this.tagIndex.get(tag);\n        if (entries) {\n          entries.delete(entryId);\n          if (entries.size === 0) {\n            this.tagIndex.delete(tag);\n          }\n        }\n      }\n    }\n\n    // Remove from privacy index\n    const privacyLevel = entry.metadata?.privacyLevel || entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;\n    const privacyEntries = this.privacyIndex.get(privacyLevel);\n    if (privacyEntries) {\n      privacyEntries.delete(entryId);\n    }\n\n    // Remove from content index\n    this.contentIndex?.removeEntry(entryId);\n\n    // Remove from temporal index\n    this.temporalIndex.removeEntry(entryId);\n\n    // Remove from cache\n    this.entriesCache.delete(entryId);\n\n    this.stats.entryCount--;\n\n    logger.debug('Entry removed from index', { id: entryId });\n  }\n\n  /**\n   * Search the index with multiple criteria\n   */\n  search(query: SearchQuery, entries: Map<string, MemoryEntry>): SearchResult[] {\n    if (!this.isBuilt) {\n      logger.debug('Index not built, falling back to linear search');\n      return this.linearSearch(query, entries);\n    }\n\n    // Start with all entries or filtered by privacy\n    let candidateIds: Set<string> | null = null;\n\n    // Filter by privacy level\n    if (query.privacyLevel) {\n      candidateIds = new Set(this.privacyIndex.get(query.privacyLevel) || []);\n    }\n\n    // Filter by tags (intersection)\n    if (query.tags && query.tags.length > 0) {\n      const tagResults = new Set<string>();\n      for (const tag of query.tags) {\n        const entries = this.tagIndex.get(tag.toLowerCase());\n        if (entries) {\n          if (candidateIds) {\n            // Intersection with existing candidates\n            for (const id of entries) {\n              if (candidateIds.has(id)) {\n                tagResults.add(id);\n              }\n            }\n          } else {\n            // First filter\n            entries.forEach(id => tagResults.add(id));\n          }\n        }\n      }\n      candidateIds = tagResults;\n    }\n\n    // Filter by date range\n    if (query.dateFrom || query.dateTo) {\n      const dateResults = this.temporalIndex.searchRange(query.dateFrom, query.dateTo);\n      if (candidateIds) {\n        // Intersection\n        const intersection = new Set<string>();\n        for (const id of candidateIds) {\n          if (dateResults.has(id)) {\n            intersection.add(id);\n          }\n        }\n        candidateIds = intersection;\n      } else {\n        candidateIds = dateResults;\n      }\n    }\n\n    // Score by content if provided\n    const contentScores = query.content && this.contentIndex\n      ? this.contentIndex.search(query.content)\n      : new Map<string, number>();\n\n    // Build results\n    const results: SearchResult[] = [];\n    const searchEntries = candidateIds || new Set(entries.keys());\n\n    for (const id of searchEntries) {\n      const entry = entries.get(id);\n      if (!entry) continue;\n\n      // Calculate score\n      let score = 1;\n\n      // Content relevance score\n      if (contentScores.has(id)) {\n        score += contentScores.get(id)! * 2;\n      }\n\n      // Tag match bonus\n      if (query.tags && entry.metadata?.tags) {\n        const matchedTags = query.tags.filter(tag =>\n          entry.metadata?.tags?.includes(tag)\n        );\n        score += matchedTags.length;\n      }\n\n      results.push({\n        entry,\n        score,\n        matches: {\n          tags: query.tags?.filter(tag => entry.metadata?.tags?.includes(tag)),\n          terms: query.content ? ['indexed'] : undefined\n        }\n      });\n    }\n\n    // Sort by score and apply pagination\n    results.sort((a, b) => b.score - a.score);\n\n    const offset = query.offset || 0;\n    const limit = query.limit || 100;\n\n    return results.slice(offset, offset + limit);\n  }\n\n  /**\n   * Fallback linear search when index is not available\n   */\n  private linearSearch(query: SearchQuery, entries: Map<string, MemoryEntry>): SearchResult[] {\n    const results: SearchResult[] = [];\n\n    for (const [id, entry] of entries) {\n      // Check privacy level\n      if (query.privacyLevel && entry.metadata?.privacyLevel !== query.privacyLevel) {\n        continue;\n      }\n\n      // Check date range\n      if (query.dateFrom && entry.metadata?.timestamp && entry.metadata.timestamp < query.dateFrom) {\n        continue;\n      }\n      if (query.dateTo && entry.metadata?.timestamp && entry.metadata.timestamp > query.dateTo) {\n        continue;\n      }\n\n      // Check tags\n      if (query.tags && query.tags.length > 0) {\n        const hasAllTags = query.tags.every(tag =>\n          entry.metadata?.tags?.includes(tag)\n        );\n        if (!hasAllTags) continue;\n      }\n\n      // Check content (simple substring match)\n      let score = 1;\n      if (query.content) {\n        const normalized = UnicodeValidator.normalize(query.content);\n        if (normalized.isValid) {\n          const searchTerm = normalized.normalizedContent.toLowerCase();\n          if (entry.content.toLowerCase().includes(searchTerm)) {\n            score += 2;\n          }\n        }\n      }\n\n      results.push({\n        entry,\n        score,\n        matches: {\n          tags: query.tags?.filter(tag => entry.metadata?.tags?.includes(tag))\n        }\n      });\n    }\n\n    // Sort and paginate\n    results.sort((a, b) => b.score - a.score);\n    const offset = query.offset || 0;\n    const limit = query.limit || 100;\n\n    return results.slice(offset, offset + limit);\n  }\n\n  /**\n   * Internal helper to add entry to all indexes\n   */\n  private addToIndex(id: string, entry: MemoryEntry): void {\n    // Cache entry\n    this.entriesCache.set(id, entry);\n\n    // Add to tag index\n    if (entry.metadata?.tags) {\n      for (const tag of entry.metadata.tags) {\n        const normalizedTag = tag.toLowerCase();\n        let entries = this.tagIndex.get(normalizedTag);\n        if (!entries) {\n          entries = new Set();\n          this.tagIndex.set(normalizedTag, entries);\n        }\n        entries.add(id);\n      }\n    }\n\n    // Add to privacy index\n    const privacyLevel = entry.metadata?.privacyLevel || entry.privacyLevel || MEMORY_CONSTANTS.DEFAULT_PRIVACY_LEVEL;\n    let privacyEntries = this.privacyIndex.get(privacyLevel);\n    if (!privacyEntries) {\n      privacyEntries = new Set();\n      this.privacyIndex.set(privacyLevel, privacyEntries);\n    }\n    privacyEntries.add(id);\n\n    // Add to content index\n    if (this.contentIndex) {\n      this.contentIndex.addEntry(id, entry.content);\n    }\n\n    // Add to temporal index\n    this.temporalIndex.addEntry(id, entry.metadata?.timestamp || entry.timestamp);\n  }\n\n  /**\n   * Clear all indexes\n   */\n  clear(): void {\n    this.tagIndex.clear();\n    this.privacyIndex.clear();\n    this.contentIndex?.clear();\n    this.temporalIndex.clear();\n    this.entriesCache.clear();\n    this.isBuilt = false;\n    this.stats = {\n      isIndexed: false,\n      entryCount: 0,\n      tagCount: 0,\n      termCount: 0\n    };\n  }\n\n  /**\n   * Get index statistics\n   */\n  getStats(): SearchIndexStats {\n    return { ...this.stats };\n  }\n\n  /**\n   * Check if index is built\n   */\n  get isIndexed(): boolean {\n    return this.isBuilt;\n  }\n\n  /**\n   * Calculate and update memory usage\n   * FIX: Added memory monitoring for content index\n   */\n  private updateMemoryUsage(): void {\n    let totalBytes = 0;\n\n    // Estimate tag index memory\n    for (const [tag, entries] of this.tagIndex) {\n      totalBytes += tag.length * 2; // UTF-16 encoding\n      totalBytes += entries.size * 32; // Estimated ID size\n    }\n\n    // Estimate content index memory\n    if (this.contentIndex) {\n      // Rough estimate: each term + entry IDs\n      totalBytes += this.contentIndex.size * 100;\n    }\n\n    // Estimate temporal index memory\n    totalBytes += this.temporalIndex.size * 48; // Date + ID\n\n    // Estimate cache memory\n    for (const entry of this.entriesCache.values()) {\n      totalBytes += JSON.stringify(entry).length * 2;\n    }\n\n    this.memoryUsageBytes = totalBytes;\n\n    // Check if we're exceeding memory limit\n    if (totalBytes > this.maxMemoryBytes) {\n      logger.warn('Memory search index exceeding limit', {\n        usedMB: Math.round(totalBytes / 1024 / 1024),\n        limitMB: Math.round(this.maxMemoryBytes / 1024 / 1024)\n      });\n\n      // Trigger LRU eviction if enabled\n      if (this.config.enableLRUEviction) {\n        this.evictLRUEntries();\n      }\n    }\n  }\n\n  /**\n   * Evict least recently used entries to free memory\n   * FIX: Added LRU eviction for memory management\n   */\n  private evictLRUEntries(): void {\n    // Get entries sorted by access time (would need to track this)\n    // For now, evict oldest 20% of entries\n    const entriesToEvict = Math.floor(this.entriesCache.size * 0.2);\n    const entriesArray = Array.from(this.entriesCache.keys());\n\n    for (let i = 0; i < entriesToEvict; i++) {\n      const idToEvict = entriesArray[i];\n      this.removeEntry(idToEvict);\n    }\n\n    logger.info('Evicted LRU entries', {\n      evictedCount: entriesToEvict,\n      remainingCount: this.entriesCache.size\n    });\n  }\n\n  /**\n   * Serialize index to JSON for persistence\n   * FIX: Added index serialization for cold start optimization\n   */\n  serialize(): string {\n    if (!this.isBuilt) {\n      throw new Error('Cannot serialize unbuilt index');\n    }\n\n    const indexData = {\n      version: '1.0.0',\n      stats: this.stats,\n      tagIndex: Array.from(this.tagIndex.entries()).map(([tag, ids]) => ({\n        tag,\n        ids: Array.from(ids)\n      })),\n      privacyIndex: Array.from(this.privacyIndex.entries()).map(([level, ids]) => ({\n        level,\n        ids: Array.from(ids)\n      })),\n      temporalIndex: this.temporalIndex.serialize(),\n      // Note: Content index is not serialized due to size\n      // It will be rebuilt on load if needed\n    };\n\n    return JSON.stringify(indexData);\n  }\n\n  /**\n   * Deserialize index from JSON\n   * FIX: Added index deserialization for faster startup\n   */\n  deserialize(data: string, entries: Map<string, MemoryEntry>): void {\n    try {\n      const indexData = JSON.parse(data);\n\n      // Validate version\n      if (indexData.version !== '1.0.0') {\n        throw new Error(`Unsupported index version: ${indexData.version}`);\n      }\n\n      // Clear existing indexes\n      this.clear();\n\n      // Restore tag index\n      for (const { tag, ids } of indexData.tagIndex) {\n        this.tagIndex.set(tag, new Set(ids));\n      }\n\n      // Restore privacy index\n      for (const { level, ids } of indexData.privacyIndex) {\n        this.privacyIndex.set(level as PrivacyLevel, new Set(ids));\n      }\n\n      // Restore temporal index\n      this.temporalIndex.deserialize(indexData.temporalIndex);\n\n      // Restore entries cache from provided entries\n      for (const [id, entry] of entries) {\n        if (indexData.tagIndex.some((item: any) => item.ids.includes(id))) {\n          this.entriesCache.set(id, entry);\n        }\n      }\n\n      // Rebuild content index if enabled (can't serialize efficiently)\n      if (this.config.enableContentIndex) {\n        this.contentIndex = new ContentIndex(this.config);\n        for (const [id, entry] of this.entriesCache) {\n          this.contentIndex.addEntry(id, entry.content);\n        }\n      }\n\n      // Update stats\n      this.stats = indexData.stats;\n      this.isBuilt = true;\n\n      logger.info('Memory search index deserialized', this.stats);\n    } catch (error) {\n      logger.error('Failed to deserialize index, rebuilding', error);\n      // Fall back to building from scratch\n      this.buildIndex(entries);\n    }\n  }\n}"]}