@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/search/HybridSearchManager.d.ts

@@ -1,80 +0,0 @@
-/**
- * Hybrid Search Manager
- *
- * Phase 11: Orchestrates three-layer hybrid search combining
- * semantic, lexical, and symbolic signals.
- *
- * @module search/HybridSearchManager
- */
-import type { HybridSearchOptions, HybridSearchResult, ReadonlyKnowledgeGraph } from '../types/index.js';
-import type { SemanticSearch } from './SemanticSearch.js';
-import type { RankedSearch } from './RankedSearch.js';
-import { SymbolicSearch } from './SymbolicSearch.js';
-/**
- * Default weights for hybrid search layers.
- */
-export declare const DEFAULT_HYBRID_WEIGHTS: {
-    semantic: number;
-    lexical: number;
-    symbolic: number;
-};
-/**
- * Hybrid Search Manager
- *
- * Combines three search layers:
- * 1. Semantic: Vector similarity via embeddings
- * 2. Lexical: Keyword matching via TF-IDF/BM25
- * 3. Symbolic: Structured metadata filtering
- *
- * @example
- * ```typescript
- * const hybrid = new HybridSearchManager(semanticSearch, rankedSearch);
- * const results = await hybrid.search(graph, 'machine learning', {
- *   semanticWeight: 0.5,
- *   lexicalWeight: 0.3,
- *   symbolicWeight: 0.2,
- *   symbolic: { tags: ['ai'] }
- * });
- * ```
- */
-export declare class HybridSearchManager {
-    private semanticSearch;
-    private rankedSearch;
-    private symbolicSearch;
-    constructor(semanticSearch: SemanticSearch | null, rankedSearch: RankedSearch);
-    /**
-     * Perform hybrid search combining all three layers.
-     *
-     * @param graph - Knowledge graph to search
-     * @param query - Search query text
-     * @param options - Hybrid search options with weights
-     * @returns Combined and ranked results
-     */
-    search(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResult[]>;
-    /**
-     * Execute semantic search layer.
-     */
-    private executeSemanticSearch;
-    /**
-     * Execute lexical search layer (TF-IDF/BM25).
-     */
-    private executeLexicalSearch;
-    /**
-     * Execute symbolic search layer.
-     */
-    private executeSymbolicSearch;
-    /**
-     * Merge results from all three layers.
-     */
-    private mergeResults;
-    /**
-     * Search with full entity resolution.
-     * Alias for search() since we now always resolve entities.
-     */
-    searchWithEntities(graph: ReadonlyKnowledgeGraph, query: string, options?: Partial<HybridSearchOptions>): Promise<HybridSearchResult[]>;
-    /**
-     * Get the symbolic search instance for direct access.
-     */
-    getSymbolicSearch(): SymbolicSearch;
-}
-//# sourceMappingURL=HybridSearchManager.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"HybridSearchManager.d.ts","sourceRoot":"","sources":["../../src/search/HybridSearchManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAEV,mBAAmB,EACnB,kBAAkB,EAClB,sBAAsB,EAEvB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;CAIlC,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,YAAY;IAJtB,OAAO,CAAC,cAAc,CAAiB;gBAG7B,cAAc,EAAE,cAAc,GAAG,IAAI,EACrC,YAAY,EAAE,YAAY;IAKpC;;;;;;;OAOG;IACG,MAAM,CACV,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACzC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAuChC;;OAEG;YACW,qBAAqB;IA8BnC;;OAEG;YACW,oBAAoB;IA4BlC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAsB7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAkDpB;;;OAGG;IACG,kBAAkB,CACtB,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,OAAO,CAAC,mBAAmB,CAAM,GACzC,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAIhC;;OAEG;IACH,iBAAiB,IAAI,cAAc;CAGpC"}

package/dist/search/HybridSearchManager.js

@@ -1,187 +0,0 @@
-/**
- * Hybrid Search Manager
- *
- * Phase 11: Orchestrates three-layer hybrid search combining
- * semantic, lexical, and symbolic signals.
- *
- * @module search/HybridSearchManager
- */
-import { SymbolicSearch } from './SymbolicSearch.js';
-import { SEMANTIC_SEARCH_LIMITS } from '../utils/constants.js';
-/**
- * Default weights for hybrid search layers.
- */
-export const DEFAULT_HYBRID_WEIGHTS = {
-    semantic: 0.5,
-    lexical: 0.3,
-    symbolic: 0.2,
-};
-/**
- * Hybrid Search Manager
- *
- * Combines three search layers:
- * 1. Semantic: Vector similarity via embeddings
- * 2. Lexical: Keyword matching via TF-IDF/BM25
- * 3. Symbolic: Structured metadata filtering
- *
- * @example
- * ```typescript
- * const hybrid = new HybridSearchManager(semanticSearch, rankedSearch);
- * const results = await hybrid.search(graph, 'machine learning', {
- *   semanticWeight: 0.5,
- *   lexicalWeight: 0.3,
- *   symbolicWeight: 0.2,
- *   symbolic: { tags: ['ai'] }
- * });
- * ```
- */
-export class HybridSearchManager {
-    semanticSearch;
-    rankedSearch;
-    symbolicSearch;
-    constructor(semanticSearch, rankedSearch) {
-        this.semanticSearch = semanticSearch;
-        this.rankedSearch = rankedSearch;
-        this.symbolicSearch = new SymbolicSearch();
-    }
-    /**
-     * Perform hybrid search combining all three layers.
-     *
-     * @param graph - Knowledge graph to search
-     * @param query - Search query text
-     * @param options - Hybrid search options with weights
-     * @returns Combined and ranked results
-     */
-    async search(graph, query, options = {}) {
-        const { semanticWeight = DEFAULT_HYBRID_WEIGHTS.semantic, lexicalWeight = DEFAULT_HYBRID_WEIGHTS.lexical, symbolicWeight = DEFAULT_HYBRID_WEIGHTS.symbolic, semantic = {}, lexical = {}, symbolic = {}, limit = SEMANTIC_SEARCH_LIMITS.DEFAULT_LIMIT, } = options;
-        // Normalize weights
-        const totalWeight = semanticWeight + lexicalWeight + symbolicWeight;
-        const normSemantic = semanticWeight / totalWeight;
-        const normLexical = lexicalWeight / totalWeight;
-        const normSymbolic = symbolicWeight / totalWeight;
-        // Execute searches in parallel
-        const [semanticResults, lexicalResults, symbolicResults] = await Promise.all([
-            this.executeSemanticSearch(graph, query, semantic, limit * 2),
-            this.executeLexicalSearch(query, lexical, limit * 2),
-            this.executeSymbolicSearch(graph.entities, symbolic),
-        ]);
-        // Merge results
-        const merged = this.mergeResults(graph.entities, semanticResults, lexicalResults, symbolicResults, { semantic: normSemantic, lexical: normLexical, symbolic: normSymbolic });
-        // Sort by combined score and limit
-        return merged
-            .sort((a, b) => b.scores.combined - a.scores.combined)
-            .slice(0, limit);
-    }
-    /**
-     * Execute semantic search layer.
-     */
-    async executeSemanticSearch(graph, query, options, limit) {
-        const results = new Map();
-        if (!this.semanticSearch) {
-            return results; // Semantic search not available
-        }
-        try {
-            const semanticResults = await this.semanticSearch.search(graph, query, options.topK ?? limit, options.minSimilarity ?? 0);
-            for (const result of semanticResults) {
-                results.set(result.entity.name, result.similarity);
-            }
-        }
-        catch {
-            // Semantic search may fail if not indexed
-        }
-        return results;
-    }
-    /**
-     * Execute lexical search layer (TF-IDF/BM25).
-     */
-    async executeLexicalSearch(query, _options, limit) {
-        const results = new Map();
-        try {
-            const lexicalResults = await this.rankedSearch.searchNodesRanked(query, undefined, // tags
-            undefined, // minImportance
-            undefined, // maxImportance
-            limit);
-            // Normalize scores to 0-1 range
-            const maxScore = Math.max(...lexicalResults.map(r => r.score), 1);
-            for (const result of lexicalResults) {
-                results.set(result.entity.name, result.score / maxScore);
-            }
-        }
-        catch {
-            // Lexical search may fail
-        }
-        return results;
-    }
-    /**
-     * Execute symbolic search layer.
-     */
-    executeSymbolicSearch(entities, filters) {
-        const results = new Map();
-        if (!filters || Object.keys(filters).length === 0) {
-            // No symbolic filters, give all entities base score
-            for (const entity of entities) {
-                results.set(entity.name, 0.5);
-            }
-            return results;
-        }
-        const symbolicResults = this.symbolicSearch.search(entities, filters);
-        for (const result of symbolicResults) {
-            results.set(result.entity.name, result.score);
-        }
-        return results;
-    }
-    /**
-     * Merge results from all three layers.
-     */
-    mergeResults(entities, semanticScores, lexicalScores, symbolicScores, weights) {
-        // Collect all unique entity names that have at least one non-zero score
-        const allNames = new Set([
-            ...semanticScores.keys(),
-            ...lexicalScores.keys(),
-            ...symbolicScores.keys(),
-        ]);
-        // Create entity lookup map
-        const entityMap = new Map(entities.map(e => [e.name, e]));
-        const results = [];
-        for (const name of allNames) {
-            const entity = entityMap.get(name);
-            if (!entity)
-                continue;
-            const semantic = semanticScores.get(name) ?? 0;
-            const lexical = lexicalScores.get(name) ?? 0;
-            const symbolic = symbolicScores.get(name) ?? 0;
-            const combined = semantic * weights.semantic +
-                lexical * weights.lexical +
-                symbolic * weights.symbolic;
-            const matchedLayers = [];
-            if (semantic > 0)
-                matchedLayers.push('semantic');
-            if (lexical > 0)
-                matchedLayers.push('lexical');
-            if (symbolic > 0)
-                matchedLayers.push('symbolic');
-            // Skip if no layers matched meaningfully
-            if (matchedLayers.length === 0)
-                continue;
-            results.push({
-                entity,
-                scores: { semantic, lexical, symbolic, combined },
-                matchedLayers,
-            });
-        }
-        return results;
-    }
-    /**
-     * Search with full entity resolution.
-     * Alias for search() since we now always resolve entities.
-     */
-    async searchWithEntities(graph, query, options = {}) {
-        return this.search(graph, query, options);
-    }
-    /**
-     * Get the symbolic search instance for direct access.
-     */
-    getSymbolicSearch() {
-        return this.symbolicSearch;
-    }
-}

package/dist/search/IncrementalIndexer.d.ts

@@ -1,201 +0,0 @@
-/**
- * Incremental Indexer
- *
- * Phase 12 Sprint 5: Queues embedding index updates and batch-processes them
- * efficiently using flush thresholds and timer-based flushing.
- *
- * @module search/IncrementalIndexer
- */
-import type { EmbeddingService, EmbeddingMode } from '../types/index.js';
-import type { IVectorStore } from '../types/index.js';
-import type { EmbeddingProgressCallback } from './EmbeddingService.js';
-/**
- * Types of index operations.
- */
-export type IndexOperationType = 'create' | 'update' | 'delete';
-/**
- * Queued index operation.
- */
-export interface IndexOperation {
-    /** Type of operation */
-    type: IndexOperationType;
-    /** Entity name */
-    entityName: string;
-    /** Text to embed (for create/update) */
-    text?: string;
-    /** Timestamp when operation was queued */
-    queuedAt: number;
-}
-/**
- * Options for IncrementalIndexer.
- */
-export interface IncrementalIndexerOptions {
-    /** Flush threshold - number of operations to queue before auto-flush (default: 50) */
-    flushThreshold?: number;
-    /** Timer-based flush interval in milliseconds (default: 5000ms) */
-    flushIntervalMs?: number;
-    /** Embedding mode for new embeddings (default: 'document') */
-    embeddingMode?: EmbeddingMode;
-    /** Progress callback for batch operations */
-    onProgress?: EmbeddingProgressCallback;
-}
-/**
- * Default indexer options.
- */
-export declare const DEFAULT_INDEXER_OPTIONS: Required<Omit<IncrementalIndexerOptions, 'onProgress'>>;
-/**
- * Result of a flush operation.
- */
-export interface FlushResult {
-    /** Number of operations processed */
-    processed: number;
-    /** Number of successful operations */
-    succeeded: number;
-    /** Number of failed operations */
-    failed: number;
-    /** Errors encountered during flush */
-    errors: Array<{
-        entityName: string;
-        error: string;
-    }>;
-    /** Duration of flush in milliseconds */
-    durationMs: number;
-}
-/**
- * Incremental indexer for embedding vectors.
- *
- * Queues index updates and batch-processes them efficiently:
- * - Auto-flush when queue reaches threshold
- * - Timer-based flush for time-sensitive updates
- * - Supports create, update, and delete operations
- * - Graceful shutdown with final flush
- *
- * @example
- * ```typescript
- * const indexer = new IncrementalIndexer(embeddingService, vectorStore, {
- *   flushThreshold: 100,
- *   flushIntervalMs: 10000,
- * });
- *
- * // Queue operations
- * indexer.queueCreate('entity1', 'Entity text content');
- * indexer.queueUpdate('entity2', 'Updated text content');
- * indexer.queueDelete('entity3');
- *
- * // Manual flush
- * const result = await indexer.flush();
- * console.log(`Processed ${result.processed} operations`);
- *
- * // Graceful shutdown
- * await indexer.shutdown();
- * ```
- */
-export declare class IncrementalIndexer {
-    private embeddingService;
-    private vectorStore;
-    private options;
-    private onProgress?;
-    private queue;
-    private flushTimer;
-    private isFlushing;
-    private isShutdown;
-    /**
-     * Create a new incremental indexer.
-     *
-     * @param embeddingService - Service for generating embeddings
-     * @param vectorStore - Store for embedding vectors
-     * @param options - Indexer configuration options
-     */
-    constructor(embeddingService: EmbeddingService, vectorStore: IVectorStore, options?: IncrementalIndexerOptions);
-    /**
-     * Start the timer-based flush interval.
-     */
-    private startFlushTimer;
-    /**
-     * Stop the flush timer.
-     */
-    private stopFlushTimer;
-    /**
-     * Queue a create operation.
-     *
-     * @param entityName - Name of the entity to create
-     * @param text - Text content to embed
-     */
-    queueCreate(entityName: string, text: string): void;
-    /**
-     * Queue an update operation.
-     *
-     * @param entityName - Name of the entity to update
-     * @param text - Updated text content to embed
-     */
-    queueUpdate(entityName: string, text: string): void;
-    /**
-     * Queue a delete operation.
-     *
-     * @param entityName - Name of the entity to delete
-     */
-    queueDelete(entityName: string): void;
-    /**
-     * Remove all queued operations for an entity.
-     *
-     * @param entityName - Entity name to remove from queue
-     */
-    private removeFromQueue;
-    /**
-     * Check if auto-flush threshold is reached.
-     */
-    private checkAutoFlush;
-    /**
-     * Flush the queue and process all pending operations.
-     *
-     * @returns Result of the flush operation
-     */
-    flush(): Promise<FlushResult>;
-    /**
-     * Get the current queue size.
-     *
-     * @returns Number of operations in the queue
-     */
-    getQueueSize(): number;
-    /**
-     * Get the current queue contents (for debugging/monitoring).
-     *
-     * @returns Copy of the current queue
-     */
-    getQueue(): IndexOperation[];
-    /**
-     * Check if the indexer is currently flushing.
-     *
-     * @returns True if flushing
-     */
-    isBusy(): boolean;
-    /**
-     * Check if the indexer is shutdown.
-     *
-     * @returns True if shutdown
-     */
-    isShutdownComplete(): boolean;
-    /**
-     * Graceful shutdown with final flush.
-     *
-     * Stops the timer and flushes any remaining operations.
-     *
-     * @returns Result of the final flush
-     */
-    shutdown(): Promise<FlushResult>;
-    /**
-     * Update indexer options.
-     *
-     * Note: Changes to flushIntervalMs will take effect on the next interval.
-     *
-     * @param options - New options to apply
-     */
-    updateOptions(options: Partial<IncrementalIndexerOptions>): void;
-    /**
-     * Clear the queue without processing.
-     *
-     * @returns Number of operations cleared
-     */
-    clearQueue(): number;
-}
-//# sourceMappingURL=IncrementalIndexer.d.ts.map

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

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