@danielsimonjr/memory-mcp 12.2.3 → 12.5.2

package/dist/utils/indexes.js

@@ -1,526 +0,0 @@
-/**
- * Search Indexes
- *
- * Provides O(1) lookup structures to avoid repeated linear scans.
- * - NameIndex: O(1) entity lookup by name
- * - TypeIndex: O(1) entities by type
- * - LowercaseCache: Pre-computed lowercase strings to avoid repeated toLowerCase()
- * - RelationIndex: O(1) relation lookup by entity name (from/to)
- * - ObservationIndex: O(1) observation word lookup by entity
- *
- * @module utils/indexes
- */
-/**
- * NameIndex provides O(1) entity lookup by name.
- *
- * Uses a Map internally for constant-time access.
- */
-export class NameIndex {
-    index = new Map();
-    /**
-     * Build the index from an array of entities.
-     * Clears any existing index data first.
-     */
-    build(entities) {
-        this.index.clear();
-        for (const entity of entities) {
-            this.index.set(entity.name, entity);
-        }
-    }
-    /**
-     * Get an entity by name in O(1) time.
-     */
-    get(name) {
-        return this.index.get(name);
-    }
-    /**
-     * Add a single entity to the index.
-     */
-    add(entity) {
-        this.index.set(entity.name, entity);
-    }
-    /**
-     * Remove an entity from the index by name.
-     */
-    remove(name) {
-        this.index.delete(name);
-    }
-    /**
-     * Check if an entity exists in the index.
-     */
-    has(name) {
-        return this.index.has(name);
-    }
-    /**
-     * Get the number of entities in the index.
-     */
-    get size() {
-        return this.index.size;
-    }
-    /**
-     * Clear all entries from the index.
-     */
-    clear() {
-        this.index.clear();
-    }
-}
-/**
- * TypeIndex provides O(1) lookup of entities by type.
- *
- * Uses a Map<type, Set<entityName>> structure for efficient type queries.
- * Type comparisons are case-insensitive.
- */
-export class TypeIndex {
-    index = new Map();
-    /**
-     * Build the index from an array of entities.
-     * Clears any existing index data first.
-     */
-    build(entities) {
-        this.index.clear();
-        for (const entity of entities) {
-            this.addToIndex(entity.name, entity.entityType);
-        }
-    }
-    /**
-     * Get all entity names of a given type in O(1) time.
-     * Type comparison is case-insensitive.
-     */
-    getNames(entityType) {
-        const typeLower = entityType.toLowerCase();
-        return this.index.get(typeLower) ?? new Set();
-    }
-    /**
-     * Add an entity to the type index.
-     */
-    add(entity) {
-        this.addToIndex(entity.name, entity.entityType);
-    }
-    /**
-     * Remove an entity from the type index.
-     * Requires the entity type to know which bucket to remove from.
-     */
-    remove(entityName, entityType) {
-        const typeLower = entityType.toLowerCase();
-        const names = this.index.get(typeLower);
-        if (names) {
-            names.delete(entityName);
-            if (names.size === 0) {
-                this.index.delete(typeLower);
-            }
-        }
-    }
-    /**
-     * Update an entity's type in the index.
-     * Removes from old type and adds to new type.
-     */
-    updateType(entityName, oldType, newType) {
-        this.remove(entityName, oldType);
-        this.addToIndex(entityName, newType);
-    }
-    /**
-     * Get all unique types in the index.
-     */
-    getTypes() {
-        return Array.from(this.index.keys());
-    }
-    /**
-     * Clear all entries from the index.
-     */
-    clear() {
-        this.index.clear();
-    }
-    addToIndex(entityName, entityType) {
-        const typeLower = entityType.toLowerCase();
-        let names = this.index.get(typeLower);
-        if (!names) {
-            names = new Set();
-            this.index.set(typeLower, names);
-        }
-        names.add(entityName);
-    }
-}
-/**
- * LowercaseCache pre-computes lowercase versions of all searchable fields.
- *
- * Eliminates the need for repeated toLowerCase() calls during search,
- * which is expensive with many entities and observations.
- */
-export class LowercaseCache {
-    cache = new Map();
-    /**
-     * Build the cache from an array of entities.
-     * Clears any existing cache data first.
-     */
-    build(entities) {
-        this.cache.clear();
-        for (const entity of entities) {
-            this.cache.set(entity.name, this.computeLowercase(entity));
-        }
-    }
-    /**
-     * Get pre-computed lowercase data for an entity.
-     */
-    get(entityName) {
-        return this.cache.get(entityName);
-    }
-    /**
-     * Add or update an entity in the cache.
-     */
-    set(entity) {
-        this.cache.set(entity.name, this.computeLowercase(entity));
-    }
-    /**
-     * Remove an entity from the cache.
-     */
-    remove(entityName) {
-        this.cache.delete(entityName);
-    }
-    /**
-     * Check if an entity exists in the cache.
-     */
-    has(entityName) {
-        return this.cache.has(entityName);
-    }
-    /**
-     * Clear all entries from the cache.
-     */
-    clear() {
-        this.cache.clear();
-    }
-    /**
-     * Get the number of entries in the cache.
-     */
-    get size() {
-        return this.cache.size;
-    }
-    computeLowercase(entity) {
-        return {
-            name: entity.name.toLowerCase(),
-            entityType: entity.entityType.toLowerCase(),
-            observations: entity.observations.map(o => o.toLowerCase()),
-            tags: entity.tags?.map(t => t.toLowerCase()) ?? [],
-        };
-    }
-}
-/**
- * RelationIndex provides O(1) lookup of relations by entity name.
- *
- * Maintains two separate indexes for efficient directional queries:
- * - fromIndex: Map from source entity name to its outgoing relations
- * - toIndex: Map from target entity name to its incoming relations
- *
- * This eliminates O(n) array scans when looking up relations for an entity.
- */
-export class RelationIndex {
-    /** Index of relations by source (from) entity */
-    fromIndex = new Map();
-    /** Index of relations by target (to) entity */
-    toIndex = new Map();
-    /**
-     * Build the index from an array of relations.
-     * Clears any existing index data first.
-     */
-    build(relations) {
-        this.fromIndex.clear();
-        this.toIndex.clear();
-        for (const relation of relations) {
-            this.addToIndexes(relation);
-        }
-    }
-    /**
-     * Get all relations where the entity is the source (outgoing relations).
-     * Returns empty array if no relations found.
-     */
-    getRelationsFrom(entityName) {
-        const relations = this.fromIndex.get(entityName);
-        return relations ? Array.from(relations) : [];
-    }
-    /**
-     * Get all relations where the entity is the target (incoming relations).
-     * Returns empty array if no relations found.
-     */
-    getRelationsTo(entityName) {
-        const relations = this.toIndex.get(entityName);
-        return relations ? Array.from(relations) : [];
-    }
-    /**
-     * Get all relations involving the entity (both incoming and outgoing).
-     * Returns empty array if no relations found.
-     */
-    getRelationsFor(entityName) {
-        const fromRelations = this.fromIndex.get(entityName);
-        const toRelations = this.toIndex.get(entityName);
-        // Combine sets to handle self-referential relations correctly
-        const combined = new Set();
-        if (fromRelations) {
-            for (const r of fromRelations) {
-                combined.add(r);
-            }
-        }
-        if (toRelations) {
-            for (const r of toRelations) {
-                combined.add(r);
-            }
-        }
-        return Array.from(combined);
-    }
-    /**
-     * Add a single relation to the index.
-     */
-    add(relation) {
-        this.addToIndexes(relation);
-    }
-    /**
-     * Remove a relation from the index.
-     * Matches by from, to, and relationType.
-     */
-    remove(relation) {
-        // Remove from fromIndex
-        const fromRelations = this.fromIndex.get(relation.from);
-        if (fromRelations) {
-            for (const r of fromRelations) {
-                if (r.from === relation.from && r.to === relation.to && r.relationType === relation.relationType) {
-                    fromRelations.delete(r);
-                    break;
-                }
-            }
-            if (fromRelations.size === 0) {
-                this.fromIndex.delete(relation.from);
-            }
-        }
-        // Remove from toIndex
-        const toRelations = this.toIndex.get(relation.to);
-        if (toRelations) {
-            for (const r of toRelations) {
-                if (r.from === relation.from && r.to === relation.to && r.relationType === relation.relationType) {
-                    toRelations.delete(r);
-                    break;
-                }
-            }
-            if (toRelations.size === 0) {
-                this.toIndex.delete(relation.to);
-            }
-        }
-    }
-    /**
-     * Remove all relations involving a specific entity.
-     * Returns the relations that were removed.
-     */
-    removeAllForEntity(entityName) {
-        const removed = [];
-        // Remove outgoing relations
-        const fromRelations = this.fromIndex.get(entityName);
-        if (fromRelations) {
-            for (const r of fromRelations) {
-                removed.push(r);
-                // Also remove from toIndex
-                const toRels = this.toIndex.get(r.to);
-                if (toRels) {
-                    toRels.delete(r);
-                    if (toRels.size === 0) {
-                        this.toIndex.delete(r.to);
-                    }
-                }
-            }
-            this.fromIndex.delete(entityName);
-        }
-        // Remove incoming relations
-        const toRelations = this.toIndex.get(entityName);
-        if (toRelations) {
-            for (const r of toRelations) {
-                // Skip self-referential relations (already handled above)
-                if (r.from === entityName)
-                    continue;
-                removed.push(r);
-                // Also remove from fromIndex
-                const fromRels = this.fromIndex.get(r.from);
-                if (fromRels) {
-                    fromRels.delete(r);
-                    if (fromRels.size === 0) {
-                        this.fromIndex.delete(r.from);
-                    }
-                }
-            }
-            this.toIndex.delete(entityName);
-        }
-        return removed;
-    }
-    /**
-     * Check if any relations exist for an entity.
-     */
-    hasRelations(entityName) {
-        return this.fromIndex.has(entityName) || this.toIndex.has(entityName);
-    }
-    /**
-     * Get count of outgoing relations for an entity.
-     */
-    getOutgoingCount(entityName) {
-        return this.fromIndex.get(entityName)?.size ?? 0;
-    }
-    /**
-     * Get count of incoming relations for an entity.
-     */
-    getIncomingCount(entityName) {
-        return this.toIndex.get(entityName)?.size ?? 0;
-    }
-    /**
-     * Get total count of unique relations in the index.
-     */
-    get size() {
-        // Count all relations in fromIndex (each relation appears exactly once there)
-        let count = 0;
-        for (const relations of this.fromIndex.values()) {
-            count += relations.size;
-        }
-        return count;
-    }
-    /**
-     * Clear all entries from the index.
-     */
-    clear() {
-        this.fromIndex.clear();
-        this.toIndex.clear();
-    }
-    addToIndexes(relation) {
-        // Add to fromIndex
-        let fromSet = this.fromIndex.get(relation.from);
-        if (!fromSet) {
-            fromSet = new Set();
-            this.fromIndex.set(relation.from, fromSet);
-        }
-        fromSet.add(relation);
-        // Add to toIndex
-        let toSet = this.toIndex.get(relation.to);
-        if (!toSet) {
-            toSet = new Set();
-            this.toIndex.set(relation.to, toSet);
-        }
-        toSet.add(relation);
-    }
-}
-/**
- * Inverted index mapping observation keywords to entity names.
- * Enables O(1) lookup for 'which entities mention word X?' queries.
- * Words are normalized to lowercase and split on whitespace/punctuation.
- */
-export class ObservationIndex {
-    index = new Map();
-    entityObservations = new Map();
-    /**
-     * Add an entity's observations to the index.
-     * Tokenizes observations into words and creates reverse mapping.
-     *
-     * @param entityName - Name of the entity
-     * @param observations - Array of observation strings
-     */
-    add(entityName, observations) {
-        const entityWords = new Set();
-        for (const observation of observations) {
-            const words = this.tokenize(observation);
-            for (const word of words) {
-                entityWords.add(word);
-                if (!this.index.has(word)) {
-                    this.index.set(word, new Set());
-                }
-                this.index.get(word).add(entityName);
-            }
-        }
-        this.entityObservations.set(entityName, entityWords);
-    }
-    /**
-     * Remove an entity from the index.
-     * Cleans up all word mappings for this entity.
-     *
-     * @param entityName - Name of the entity to remove
-     */
-    remove(entityName) {
-        const words = this.entityObservations.get(entityName);
-        if (!words)
-            return;
-        for (const word of words) {
-            const entities = this.index.get(word);
-            if (entities) {
-                entities.delete(entityName);
-                if (entities.size === 0) {
-                    this.index.delete(word);
-                }
-            }
-        }
-        this.entityObservations.delete(entityName);
-    }
-    /**
-     * Get all entities that have observations containing the given word.
-     * Word matching is case-insensitive.
-     *
-     * @param word - Word to search for
-     * @returns Set of entity names containing this word
-     */
-    getEntitiesWithWord(word) {
-        return this.index.get(word.toLowerCase()) ?? new Set();
-    }
-    /**
-     * Get all entities that have observations containing ANY of the given words (union).
-     *
-     * @param words - Array of words to search for
-     * @returns Set of entity names containing any of the words
-     */
-    getEntitiesWithAnyWord(words) {
-        const result = new Set();
-        for (const word of words) {
-            const entities = this.getEntitiesWithWord(word);
-            for (const entity of entities) {
-                result.add(entity);
-            }
-        }
-        return result;
-    }
-    /**
-     * Get all entities that have observations containing ALL of the given words (intersection).
-     *
-     * @param words - Array of words that must all be present
-     * @returns Set of entity names containing all of the words
-     */
-    getEntitiesWithAllWords(words) {
-        if (words.length === 0)
-            return new Set();
-        let result = new Set(this.getEntitiesWithWord(words[0]));
-        for (let i = 1; i < words.length && result.size > 0; i++) {
-            const wordEntities = this.getEntitiesWithWord(words[i]);
-            result = new Set([...result].filter(e => wordEntities.has(e)));
-        }
-        return result;
-    }
-    /**
-     * Clear all entries from the index.
-     */
-    clear() {
-        this.index.clear();
-        this.entityObservations.clear();
-    }
-    /**
-     * Get statistics about the index.
-     *
-     * @returns Object with wordCount and entityCount
-     */
-    getStats() {
-        return {
-            wordCount: this.index.size,
-            entityCount: this.entityObservations.size,
-        };
-    }
-    /**
-     * Tokenize text into searchable words.
-     * Normalizes to lowercase, splits on non-alphanumeric characters,
-     * and filters out words less than 2 characters.
-     *
-     * @param text - Text to tokenize
-     * @returns Array of normalized words
-     */
-    tokenize(text) {
-        return text
-            .toLowerCase()
-            .split(/[^a-z0-9]+/)
-            .filter(word => word.length >= 2);
-    }
-}

package/dist/utils/logger.d.ts

@@ -1,24 +0,0 @@
-/**
- * Simple logging utility for the Memory MCP Server
- *
- * Provides consistent log formatting with levels: debug, info, warn, error
- */
-export declare const logger: {
-    /**
-     * Debug level logging (verbose, for development)
-     */
-    debug: (msg: string, ...args: unknown[]) => void;
-    /**
-     * Info level logging (general informational messages)
-     */
-    info: (msg: string, ...args: unknown[]) => void;
-    /**
-     * Warning level logging (warnings that don't prevent operation)
-     */
-    warn: (msg: string, ...args: unknown[]) => void;
-    /**
-     * Error level logging (errors that affect functionality)
-     */
-    error: (msg: string, ...args: unknown[]) => void;
-};
-//# sourceMappingURL=logger.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,eAAO,MAAM,MAAM;IACjB;;OAEG;iBACU,MAAM,WAAW,OAAO,EAAE,KAAG,IAAI;IAM9C;;OAEG;gBACS,MAAM,WAAW,OAAO,EAAE,KAAG,IAAI;IAI7C;;OAEG;gBACS,MAAM,WAAW,OAAO,EAAE,KAAG,IAAI;IAI7C;;OAEG;iBACU,MAAM,WAAW,OAAO,EAAE,KAAG,IAAI;CAG/C,CAAC"}

package/dist/utils/logger.js

@@ -1,33 +0,0 @@
-/**
- * Simple logging utility for the Memory MCP Server
- *
- * Provides consistent log formatting with levels: debug, info, warn, error
- */
-export const logger = {
-    /**
-     * Debug level logging (verbose, for development)
-     */
-    debug: (msg, ...args) => {
-        if (process.env.LOG_LEVEL === 'debug') {
-            console.debug(`[DEBUG] ${msg}`, ...args);
-        }
-    },
-    /**
-     * Info level logging (general informational messages)
-     */
-    info: (msg, ...args) => {
-        console.log(`[INFO] ${msg}`, ...args);
-    },
-    /**
-     * Warning level logging (warnings that don't prevent operation)
-     */
-    warn: (msg, ...args) => {
-        console.warn(`[WARN] ${msg}`, ...args);
-    },
-    /**
-     * Error level logging (errors that affect functionality)
-     */
-    error: (msg, ...args) => {
-        console.error(`[ERROR] ${msg}`, ...args);
-    },
-};

package/dist/utils/parallelUtils.d.ts

@@ -1,72 +0,0 @@
-/**
- * Parallel Utilities
- *
- * Utilities for parallel array operations using workerpool.
- * Phase 8 Sprint 3: Parallel array operations for improved performance.
- *
- * @module utils/parallelUtils
- */
-import workerpool from '@danielsimonjr/workerpool/modern';
-/**
- * Shutdown the shared worker pool and clean up resources.
- * Should be called when parallel utilities are no longer needed.
- */
-export declare function shutdownParallelUtils(): Promise<void>;
-/**
- * Map items in parallel using workerpool.
- *
- * Splits the array into chunks and processes each chunk in a worker thread.
- * Falls back to single-threaded for small arrays (< MIN_PARALLEL_SIZE).
- *
- * **Note:** The mapping function must be serializable (no closures, external variables).
- * Due to ESM/worker thread compatibility issues, this may fall back to single-threaded
- * execution in some environments (e.g., vitest test runner).
- *
- * @template T - Input item type
- * @template R - Output item type
- * @param items - Array of items to map
- * @param fn - Mapping function (must be serializable)
- * @param chunkSize - Optional chunk size (default: DEFAULT_CHUNK_SIZE)
- * @returns Promise resolving to array of mapped results
- *
- * @example
- * ```typescript
- * // Map numbers to their squares
- * const numbers = [1, 2, 3, 4, 5];
- * const squared = await parallelMap(numbers, (n: number) => n * n);
- * // Result: [1, 4, 9, 16, 25]
- * ```
- */
-export declare function parallelMap<T, R>(items: T[], fn: (item: T) => R, chunkSize?: number): Promise<R[]>;
-/**
- * Filter items in parallel using workerpool.
- *
- * Splits the array into chunks and processes each chunk in a worker thread.
- * Falls back to single-threaded for small arrays (< MIN_PARALLEL_SIZE).
- *
- * **Note:** The predicate function must be serializable (no closures, external variables).
- * Due to ESM/worker thread compatibility issues, this may fall back to single-threaded
- * execution in some environments (e.g., vitest test runner).
- *
- * @template T - Item type
- * @param items - Array of items to filter
- * @param predicate - Filter predicate (must be serializable)
- * @param chunkSize - Optional chunk size (default: DEFAULT_CHUNK_SIZE)
- * @returns Promise resolving to filtered array
- *
- * @example
- * ```typescript
- * // Filter even numbers
- * const numbers = [1, 2, 3, 4, 5, 6];
- * const evens = await parallelFilter(numbers, (n: number) => n % 2 === 0);
- * // Result: [2, 4, 6]
- * ```
- */
-export declare function parallelFilter<T>(items: T[], predicate: (item: T) => boolean, chunkSize?: number): Promise<T[]>;
-/**
- * Get statistics about the worker pool.
- *
- * @returns Pool statistics or null if pool is not initialized
- */
-export declare function getPoolStats(): workerpool.PoolStats | null;
-//# sourceMappingURL=parallelUtils.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parallelUtils.d.ts","sourceRoot":"","sources":["../../src/utils/parallelUtils.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,UAAU,MAAM,kCAAkC,CAAC;AAoC1D;;;GAGG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAK3D;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,CAAC,EACpC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,EAClB,SAAS,GAAE,MAA2B,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAwCd;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,EAC/B,SAAS,GAAE,MAA2B,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAwCd;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,UAAU,CAAC,SAAS,GAAG,IAAI,CAK1D"}