@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/search/EmbeddingCache.js

@@ -1,246 +0,0 @@
-/**
- * Embedding Cache
- *
- * Phase 12 Sprint 5: LRU cache for embedding vectors with hit/miss tracking,
- * auto-invalidation on text hash changes, and TTL support.
- *
- * @module search/EmbeddingCache
- */
-import { createHash } from 'crypto';
-/**
- * Default cache options.
- */
-export const DEFAULT_EMBEDDING_CACHE_OPTIONS = {
-    maxSize: 1000,
-    ttlMs: 3600000, // 1 hour
-    dimensions: 384,
-};
-/**
- * LRU cache for embedding vectors with hit/miss tracking.
- *
- * Features:
- * - LRU eviction when max size is reached
- * - Text hash-based invalidation (detects stale entries)
- * - TTL support for automatic expiration
- * - Hit/miss statistics tracking
- *
- * @example
- * ```typescript
- * const cache = new EmbeddingCache({ maxSize: 500, ttlMs: 60000 });
- *
- * // Cache an embedding
- * cache.set('entity1', 'Original text content', [0.1, 0.2, ...]);
- *
- * // Retrieve from cache
- * const result = cache.get('entity1', 'Original text content');
- * if (result) {
- *   console.log('Cache hit!', result);
- * }
- *
- * // Check stats
- * console.log(cache.getStats()); // { size, memoryBytes, hitRate, hits, misses }
- * ```
- */
-export class EmbeddingCache {
-    cache;
-    options;
-    hits = 0;
-    misses = 0;
-    /**
-     * Create a new embedding cache.
-     *
-     * @param options - Cache configuration options
-     */
-    constructor(options) {
-        this.options = { ...DEFAULT_EMBEDDING_CACHE_OPTIONS, ...options };
-        this.cache = new Map();
-    }
-    /**
-     * Hash a text string for cache invalidation.
-     *
-     * @param text - Text to hash
-     * @returns MD5 hash of the text
-     */
-    hashText(text) {
-        return createHash('md5').update(text).digest('hex');
-    }
-    /**
-     * Check if an entry is expired based on TTL.
-     *
-     * @param entry - Cache entry to check
-     * @returns True if expired
-     */
-    isExpired(entry) {
-        return Date.now() - entry.createdAt > this.options.ttlMs;
-    }
-    /**
-     * Evict the least recently used entry.
-     */
-    evictLRU() {
-        let oldestKey = null;
-        let oldestTime = Infinity;
-        for (const [key, entry] of this.cache) {
-            if (entry.lastAccess < oldestTime) {
-                oldestTime = entry.lastAccess;
-                oldestKey = key;
-            }
-        }
-        if (oldestKey) {
-            this.cache.delete(oldestKey);
-        }
-    }
-    /**
-     * Get an embedding from the cache.
-     *
-     * Returns null if:
-     * - Key not found
-     * - Entry is expired (TTL)
-     * - Text hash doesn't match (content changed)
-     *
-     * @param key - Cache key (typically entity name)
-     * @param text - Current text content (for hash validation)
-     * @returns Embedding vector if found and valid, null otherwise
-     */
-    get(key, text) {
-        const entry = this.cache.get(key);
-        if (!entry) {
-            this.misses++;
-            return null;
-        }
-        // Check TTL
-        if (this.isExpired(entry)) {
-            this.cache.delete(key);
-            this.misses++;
-            return null;
-        }
-        // Check text hash for invalidation
-        const currentHash = this.hashText(text);
-        if (entry.textHash !== currentHash) {
-            this.cache.delete(key);
-            this.misses++;
-            return null;
-        }
-        // Update last access time
-        entry.lastAccess = Date.now();
-        this.hits++;
-        return entry.vector;
-    }
-    /**
-     * Set an embedding in the cache.
-     *
-     * Automatically evicts LRU entries if max size is reached.
-     *
-     * @param key - Cache key (typically entity name)
-     * @param text - Text content (used for hash-based invalidation)
-     * @param vector - Embedding vector to cache
-     */
-    set(key, text, vector) {
-        // Evict if at capacity and not updating existing key
-        if (this.cache.size >= this.options.maxSize && !this.cache.has(key)) {
-            this.evictLRU();
-        }
-        const now = Date.now();
-        this.cache.set(key, {
-            vector,
-            textHash: this.hashText(text),
-            createdAt: now,
-            lastAccess: now,
-        });
-    }
-    /**
-     * Check if a key exists in the cache (without affecting hit/miss stats).
-     *
-     * @param key - Cache key to check
-     * @returns True if key exists (may be expired or stale)
-     */
-    has(key) {
-        return this.cache.has(key);
-    }
-    /**
-     * Delete an entry from the cache.
-     *
-     * @param key - Cache key to delete
-     * @returns True if entry was deleted
-     */
-    delete(key) {
-        return this.cache.delete(key);
-    }
-    /**
-     * Clear all entries from the cache.
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Get cache statistics.
-     *
-     * @returns Cache statistics including size, memory usage, and hit rate
-     */
-    getStats() {
-        const size = this.cache.size;
-        // Estimate memory: each entry has vector (dimensions * 8 bytes for float64)
-        // plus overhead for hash (~32 bytes), timestamps (~16 bytes), and Map overhead (~50 bytes)
-        const memoryPerEntry = this.options.dimensions * 8 + 32 + 16 + 50;
-        const memoryBytes = size * memoryPerEntry;
-        const totalRequests = this.hits + this.misses;
-        const hitRate = totalRequests > 0 ? this.hits / totalRequests : 0;
-        return {
-            size,
-            memoryBytes,
-            hitRate,
-            hits: this.hits,
-            misses: this.misses,
-        };
-    }
-    /**
-     * Reset hit/miss statistics (useful for benchmarks).
-     */
-    resetStats() {
-        this.hits = 0;
-        this.misses = 0;
-    }
-    /**
-     * Remove expired entries from the cache.
-     *
-     * Called automatically during get operations, but can be
-     * manually triggered for maintenance.
-     *
-     * @returns Number of entries removed
-     */
-    pruneExpired() {
-        let removed = 0;
-        for (const [key, entry] of this.cache) {
-            if (this.isExpired(entry)) {
-                this.cache.delete(key);
-                removed++;
-            }
-        }
-        return removed;
-    }
-    /**
-     * Get the current cache size.
-     *
-     * @returns Number of entries in the cache
-     */
-    size() {
-        return this.cache.size;
-    }
-    /**
-     * Get all cached keys.
-     *
-     * @returns Array of cache keys
-     */
-    keys() {
-        return Array.from(this.cache.keys());
-    }
-    /**
-     * Update options dynamically.
-     *
-     * Note: Reducing maxSize will not immediately evict entries.
-     *
-     * @param options - New options to apply
-     */
-    updateOptions(options) {
-        this.options = { ...this.options, ...options };
-    }
-}

package/dist/search/HybridScorer.d.ts

@@ -1,181 +0,0 @@
-/**
- * Hybrid Scorer
- *
- * Combines semantic, lexical, and symbolic search scores with
- * min-max normalization and configurable weights.
- *
- * Phase 12 Sprint 3: Search Algorithm Optimization
- *
- * @module search/HybridScorer
- */
-import type { Entity } from '../types/index.js';
-/**
- * Result from semantic search layer.
- */
-export interface SemanticSearchResult {
-    /** Entity name */
-    entityName: string;
-    /** Similarity score (typically 0-1 for cosine similarity) */
-    similarity: number;
-    /** The matched entity (if resolved) */
-    entity?: Entity;
-}
-/**
- * Result from lexical search layer (TF-IDF or BM25).
- */
-export interface LexicalSearchResult {
-    /** Entity name */
-    entityName: string;
-    /** Relevance score (unbounded, higher is better) */
-    score: number;
-    /** The matched entity (if resolved) */
-    entity?: Entity;
-}
-/**
- * Result from symbolic search layer.
- */
-export interface SymbolicSearchResult {
-    /** Entity name */
-    entityName: string;
-    /** Match score (typically 0-1) */
-    score: number;
-    /** The matched entity (if resolved) */
-    entity?: Entity;
-}
-/**
- * Combined result with scores from all layers.
- */
-export interface ScoredResult {
-    /** Entity name */
-    entityName: string;
-    /** The matched entity */
-    entity: Entity;
-    /** Individual layer scores (normalized 0-1) */
-    scores: {
-        semantic: number;
-        lexical: number;
-        symbolic: number;
-        combined: number;
-    };
-    /** Which layers contributed to this result */
-    matchedLayers: ('semantic' | 'lexical' | 'symbolic')[];
-    /** Original raw scores before normalization */
-    rawScores: {
-        semantic?: number;
-        lexical?: number;
-        symbolic?: number;
-    };
-}
-/**
- * Configurable weights for hybrid scoring.
- */
-export interface HybridWeights {
-    /** Weight for semantic layer (default: 0.4) */
-    semantic: number;
-    /** Weight for lexical layer (default: 0.4) */
-    lexical: number;
-    /** Weight for symbolic layer (default: 0.2) */
-    symbolic: number;
-}
-/**
- * Default weights for hybrid search.
- */
-export declare const DEFAULT_SCORER_WEIGHTS: HybridWeights;
-/**
- * Options for the HybridScorer.
- */
-export interface HybridScorerOptions {
-    /** Weights for each layer */
-    weights?: Partial<HybridWeights>;
-    /** Minimum score to include in results (default: 0) */
-    minScore?: number;
-    /** Whether to normalize weights to sum to 1 (default: true) */
-    normalizeWeights?: boolean;
-}
-/**
- * HybridScorer combines multiple search signals using min-max normalization.
- *
- * Features:
- * 1. Min-max normalization brings all scores to 0-1 range
- * 2. Configurable weights for each layer
- * 3. Handles missing layers gracefully (redistributes weights)
- * 4. Tracks which layers contributed to each result
- *
- * @example
- * ```typescript
- * const scorer = new HybridScorer({
- *   weights: { semantic: 0.5, lexical: 0.3, symbolic: 0.2 }
- * });
- *
- * const results = scorer.combine(
- *   semanticResults,
- *   lexicalResults,
- *   symbolicResults,
- *   entityMap
- * );
- * ```
- */
-export declare class HybridScorer {
-    private weights;
-    private minScore;
-    private normalizeWeights;
-    constructor(options?: HybridScorerOptions);
-    /**
-     * Get current weights configuration.
-     */
-    getWeights(): HybridWeights;
-    /**
-     * Update weights configuration.
-     */
-    setWeights(weights: Partial<HybridWeights>): void;
-    /**
-     * Perform min-max normalization on scores.
-     *
-     * Formula: normalized = (x - min) / (max - min)
-     *
-     * @param scores - Map of entity name to raw score
-     * @returns Map of entity name to normalized score (0-1)
-     */
-    minMaxNormalize(scores: Map<string, number>): Map<string, number>;
-    /**
-     * Combine results from all three search layers.
-     *
-     * @param semanticResults - Results from semantic search
-     * @param lexicalResults - Results from lexical search
-     * @param symbolicResults - Results from symbolic search
-     * @param entityMap - Map of entity names to Entity objects
-     * @returns Array of combined results sorted by score
-     */
-    combine(semanticResults: SemanticSearchResult[], lexicalResults: LexicalSearchResult[], symbolicResults: SymbolicSearchResult[], entityMap: Map<string, Entity>): ScoredResult[];
-    /**
-     * Get weights normalized to sum to 1, redistributing for missing layers.
-     *
-     * @param hasSemantic - Whether semantic results are available
-     * @param hasLexical - Whether lexical results are available
-     * @param hasSymbolic - Whether symbolic results are available
-     * @returns Normalized weights
-     */
-    getNormalizedWeights(hasSemantic: boolean, hasLexical: boolean, hasSymbolic: boolean): HybridWeights;
-    /**
-     * Combine scores from maps directly (alternative interface).
-     *
-     * @param semanticScores - Map of entity name to semantic score
-     * @param lexicalScores - Map of entity name to lexical score
-     * @param symbolicScores - Map of entity name to symbolic score
-     * @param entityMap - Map of entity names to Entity objects
-     * @returns Array of combined results sorted by score
-     */
-    combineFromMaps(semanticScores: Map<string, number>, lexicalScores: Map<string, number>, symbolicScores: Map<string, number>, entityMap: Map<string, Entity>): ScoredResult[];
-    /**
-     * Calculate combined score for a single entity.
-     *
-     * Useful for scoring individual results without full normalization.
-     *
-     * @param semanticScore - Normalized semantic score (0-1)
-     * @param lexicalScore - Normalized lexical score (0-1)
-     * @param symbolicScore - Normalized symbolic score (0-1)
-     * @returns Combined weighted score
-     */
-    calculateScore(semanticScore: number, lexicalScore: number, symbolicScore: number): number;
-}
-//# sourceMappingURL=HybridScorer.d.ts.map

package/dist/search/HybridScorer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HybridScorer.d.ts","sourceRoot":"","sources":["../../src/search/HybridScorer.ts"],"names":[],"mappings":"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"}

package/dist/search/HybridScorer.js

@@ -1,257 +0,0 @@
-/**
- * Hybrid Scorer
- *
- * Combines semantic, lexical, and symbolic search scores with
- * min-max normalization and configurable weights.
- *
- * Phase 12 Sprint 3: Search Algorithm Optimization
- *
- * @module search/HybridScorer
- */
-/**
- * Default weights for hybrid search.
- */
-export const DEFAULT_SCORER_WEIGHTS = {
-    semantic: 0.4,
-    lexical: 0.4,
-    symbolic: 0.2,
-};
-/**
- * HybridScorer combines multiple search signals using min-max normalization.
- *
- * Features:
- * 1. Min-max normalization brings all scores to 0-1 range
- * 2. Configurable weights for each layer
- * 3. Handles missing layers gracefully (redistributes weights)
- * 4. Tracks which layers contributed to each result
- *
- * @example
- * ```typescript
- * const scorer = new HybridScorer({
- *   weights: { semantic: 0.5, lexical: 0.3, symbolic: 0.2 }
- * });
- *
- * const results = scorer.combine(
- *   semanticResults,
- *   lexicalResults,
- *   symbolicResults,
- *   entityMap
- * );
- * ```
- */
-export class HybridScorer {
-    weights;
-    minScore;
-    normalizeWeights;
-    constructor(options = {}) {
-        this.weights = {
-            ...DEFAULT_SCORER_WEIGHTS,
-            ...options.weights,
-        };
-        this.minScore = options.minScore ?? 0;
-        this.normalizeWeights = options.normalizeWeights ?? true;
-    }
-    /**
-     * Get current weights configuration.
-     */
-    getWeights() {
-        return { ...this.weights };
-    }
-    /**
-     * Update weights configuration.
-     */
-    setWeights(weights) {
-        this.weights = { ...this.weights, ...weights };
-    }
-    /**
-     * Perform min-max normalization on scores.
-     *
-     * Formula: normalized = (x - min) / (max - min)
-     *
-     * @param scores - Map of entity name to raw score
-     * @returns Map of entity name to normalized score (0-1)
-     */
-    minMaxNormalize(scores) {
-        if (scores.size === 0) {
-            return new Map();
-        }
-        // Find min and max
-        let min = Infinity;
-        let max = -Infinity;
-        for (const score of scores.values()) {
-            if (score < min)
-                min = score;
-            if (score > max)
-                max = score;
-        }
-        // Handle edge case where all scores are the same
-        if (max === min) {
-            const normalized = new Map();
-            for (const name of scores.keys()) {
-                // If all scores are zero, keep them zero; otherwise normalize to 1
-                normalized.set(name, max === 0 ? 0 : 1);
-            }
-            return normalized;
-        }
-        // Normalize
-        const range = max - min;
-        const normalized = new Map();
-        for (const [name, score] of scores) {
-            normalized.set(name, (score - min) / range);
-        }
-        return normalized;
-    }
-    /**
-     * Combine results from all three search layers.
-     *
-     * @param semanticResults - Results from semantic search
-     * @param lexicalResults - Results from lexical search
-     * @param symbolicResults - Results from symbolic search
-     * @param entityMap - Map of entity names to Entity objects
-     * @returns Array of combined results sorted by score
-     */
-    combine(semanticResults, lexicalResults, symbolicResults, entityMap) {
-        // Build score maps
-        const semanticScores = new Map();
-        for (const result of semanticResults) {
-            semanticScores.set(result.entityName, result.similarity);
-        }
-        const lexicalScores = new Map();
-        for (const result of lexicalResults) {
-            lexicalScores.set(result.entityName, result.score);
-        }
-        const symbolicScores = new Map();
-        for (const result of symbolicResults) {
-            symbolicScores.set(result.entityName, result.score);
-        }
-        // Normalize scores
-        const normalizedSemantic = this.minMaxNormalize(semanticScores);
-        const normalizedLexical = this.minMaxNormalize(lexicalScores);
-        const normalizedSymbolic = this.minMaxNormalize(symbolicScores);
-        // Calculate effective weights
-        let effectiveWeights = { ...this.weights };
-        if (this.normalizeWeights) {
-            effectiveWeights = this.getNormalizedWeights(semanticResults.length > 0, lexicalResults.length > 0, symbolicResults.length > 0);
-        }
-        // Collect all unique entity names
-        const allNames = new Set([
-            ...normalizedSemantic.keys(),
-            ...normalizedLexical.keys(),
-            ...normalizedSymbolic.keys(),
-        ]);
-        // Calculate combined scores
-        const results = [];
-        for (const entityName of allNames) {
-            const entity = entityMap.get(entityName);
-            if (!entity)
-                continue;
-            const semanticScore = normalizedSemantic.get(entityName) ?? 0;
-            const lexicalScore = normalizedLexical.get(entityName) ?? 0;
-            const symbolicScore = normalizedSymbolic.get(entityName) ?? 0;
-            // Calculate weighted combination
-            const combined = semanticScore * effectiveWeights.semantic +
-                lexicalScore * effectiveWeights.lexical +
-                symbolicScore * effectiveWeights.symbolic;
-            // Track matched layers
-            const matchedLayers = [];
-            const rawScores = {};
-            if (semanticScores.has(entityName)) {
-                matchedLayers.push('semantic');
-                rawScores.semantic = semanticScores.get(entityName);
-            }
-            if (lexicalScores.has(entityName)) {
-                matchedLayers.push('lexical');
-                rawScores.lexical = lexicalScores.get(entityName);
-            }
-            if (symbolicScores.has(entityName)) {
-                matchedLayers.push('symbolic');
-                rawScores.symbolic = symbolicScores.get(entityName);
-            }
-            // Skip if below minimum score or no layers matched
-            if (combined < this.minScore || matchedLayers.length === 0) {
-                continue;
-            }
-            results.push({
-                entityName,
-                entity,
-                scores: {
-                    semantic: semanticScore,
-                    lexical: lexicalScore,
-                    symbolic: symbolicScore,
-                    combined,
-                },
-                matchedLayers,
-                rawScores,
-            });
-        }
-        // Sort by combined score descending
-        return results.sort((a, b) => b.scores.combined - a.scores.combined);
-    }
-    /**
-     * Get weights normalized to sum to 1, redistributing for missing layers.
-     *
-     * @param hasSemantic - Whether semantic results are available
-     * @param hasLexical - Whether lexical results are available
-     * @param hasSymbolic - Whether symbolic results are available
-     * @returns Normalized weights
-     */
-    getNormalizedWeights(hasSemantic, hasLexical, hasSymbolic) {
-        let totalActiveWeight = 0;
-        if (hasSemantic)
-            totalActiveWeight += this.weights.semantic;
-        if (hasLexical)
-            totalActiveWeight += this.weights.lexical;
-        if (hasSymbolic)
-            totalActiveWeight += this.weights.symbolic;
-        // If no layers are active, return zero weights
-        if (totalActiveWeight === 0) {
-            return { semantic: 0, lexical: 0, symbolic: 0 };
-        }
-        // Normalize active weights to sum to 1
-        return {
-            semantic: hasSemantic ? this.weights.semantic / totalActiveWeight : 0,
-            lexical: hasLexical ? this.weights.lexical / totalActiveWeight : 0,
-            symbolic: hasSymbolic ? this.weights.symbolic / totalActiveWeight : 0,
-        };
-    }
-    /**
-     * Combine scores from maps directly (alternative interface).
-     *
-     * @param semanticScores - Map of entity name to semantic score
-     * @param lexicalScores - Map of entity name to lexical score
-     * @param symbolicScores - Map of entity name to symbolic score
-     * @param entityMap - Map of entity names to Entity objects
-     * @returns Array of combined results sorted by score
-     */
-    combineFromMaps(semanticScores, lexicalScores, symbolicScores, entityMap) {
-        // Convert maps to result arrays
-        const semanticResults = [];
-        for (const [entityName, similarity] of semanticScores) {
-            semanticResults.push({ entityName, similarity });
-        }
-        const lexicalResults = [];
-        for (const [entityName, score] of lexicalScores) {
-            lexicalResults.push({ entityName, score });
-        }
-        const symbolicResults = [];
-        for (const [entityName, score] of symbolicScores) {
-            symbolicResults.push({ entityName, score });
-        }
-        return this.combine(semanticResults, lexicalResults, symbolicResults, entityMap);
-    }
-    /**
-     * Calculate combined score for a single entity.
-     *
-     * Useful for scoring individual results without full normalization.
-     *
-     * @param semanticScore - Normalized semantic score (0-1)
-     * @param lexicalScore - Normalized lexical score (0-1)
-     * @param symbolicScore - Normalized symbolic score (0-1)
-     * @returns Combined weighted score
-     */
-    calculateScore(semanticScore, lexicalScore, symbolicScore) {
-        return (semanticScore * this.weights.semantic +
-            lexicalScore * this.weights.lexical +
-            symbolicScore * this.weights.symbolic);
-    }
-}