@danielsimonjr/memory-mcp 0.7.1 → 0.41.0

package/dist/search/SearchSuggestions.js

@@ -0,0 +1,57 @@
+/**
+ * Search Suggestions
+ *
+ * Provides "did you mean?" suggestions using Levenshtein distance.
+ *
+ * @module search/SearchSuggestions
+ */
+import { levenshteinDistance } from '../utils/levenshtein.js';
+/**
+ * Generates search suggestions based on entity names and types.
+ */
+export class SearchSuggestions {
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Get "did you mean?" suggestions for a query.
+     *
+     * Returns similar entity names and types that might be what the user intended.
+     * Excludes exact matches (similarity < 1.0) and very dissimilar strings (similarity > 0.5).
+     *
+     * @param query - The search query
+     * @param maxSuggestions - Maximum number of suggestions to return (default 5)
+     * @returns Array of suggested entity/type names sorted by similarity
+     */
+    async getSearchSuggestions(query, maxSuggestions = 5) {
+        const graph = await this.storage.loadGraph();
+        const queryLower = query.toLowerCase();
+        const suggestions = [];
+        // Check entity names
+        for (const entity of graph.entities) {
+            const distance = levenshteinDistance(queryLower, entity.name.toLowerCase());
+            const maxLength = Math.max(queryLower.length, entity.name.length);
+            const similarity = 1 - distance / maxLength;
+            if (similarity > 0.5 && similarity < 1.0) {
+                // Not exact match but similar
+                suggestions.push({ text: entity.name, similarity });
+            }
+        }
+        // Check entity types
+        const uniqueTypes = [...new Set(graph.entities.map(e => e.entityType))];
+        for (const type of uniqueTypes) {
+            const distance = levenshteinDistance(queryLower, type.toLowerCase());
+            const maxLength = Math.max(queryLower.length, type.length);
+            const similarity = 1 - distance / maxLength;
+            if (similarity > 0.5 && similarity < 1.0) {
+                suggestions.push({ text: type, similarity });
+            }
+        }
+        // Sort by similarity and return top suggestions
+        return suggestions
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, maxSuggestions)
+            .map(s => s.text);
+    }
+}

package/dist/search/TFIDFIndexManager.js

@@ -0,0 +1,217 @@
+/**
+ * TF-IDF Index Manager
+ *
+ * Manages pre-calculated TF-IDF indexes for fast ranked search.
+ * Handles index building, incremental updates, and persistence.
+ *
+ * @module search/TFIDFIndexManager
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { calculateIDF, tokenize } from '../utils/tfidf.js';
+const INDEX_VERSION = '1.0';
+const INDEX_FILENAME = 'tfidf-index.json';
+/**
+ * Manages TF-IDF index lifecycle: building, updating, and persistence.
+ */
+export class TFIDFIndexManager {
+    indexPath;
+    index = null;
+    constructor(storageDir) {
+        this.indexPath = path.join(storageDir, '.indexes', INDEX_FILENAME);
+    }
+    /**
+     * Build a complete TF-IDF index from a knowledge graph.
+     *
+     * @param graph - Knowledge graph to index
+     * @returns Newly built TF-IDF index
+     */
+    async buildIndex(graph) {
+        const documents = new Map();
+        const allDocumentTexts = [];
+        const allTokens = [];
+        // Build document vectors
+        for (const entity of graph.entities) {
+            const documentText = [
+                entity.name,
+                entity.entityType,
+                ...entity.observations,
+            ].join(' ');
+            allDocumentTexts.push(documentText);
+            const tokens = tokenize(documentText);
+            allTokens.push(tokens);
+            // Calculate term frequencies
+            const termFreq = {};
+            for (const term of tokens) {
+                termFreq[term] = (termFreq[term] || 0) + 1;
+            }
+            documents.set(entity.name, {
+                entityName: entity.name,
+                terms: termFreq,
+                documentText,
+            });
+        }
+        // Calculate IDF for all terms
+        const idf = new Map();
+        const allTerms = new Set(allTokens.flat());
+        for (const term of allTerms) {
+            const idfScore = calculateIDF(term, allDocumentTexts);
+            idf.set(term, idfScore);
+        }
+        this.index = {
+            version: INDEX_VERSION,
+            lastUpdated: new Date().toISOString(),
+            documents,
+            idf,
+        };
+        return this.index;
+    }
+    /**
+     * Update the index incrementally when entities change.
+     *
+     * More efficient than rebuilding the entire index.
+     *
+     * @param graph - Updated knowledge graph
+     * @param changedEntityNames - Names of entities that changed
+     */
+    async updateIndex(graph, changedEntityNames) {
+        if (!this.index) {
+            // No existing index, build from scratch
+            return this.buildIndex(graph);
+        }
+        // Rebuild document vectors for changed entities
+        const allDocumentTexts = [];
+        const allTokens = [];
+        const updatedDocuments = new Map(this.index.documents);
+        // Remove deleted entities
+        for (const entityName of changedEntityNames) {
+            const entity = graph.entities.find(e => e.name === entityName);
+            if (!entity) {
+                updatedDocuments.delete(entityName);
+            }
+        }
+        // Update/add changed entities
+        for (const entity of graph.entities) {
+            const documentText = [
+                entity.name,
+                entity.entityType,
+                ...entity.observations,
+            ].join(' ');
+            allDocumentTexts.push(documentText);
+            const tokens = tokenize(documentText);
+            allTokens.push(tokens);
+            if (changedEntityNames.has(entity.name)) {
+                // Calculate term frequencies for changed entity
+                const termFreq = {};
+                for (const term of tokens) {
+                    termFreq[term] = (termFreq[term] || 0) + 1;
+                }
+                updatedDocuments.set(entity.name, {
+                    entityName: entity.name,
+                    terms: termFreq,
+                    documentText,
+                });
+            }
+        }
+        // Recalculate IDF (need all documents for accurate IDF)
+        const idf = new Map();
+        const allTerms = new Set(allTokens.flat());
+        for (const term of allTerms) {
+            const idfScore = calculateIDF(term, allDocumentTexts);
+            idf.set(term, idfScore);
+        }
+        this.index = {
+            version: INDEX_VERSION,
+            lastUpdated: new Date().toISOString(),
+            documents: updatedDocuments,
+            idf,
+        };
+        return this.index;
+    }
+    /**
+     * Load index from disk.
+     *
+     * @returns Loaded index or null if not found
+     */
+    async loadIndex() {
+        try {
+            const data = await fs.readFile(this.indexPath, 'utf-8');
+            const serialized = JSON.parse(data);
+            this.index = {
+                version: serialized.version,
+                lastUpdated: serialized.lastUpdated,
+                documents: new Map(serialized.documents),
+                idf: new Map(serialized.idf),
+            };
+            return this.index;
+        }
+        catch (error) {
+            // Index doesn't exist or is invalid
+            return null;
+        }
+    }
+    /**
+     * Save index to disk.
+     *
+     * @param index - Index to save (uses cached index if not provided)
+     */
+    async saveIndex(index) {
+        const indexToSave = index || this.index;
+        if (!indexToSave) {
+            throw new Error('No index to save');
+        }
+        // Ensure index directory exists
+        const indexDir = path.dirname(this.indexPath);
+        await fs.mkdir(indexDir, { recursive: true });
+        // Serialize Map objects to arrays for JSON
+        const serialized = {
+            version: indexToSave.version,
+            lastUpdated: indexToSave.lastUpdated,
+            documents: Array.from(indexToSave.documents.entries()),
+            idf: Array.from(indexToSave.idf.entries()),
+        };
+        await fs.writeFile(this.indexPath, JSON.stringify(serialized, null, 2), 'utf-8');
+    }
+    /**
+     * Get the current cached index.
+     *
+     * @returns Cached index or null if not loaded
+     */
+    getIndex() {
+        return this.index;
+    }
+    /**
+     * Clear the cached index and delete from disk.
+     */
+    async clearIndex() {
+        this.index = null;
+        try {
+            await fs.unlink(this.indexPath);
+        }
+        catch {
+            // Index file doesn't exist, nothing to delete
+        }
+    }
+    /**
+     * Check if the index needs rebuilding based on graph state.
+     *
+     * @param graph - Current knowledge graph
+     * @returns True if index should be rebuilt
+     */
+    needsRebuild(graph) {
+        if (!this.index) {
+            return true;
+        }
+        // Check if entity count matches
+        if (this.index.documents.size !== graph.entities.length) {
+            return true;
+        }
+        // Check if all entities are in index
+        for (const entity of graph.entities) {
+            if (!this.index.documents.has(entity.name)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/dist/search/index.js

@@ -0,0 +1,10 @@
+/**
+ * Search Module Barrel Export
+ */
+export { BasicSearch } from './BasicSearch.js';
+export { RankedSearch } from './RankedSearch.js';
+export { BooleanSearch } from './BooleanSearch.js';
+export { FuzzySearch } from './FuzzySearch.js';
+export { SearchSuggestions } from './SearchSuggestions.js';
+export { SavedSearchManager } from './SavedSearchManager.js';
+export { SearchManager } from './SearchManager.js';