@danielsimonjr/memory-mcp 12.2.3 → 12.5.2

package/dist/utils/searchAlgorithms.js

@@ -1,167 +0,0 @@
-/**
- * Search Algorithms
- *
- * Algorithms for search operations: Levenshtein distance for fuzzy matching
- * and TF-IDF for relevance scoring.
- *
- * @module utils/searchAlgorithms
- */
-// ==================== Levenshtein Distance ====================
-/**
- * Calculate Levenshtein distance between two strings.
- *
- * Returns the minimum number of single-character edits needed to change
- * one word into another.
- *
- * **Algorithm**: Space-optimized dynamic programming using only two rows.
- * Time complexity: O(m*n), Space complexity: O(min(m,n)).
- *
- * This optimization reduces memory usage from O(m*n) to O(min(m,n)) by
- * observing that each row only depends on the previous row.
- *
- * @param str1 - First string to compare
- * @param str2 - Second string to compare
- * @returns Minimum number of edits required (0 = identical strings)
- *
- * @example
- * ```typescript
- * levenshteinDistance("kitten", "sitting"); // Returns 3
- * levenshteinDistance("hello", "hello");    // Returns 0
- * levenshteinDistance("abc", "");           // Returns 3
- * ```
- */
-export function levenshteinDistance(str1, str2) {
-    // Ensure str1 is the shorter string for optimal space usage
-    if (str1.length > str2.length) {
-        [str1, str2] = [str2, str1];
-    }
-    const m = str1.length;
-    const n = str2.length;
-    // Use two rows instead of full matrix - O(min(m,n)) space
-    let prev = Array.from({ length: m + 1 }, (_, i) => i);
-    let curr = new Array(m + 1);
-    for (let j = 1; j <= n; j++) {
-        curr[0] = j; // Distance from empty string
-        for (let i = 1; i <= m; i++) {
-            if (str1[i - 1] === str2[j - 1]) {
-                // Characters match, no edit needed
-                curr[i] = prev[i - 1];
-            }
-            else {
-                // Take minimum of three operations
-                curr[i] = 1 + Math.min(prev[i - 1], // substitution
-                prev[i], // deletion
-                curr[i - 1] // insertion
-                );
-            }
-        }
-        // Swap rows for next iteration
-        [prev, curr] = [curr, prev];
-    }
-    return prev[m];
-}
-// ==================== TF-IDF ====================
-/**
- * Calculate Term Frequency (TF) for a term in a document.
- *
- * TF = (Number of times term appears in document) / (Total terms in document)
- *
- * @param term - The search term
- * @param document - The document text
- * @returns Term frequency (0.0 to 1.0)
- */
-export function calculateTF(term, document) {
-    const termLower = term.toLowerCase();
-    const tokens = tokenize(document);
-    if (tokens.length === 0)
-        return 0;
-    const termCount = tokens.filter(t => t === termLower).length;
-    return termCount / tokens.length;
-}
-/**
- * Calculate Inverse Document Frequency (IDF) for a term across documents.
- *
- * IDF = log(Total documents / Documents containing term)
- *
- * Note: For bulk IDF calculation, prefer calculateIDFFromTokenSets which
- * avoids re-tokenizing documents for each term.
- *
- * @param term - The search term
- * @param documents - Array of document texts
- * @returns Inverse document frequency
- */
-export function calculateIDF(term, documents) {
-    if (documents.length === 0)
-        return 0;
-    const termLower = term.toLowerCase();
-    const docsWithTerm = documents.filter(doc => tokenize(doc).includes(termLower)).length;
-    if (docsWithTerm === 0)
-        return 0;
-    return Math.log(documents.length / docsWithTerm);
-}
-/**
- * Calculate Inverse Document Frequency (IDF) from pre-tokenized documents.
- *
- * IDF = log(Total documents / Documents containing term)
- *
- * **Optimized**: Avoids re-tokenizing documents for each term. Pre-tokenize
- * documents once and convert to Sets for O(1) lookup per document.
- *
- * @param term - The search term (should already be lowercase)
- * @param tokenSets - Array of Sets, each containing unique tokens for a document
- * @returns Inverse document frequency
- *
- * @example
- * ```typescript
- * const docs = ["hello world", "hello there"];
- * const tokenSets = docs.map(d => new Set(tokenize(d)));
- * calculateIDFFromTokenSets("hello", tokenSets); // Low IDF (common term)
- * calculateIDFFromTokenSets("world", tokenSets); // Higher IDF (less common)
- * ```
- */
-export function calculateIDFFromTokenSets(term, tokenSets) {
-    if (tokenSets.length === 0)
-        return 0;
-    const termLower = term.toLowerCase();
-    let docsWithTerm = 0;
-    for (const tokenSet of tokenSets) {
-        if (tokenSet.has(termLower)) {
-            docsWithTerm++;
-        }
-    }
-    if (docsWithTerm === 0)
-        return 0;
-    return Math.log(tokenSets.length / docsWithTerm);
-}
-/**
- * Calculate TF-IDF score for a term in a document.
- *
- * TF-IDF = TF * IDF
- *
- * Higher scores indicate more important/relevant terms.
- *
- * @param term - The search term
- * @param document - The document text
- * @param documents - Array of all documents
- * @returns TF-IDF score
- */
-export function calculateTFIDF(term, document, documents) {
-    const tf = calculateTF(term, document);
-    const idf = calculateIDF(term, documents);
-    return tf * idf;
-}
-/**
- * Tokenize text into lowercase words.
- *
- * Splits on whitespace and removes punctuation.
- *
- * @param text - Text to tokenize
- * @returns Array of lowercase tokens
- */
-export function tokenize(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^\w\s]/g, ' ')
-        .split(/\s+/)
-        .filter(token => token.length > 0);
-}

package/dist/utils/searchCache.d.ts

@@ -1,108 +0,0 @@
-/**
- * Search Result Cache
- *
- * Simple LRU-style cache for search results with TTL support.
- * Improves performance for repeated queries without external dependencies.
- *
- * @module utils/searchCache
- */
-import type { SearchResult, KnowledgeGraph } from '../types/index.js';
-/**
- * Cache statistics for monitoring.
- */
-export interface CacheStats {
-    hits: number;
-    misses: number;
-    size: number;
-    hitRate: number;
-}
-/**
- * Simple LRU cache implementation for search results.
- *
- * Features:
- * - Maximum size limit (LRU eviction when full)
- * - TTL-based expiration
- * - Cache statistics tracking
- * - Hash-based key generation from query parameters
- */
-export declare class SearchCache<T = SearchResult[] | KnowledgeGraph> {
-    private maxSize;
-    private ttlMs;
-    private cache;
-    private accessOrder;
-    private hits;
-    private misses;
-    constructor(maxSize?: number, ttlMs?: number);
-    /**
-     * Generate cache key from query parameters.
-     */
-    private generateKey;
-    /**
-     * Get value from cache.
-     *
-     * @param params - Query parameters to generate cache key
-     * @returns Cached value or undefined if not found/expired
-     */
-    get(params: Record<string, unknown>): T | undefined;
-    /**
-     * Set value in cache.
-     *
-     * @param params - Query parameters to generate cache key
-     * @param value - Value to cache
-     */
-    set(params: Record<string, unknown>, value: T): void;
-    /**
-     * Invalidate all cached entries.
-     */
-    clear(): void;
-    /**
-     * Remove specific entry from access order.
-     */
-    private removeFromAccessOrder;
-    /**
-     * Get cache statistics.
-     */
-    getStats(): CacheStats;
-    /**
-     * Reset cache statistics.
-     */
-    resetStats(): void;
-    /**
-     * Clean up expired entries.
-     *
-     * Should be called periodically to prevent memory buildup.
-     */
-    cleanupExpired(): void;
-    /**
-     * Get current cache size.
-     */
-    get size(): number;
-    /**
-     * Check if cache has entry for params.
-     */
-    has(params: Record<string, unknown>): boolean;
-}
-/**
- * Global search caches for different search types.
- */
-export declare const searchCaches: {
-    basic: SearchCache<KnowledgeGraph>;
-    ranked: SearchCache<SearchResult[]>;
-    boolean: SearchCache<KnowledgeGraph>;
-    fuzzy: SearchCache<KnowledgeGraph>;
-};
-/**
- * Clear all search caches.
- *
- * Should be called when graph is modified to ensure cache consistency.
- */
-export declare function clearAllSearchCaches(): void;
-/**
- * Get combined statistics for all caches.
- */
-export declare function getAllCacheStats(): Record<string, CacheStats>;
-/**
- * Clean up expired entries in all caches.
- */
-export declare function cleanupAllCaches(): void;
-//# sourceMappingURL=searchCache.d.ts.map

package/dist/utils/searchCache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchCache.d.ts","sourceRoot":"","sources":["../../src/utils/searchCache.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAWtE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,qBAAa,WAAW,CAAC,CAAC,GAAG,YAAY,EAAE,GAAG,cAAc;IAOxD,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,KAAK;IAPf,OAAO,CAAC,KAAK,CAAyC;IACtD,OAAO,CAAC,WAAW,CAAgB;IACnC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAK;gBAGT,OAAO,GAAE,MAAY,EACrB,KAAK,GAAE,MAAsB;IAGvC;;OAEG;IACH,OAAO,CAAC,WAAW;IASnB;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,SAAS;IAyBnD;;;;;OAKG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAyBpD;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAO7B;;OAEG;IACH,QAAQ,IAAI,UAAU;IAUtB;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;;;OAIG;IACH,cAAc,IAAI,IAAI;IAgBtB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;CAe9C;AAED;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAK3C;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAO7D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAKvC"}

package/dist/utils/searchCache.js

@@ -1,209 +0,0 @@
-/**
- * Search Result Cache
- *
- * Simple LRU-style cache for search results with TTL support.
- * Improves performance for repeated queries without external dependencies.
- *
- * @module utils/searchCache
- */
-/**
- * Simple LRU cache implementation for search results.
- *
- * Features:
- * - Maximum size limit (LRU eviction when full)
- * - TTL-based expiration
- * - Cache statistics tracking
- * - Hash-based key generation from query parameters
- */
-export class SearchCache {
-    maxSize;
-    ttlMs;
-    cache = new Map();
-    accessOrder = [];
-    hits = 0;
-    misses = 0;
-    constructor(maxSize = 500, ttlMs = 5 * 60 * 1000 // 5 minutes default
-    ) {
-        this.maxSize = maxSize;
-        this.ttlMs = ttlMs;
-    }
-    /**
-     * Generate cache key from query parameters.
-     */
-    generateKey(params) {
-        // Sort keys for consistent hashing
-        const sorted = Object.keys(params)
-            .sort()
-            .map(key => `${key}:${JSON.stringify(params[key])}`)
-            .join('|');
-        return sorted;
-    }
-    /**
-     * Get value from cache.
-     *
-     * @param params - Query parameters to generate cache key
-     * @returns Cached value or undefined if not found/expired
-     */
-    get(params) {
-        const key = this.generateKey(params);
-        const entry = this.cache.get(key);
-        if (!entry) {
-            this.misses++;
-            return undefined;
-        }
-        // Check expiration
-        if (Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            this.removeFromAccessOrder(key);
-            this.misses++;
-            return undefined;
-        }
-        // Update access order (move to end = most recently used)
-        this.removeFromAccessOrder(key);
-        this.accessOrder.push(key);
-        this.hits++;
-        return entry.value;
-    }
-    /**
-     * Set value in cache.
-     *
-     * @param params - Query parameters to generate cache key
-     * @param value - Value to cache
-     */
-    set(params, value) {
-        const key = this.generateKey(params);
-        // Remove old entry if exists
-        if (this.cache.has(key)) {
-            this.removeFromAccessOrder(key);
-        }
-        // Evict least recently used if at capacity
-        if (this.cache.size >= this.maxSize && !this.cache.has(key)) {
-            const lruKey = this.accessOrder.shift();
-            if (lruKey) {
-                this.cache.delete(lruKey);
-            }
-        }
-        // Add new entry
-        this.cache.set(key, {
-            value,
-            timestamp: Date.now(),
-            expiresAt: Date.now() + this.ttlMs,
-        });
-        this.accessOrder.push(key);
-    }
-    /**
-     * Invalidate all cached entries.
-     */
-    clear() {
-        this.cache.clear();
-        this.accessOrder = [];
-    }
-    /**
-     * Remove specific entry from access order.
-     */
-    removeFromAccessOrder(key) {
-        const index = this.accessOrder.indexOf(key);
-        if (index > -1) {
-            this.accessOrder.splice(index, 1);
-        }
-    }
-    /**
-     * Get cache statistics.
-     */
-    getStats() {
-        const total = this.hits + this.misses;
-        return {
-            hits: this.hits,
-            misses: this.misses,
-            size: this.cache.size,
-            hitRate: total > 0 ? this.hits / total : 0,
-        };
-    }
-    /**
-     * Reset cache statistics.
-     */
-    resetStats() {
-        this.hits = 0;
-        this.misses = 0;
-    }
-    /**
-     * Clean up expired entries.
-     *
-     * Should be called periodically to prevent memory buildup.
-     */
-    cleanupExpired() {
-        const now = Date.now();
-        const keysToDelete = [];
-        for (const [key, entry] of this.cache.entries()) {
-            if (now > entry.expiresAt) {
-                keysToDelete.push(key);
-            }
-        }
-        for (const key of keysToDelete) {
-            this.cache.delete(key);
-            this.removeFromAccessOrder(key);
-        }
-    }
-    /**
-     * Get current cache size.
-     */
-    get size() {
-        return this.cache.size;
-    }
-    /**
-     * Check if cache has entry for params.
-     */
-    has(params) {
-        const key = this.generateKey(params);
-        const entry = this.cache.get(key);
-        if (!entry)
-            return false;
-        // Check expiration
-        if (Date.now() > entry.expiresAt) {
-            this.cache.delete(key);
-            this.removeFromAccessOrder(key);
-            return false;
-        }
-        return true;
-    }
-}
-/**
- * Global search caches for different search types.
- */
-export const searchCaches = {
-    basic: new SearchCache(),
-    ranked: new SearchCache(),
-    boolean: new SearchCache(),
-    fuzzy: new SearchCache(),
-};
-/**
- * Clear all search caches.
- *
- * Should be called when graph is modified to ensure cache consistency.
- */
-export function clearAllSearchCaches() {
-    searchCaches.basic.clear();
-    searchCaches.ranked.clear();
-    searchCaches.boolean.clear();
-    searchCaches.fuzzy.clear();
-}
-/**
- * Get combined statistics for all caches.
- */
-export function getAllCacheStats() {
-    return {
-        basic: searchCaches.basic.getStats(),
-        ranked: searchCaches.ranked.getStats(),
-        boolean: searchCaches.boolean.getStats(),
-        fuzzy: searchCaches.fuzzy.getStats(),
-    };
-}
-/**
- * Clean up expired entries in all caches.
- */
-export function cleanupAllCaches() {
-    searchCaches.basic.cleanupExpired();
-    searchCaches.ranked.cleanupExpired();
-    searchCaches.boolean.cleanupExpired();
-    searchCaches.fuzzy.cleanupExpired();
-}