@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/search/SymbolicSearch.js

@@ -1,163 +0,0 @@
-/**
- * Symbolic Search Layer
- *
- * Phase 11: Provides metadata-based filtering using structured predicates.
- * Part of the three-layer hybrid search architecture.
- *
- * @module search/SymbolicSearch
- */
-/**
- * Symbolic Search provides metadata-based filtering.
- *
- * Filters entities using structured predicates on tags, types,
- * dates, importance, and hierarchy.
- *
- * @example
- * ```typescript
- * const symbolic = new SymbolicSearch();
- * const results = symbolic.search(entities, {
- *   tags: ['important'],
- *   entityTypes: ['person'],
- *   importance: { min: 5 }
- * });
- * ```
- */
-export class SymbolicSearch {
-    /**
-     * Filter entities using structured metadata predicates.
-     * All filters are AND-combined.
-     *
-     * @param entities - Entities to filter
-     * @param filters - Symbolic filter criteria
-     * @returns Filtered entities with match scores
-     */
-    search(entities, filters) {
-        const results = [];
-        for (const entity of entities) {
-            const { matches, score, matchedFilters } = this.evaluateFilters(entity, filters);
-            if (matches) {
-                results.push({ entity, score, matchedFilters });
-            }
-        }
-        // Sort by score descending
-        return results.sort((a, b) => b.score - a.score);
-    }
-    /**
-     * Evaluate all filters against an entity.
-     */
-    evaluateFilters(entity, filters) {
-        const matchedFilters = [];
-        let totalFilters = 0;
-        let matchedCount = 0;
-        // Tag filter
-        if (filters.tags && filters.tags.length > 0) {
-            totalFilters++;
-            const entityTags = entity.tags ?? [];
-            const matchingTags = filters.tags.filter((t) => entityTags.some((et) => et.toLowerCase() === t.toLowerCase()));
-            if (matchingTags.length > 0) {
-                matchedCount++;
-                matchedFilters.push(`tags:${matchingTags.join(',')}`);
-            }
-            else {
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-        }
-        // Entity type filter
-        if (filters.entityTypes && filters.entityTypes.length > 0) {
-            totalFilters++;
-            if (filters.entityTypes.some((t) => t.toLowerCase() === entity.entityType.toLowerCase())) {
-                matchedCount++;
-                matchedFilters.push(`type:${entity.entityType}`);
-            }
-            else {
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-        }
-        // Date range filter
-        if (filters.dateRange) {
-            totalFilters++;
-            const entityDate = entity.createdAt || entity.lastModified;
-            if (!entityDate) {
-                // Entities without dates are excluded when date filter is applied
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-            const date = new Date(entityDate);
-            const start = filters.dateRange.start ? new Date(filters.dateRange.start) : null;
-            const end = filters.dateRange.end ? new Date(filters.dateRange.end) : null;
-            const inRange = (!start || date >= start) && (!end || date <= end);
-            if (inRange) {
-                matchedCount++;
-                matchedFilters.push('dateRange');
-            }
-            else {
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-        }
-        // Importance filter
-        if (filters.importance) {
-            totalFilters++;
-            const importance = entity.importance ?? 5;
-            const { min, max } = filters.importance;
-            const inRange = (min === undefined || importance >= min) &&
-                (max === undefined || importance <= max);
-            if (inRange) {
-                matchedCount++;
-                matchedFilters.push(`importance:${importance}`);
-            }
-            else {
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-        }
-        // Parent filter
-        if (filters.parentId !== undefined) {
-            totalFilters++;
-            if (entity.parentId === filters.parentId) {
-                matchedCount++;
-                matchedFilters.push(`parent:${filters.parentId}`);
-            }
-            else {
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-        }
-        // Has observations filter
-        if (filters.hasObservations !== undefined) {
-            totalFilters++;
-            const hasObs = entity.observations.length > 0;
-            if (hasObs === filters.hasObservations) {
-                matchedCount++;
-                matchedFilters.push('hasObservations');
-            }
-            else {
-                return { matches: false, score: 0, matchedFilters: [] };
-            }
-        }
-        // If no filters specified, match all with base score
-        if (totalFilters === 0) {
-            return { matches: true, score: 0.5, matchedFilters: [] };
-        }
-        // Score based on proportion of filters matched
-        const score = matchedCount / totalFilters;
-        return { matches: true, score, matchedFilters };
-    }
-    /**
-     * Get entities matching a specific tag.
-     */
-    byTag(entities, tag) {
-        return entities.filter(e => e.tags?.some(t => t.toLowerCase() === tag.toLowerCase()));
-    }
-    /**
-     * Get entities of a specific type.
-     */
-    byType(entities, entityType) {
-        return entities.filter(e => e.entityType.toLowerCase() === entityType.toLowerCase());
-    }
-    /**
-     * Get entities within importance range.
-     */
-    byImportance(entities, min, max) {
-        return entities.filter(e => {
-            const imp = e.importance ?? 5;
-            return imp >= min && imp <= max;
-        });
-    }
-}

package/dist/search/TFIDFEventSync.d.ts

@@ -1,85 +0,0 @@
-/**
- * TF-IDF Event Sync
- *
- * Phase 10 Sprint 3: Hooks TFIDFIndexManager to graph events for automatic
- * incremental index updates when entities change.
- *
- * @module search/TFIDFEventSync
- */
-import type { GraphEventEmitter } from '../core/GraphEventEmitter.js';
-import type { TFIDFIndexManager } from './TFIDFIndexManager.js';
-import type { IGraphStorage } from '../types/index.js';
-/**
- * Phase 10 Sprint 3: Synchronizes TF-IDF index with graph changes via events.
- *
- * Listens to graph events and triggers incremental index updates automatically.
- * More efficient than rebuilding the entire index on every change.
- *
- * @example
- * ```typescript
- * const storage = new GraphStorage('/data/memory.jsonl');
- * const indexManager = new TFIDFIndexManager('/data');
- *
- * // Load or build index
- * await indexManager.loadIndex();
- *
- * // Enable automatic sync
- * const sync = new TFIDFEventSync(indexManager, storage.events, storage);
- * sync.enable();
- *
- * // Now entities added to storage will automatically update the index
- * await storage.appendEntity({ name: 'New', entityType: 'test', observations: [] });
- *
- * // Disable when done
- * sync.disable();
- * ```
- */
-export declare class TFIDFEventSync {
-    private indexManager;
-    private eventEmitter;
-    private storage;
-    private unsubscribers;
-    private enabled;
-    /**
-     * Create a new TFIDFEventSync instance.
-     *
-     * @param indexManager - TFIDFIndexManager to sync
-     * @param eventEmitter - GraphEventEmitter to listen to
-     * @param storage - Storage to fetch entity data from (for updates)
-     */
-    constructor(indexManager: TFIDFIndexManager, eventEmitter: GraphEventEmitter, storage: IGraphStorage);
-    /**
-     * Enable automatic index synchronization.
-     *
-     * Subscribes to entity:created, entity:updated, and entity:deleted events.
-     */
-    enable(): void;
-    /**
-     * Disable automatic index synchronization.
-     *
-     * Unsubscribes from all events.
-     */
-    disable(): void;
-    /**
-     * Check if synchronization is enabled.
-     *
-     * @returns True if enabled
-     */
-    isEnabled(): boolean;
-    /**
-     * Handle entity:created event.
-     * @private
-     */
-    private handleEntityCreated;
-    /**
-     * Handle entity:updated event.
-     * @private
-     */
-    private handleEntityUpdated;
-    /**
-     * Handle entity:deleted event.
-     * @private
-     */
-    private handleEntityDeleted;
-}
-//# sourceMappingURL=TFIDFEventSync.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"TFIDFEventSync.d.ts","sourceRoot":"","sources":["../../src/search/TFIDFEventSync.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAOvD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,YAAY,CAAoB;IACxC,OAAO,CAAC,OAAO,CAAgB;IAC/B,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,OAAO,CAAkB;IAEjC;;;;;;OAMG;gBAED,YAAY,EAAE,iBAAiB,EAC/B,YAAY,EAAE,iBAAiB,EAC/B,OAAO,EAAE,aAAa;IAOxB;;;;OAIG;IACH,MAAM,IAAI,IAAI;IAqBd;;;;OAIG;IACH,OAAO,IAAI,IAAI;IAYf;;;;OAIG;IACH,SAAS,IAAI,OAAO;IAIpB;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAY3B;;;OAGG;YACW,mBAAmB;IAkBjC;;;OAGG;IACH,OAAO,CAAC,mBAAmB;CAO5B"}

package/dist/search/TFIDFEventSync.js

@@ -1,133 +0,0 @@
-/**
- * TF-IDF Event Sync
- *
- * Phase 10 Sprint 3: Hooks TFIDFIndexManager to graph events for automatic
- * incremental index updates when entities change.
- *
- * @module search/TFIDFEventSync
- */
-/**
- * Phase 10 Sprint 3: Synchronizes TF-IDF index with graph changes via events.
- *
- * Listens to graph events and triggers incremental index updates automatically.
- * More efficient than rebuilding the entire index on every change.
- *
- * @example
- * ```typescript
- * const storage = new GraphStorage('/data/memory.jsonl');
- * const indexManager = new TFIDFIndexManager('/data');
- *
- * // Load or build index
- * await indexManager.loadIndex();
- *
- * // Enable automatic sync
- * const sync = new TFIDFEventSync(indexManager, storage.events, storage);
- * sync.enable();
- *
- * // Now entities added to storage will automatically update the index
- * await storage.appendEntity({ name: 'New', entityType: 'test', observations: [] });
- *
- * // Disable when done
- * sync.disable();
- * ```
- */
-export class TFIDFEventSync {
-    indexManager;
-    eventEmitter;
-    storage;
-    unsubscribers = [];
-    enabled = false;
-    /**
-     * Create a new TFIDFEventSync instance.
-     *
-     * @param indexManager - TFIDFIndexManager to sync
-     * @param eventEmitter - GraphEventEmitter to listen to
-     * @param storage - Storage to fetch entity data from (for updates)
-     */
-    constructor(indexManager, eventEmitter, storage) {
-        this.indexManager = indexManager;
-        this.eventEmitter = eventEmitter;
-        this.storage = storage;
-    }
-    /**
-     * Enable automatic index synchronization.
-     *
-     * Subscribes to entity:created, entity:updated, and entity:deleted events.
-     */
-    enable() {
-        if (this.enabled) {
-            return;
-        }
-        // Subscribe to entity events
-        this.unsubscribers.push(this.eventEmitter.on('entity:created', this.handleEntityCreated.bind(this)));
-        this.unsubscribers.push(this.eventEmitter.on('entity:updated', this.handleEntityUpdated.bind(this)));
-        this.unsubscribers.push(this.eventEmitter.on('entity:deleted', this.handleEntityDeleted.bind(this)));
-        this.enabled = true;
-    }
-    /**
-     * Disable automatic index synchronization.
-     *
-     * Unsubscribes from all events.
-     */
-    disable() {
-        if (!this.enabled) {
-            return;
-        }
-        for (const unsubscribe of this.unsubscribers) {
-            unsubscribe();
-        }
-        this.unsubscribers = [];
-        this.enabled = false;
-    }
-    /**
-     * Check if synchronization is enabled.
-     *
-     * @returns True if enabled
-     */
-    isEnabled() {
-        return this.enabled;
-    }
-    /**
-     * Handle entity:created event.
-     * @private
-     */
-    handleEntityCreated(event) {
-        if (!this.indexManager.isInitialized()) {
-            return;
-        }
-        this.indexManager.addDocument({
-            name: event.entity.name,
-            entityType: event.entity.entityType,
-            observations: event.entity.observations,
-        });
-    }
-    /**
-     * Handle entity:updated event.
-     * @private
-     */
-    async handleEntityUpdated(event) {
-        if (!this.indexManager.isInitialized()) {
-            return;
-        }
-        // Fetch the current entity state
-        const graph = await this.storage.loadGraph();
-        const entity = graph.entities.find(e => e.name === event.entityName);
-        if (entity) {
-            this.indexManager.updateDocument({
-                name: entity.name,
-                entityType: entity.entityType,
-                observations: entity.observations,
-            });
-        }
-    }
-    /**
-     * Handle entity:deleted event.
-     * @private
-     */
-    handleEntityDeleted(event) {
-        if (!this.indexManager.isInitialized()) {
-            return;
-        }
-        this.indexManager.removeDocument(event.entityName);
-    }
-}

package/dist/utils/BatchProcessor.d.ts

@@ -1,271 +0,0 @@
-/**
- * Batch Processor
- *
- * Phase 12 Sprint 2: Generic batch processing utility with parallel execution,
- * retry logic, progress callbacks, and error collection.
- *
- * @module utils/BatchProcessor
- */
-/**
- * Progress information for batch processing.
- */
-export interface BatchProgress {
-    /** Number of items completed (successfully or failed) */
-    completed: number;
-    /** Total number of items to process */
-    total: number;
-    /** Completion percentage (0-100) */
-    percentage: number;
-    /** Number of successful items */
-    succeeded: number;
-    /** Number of failed items */
-    failed: number;
-    /** Current item being processed (if applicable) */
-    currentItem?: unknown;
-    /** Current batch index */
-    batchIndex: number;
-    /** Total number of batches */
-    totalBatches: number;
-}
-/**
- * Progress callback function type.
- */
-export type BatchProgressCallback = (progress: BatchProgress) => void;
-/**
- * Result for a single item in the batch.
- */
-export interface BatchItemResult<T> {
-    /** Index of the item in the original array */
-    index: number;
-    /** Whether the processing succeeded */
-    success: boolean;
-    /** Result value if successful */
-    result?: T;
-    /** Error if failed */
-    error?: Error;
-    /** Number of attempts made */
-    attempts: number;
-    /** Processing time in milliseconds */
-    durationMs: number;
-}
-/**
- * Overall result of batch processing.
- */
-export interface BatchProcessResult<T> {
-    /** Results for each item */
-    results: BatchItemResult<T>[];
-    /** Number of successful items */
-    succeeded: number;
-    /** Number of failed items */
-    failed: number;
-    /** Total processing time in milliseconds */
-    totalTimeMs: number;
-    /** Whether all items succeeded */
-    allSucceeded: boolean;
-    /** Errors encountered (indexed by item position) */
-    errors: Map<number, Error>;
-}
-/**
- * Options for batch processing.
- */
-export interface BatchProcessorOptions {
-    /** Number of items to process concurrently (default: 4) */
-    concurrency?: number;
-    /** Size of each batch for progress reporting (default: equals concurrency) */
-    batchSize?: number;
-    /** Maximum retry attempts per item (default: 0 - no retries) */
-    maxRetries?: number;
-    /** Initial delay between retries in milliseconds (default: 1000) */
-    retryDelayMs?: number;
-    /** Exponential backoff multiplier (default: 2) */
-    retryBackoffMultiplier?: number;
-    /** Maximum retry delay in milliseconds (default: 30000) */
-    maxRetryDelayMs?: number;
-    /** Whether to continue processing on item failure (default: true) */
-    continueOnError?: boolean;
-    /** Progress callback function */
-    onProgress?: BatchProgressCallback;
-    /** Timeout per item in milliseconds (default: no timeout) */
-    itemTimeoutMs?: number;
-    /** Optional abort signal for cancellation */
-    signal?: AbortSignal;
-}
-/**
- * BatchProcessor - Generic batch processing with parallel execution
- *
- * Provides a flexible utility for processing arrays of items with:
- * - Configurable concurrency
- * - Automatic retry with exponential backoff
- * - Progress callbacks for monitoring
- * - Error collection without failing the entire batch
- * - Cancellation support via AbortSignal
- *
- * @example
- * ```typescript
- * const processor = new BatchProcessor<string, number>({
- *   concurrency: 4,
- *   maxRetries: 3,
- *   onProgress: (p) => console.log(`${p.percentage.toFixed(1)}% complete`),
- * });
- *
- * const result = await processor.process(
- *   ['item1', 'item2', 'item3'],
- *   async (item) => {
- *     const response = await fetchData(item);
- *     return response.value;
- *   }
- * );
- *
- * console.log(`Succeeded: ${result.succeeded}, Failed: ${result.failed}`);
- * ```
- */
-export declare class BatchProcessor<TInput, TOutput> {
-    private options;
-    constructor(options?: BatchProcessorOptions);
-    /**
-     * Process all items in batches with the specified processor function.
-     *
-     * @param items - Array of items to process
-     * @param processor - Async function to process each item
-     * @returns Batch processing result with all item results and statistics
-     */
-    process(items: TInput[], processor: (item: TInput, index: number) => Promise<TOutput>): Promise<BatchProcessResult<TOutput>>;
-    /**
-     * Process a single item with retry logic.
-     */
-    private processItem;
-    /**
-     * Calculate delay for retry with exponential backoff.
-     */
-    private calculateRetryDelay;
-    /**
-     * Create a timeout promise.
-     */
-    private createTimeout;
-    /**
-     * Sleep for the specified duration.
-     */
-    private sleep;
-    /**
-     * Get the configured options.
-     */
-    getOptions(): BatchProcessorOptions;
-}
-/**
- * Process items in parallel batches (convenience function).
- *
- * @template TInput - Input item type
- * @template TOutput - Output result type
- * @param items - Array of items to process
- * @param processor - Async function to process each item
- * @param options - Batch processing options
- * @returns Batch processing result
- *
- * @example
- * ```typescript
- * const result = await processBatch(
- *   urls,
- *   async (url) => fetch(url).then(r => r.json()),
- *   { concurrency: 5, maxRetries: 2 }
- * );
- * ```
- */
-export declare function processBatch<TInput, TOutput>(items: TInput[], processor: (item: TInput, index: number) => Promise<TOutput>, options?: BatchProcessorOptions): Promise<BatchProcessResult<TOutput>>;
-/**
- * Process items with automatic retry on failure (convenience function).
- *
- * @template TInput - Input item type
- * @template TOutput - Output result type
- * @param items - Array of items to process
- * @param processor - Async function to process each item
- * @param maxRetries - Maximum retry attempts (default: 3)
- * @param onProgress - Optional progress callback
- * @returns Batch processing result
- *
- * @example
- * ```typescript
- * const result = await processWithRetry(
- *   items,
- *   async (item) => unreliableOperation(item),
- *   3,
- *   (p) => console.log(`${p.percentage}%`)
- * );
- * ```
- */
-export declare function processWithRetry<TInput, TOutput>(items: TInput[], processor: (item: TInput, index: number) => Promise<TOutput>, maxRetries?: number, onProgress?: BatchProgressCallback): Promise<BatchProcessResult<TOutput>>;
-/**
- * Chunk an array into smaller arrays of specified size.
- *
- * @template T - Item type
- * @param array - Array to chunk
- * @param size - Size of each chunk
- * @returns Array of chunks
- *
- * @example
- * ```typescript
- * const chunks = chunkArray([1, 2, 3, 4, 5], 2);
- * // [[1, 2], [3, 4], [5]]
- * ```
- */
-export declare function chunkArray<T>(array: T[], size: number): T[][];
-/**
- * Execute async functions in parallel with a concurrency limit.
- *
- * @template T - Result type
- * @param tasks - Array of async functions to execute
- * @param concurrency - Maximum concurrent executions
- * @returns Array of results (successful results or errors)
- *
- * @example
- * ```typescript
- * const tasks = urls.map(url => () => fetch(url));
- * const results = await parallelLimit(tasks, 5);
- * ```
- */
-export declare function parallelLimit<T>(tasks: Array<() => Promise<T>>, concurrency: number): Promise<Array<{
-    success: true;
-    value: T;
-} | {
-    success: false;
-    error: Error;
-}>>;
-/**
- * Map over items in parallel with a concurrency limit.
- *
- * @template TInput - Input item type
- * @template TOutput - Output result type
- * @param items - Array of items to map
- * @param mapper - Async mapping function
- * @param concurrency - Maximum concurrent operations (default: 4)
- * @returns Array of results (in order)
- *
- * @example
- * ```typescript
- * const results = await mapParallel(
- *   ids,
- *   async (id) => fetchUser(id),
- *   10
- * );
- * ```
- */
-export declare function mapParallel<TInput, TOutput>(items: TInput[], mapper: (item: TInput, index: number) => Promise<TOutput>, concurrency?: number): Promise<TOutput[]>;
-/**
- * Filter items in parallel with a concurrency limit.
- *
- * @template T - Item type
- * @param items - Array of items to filter
- * @param predicate - Async predicate function
- * @param concurrency - Maximum concurrent operations (default: 4)
- * @returns Filtered array (in order)
- *
- * @example
- * ```typescript
- * const validItems = await filterParallel(
- *   items,
- *   async (item) => validateItem(item),
- *   10
- * );
- * ```
- */
-export declare function filterParallel<T>(items: T[], predicate: (item: T, index: number) => Promise<boolean>, concurrency?: number): Promise<T[]>;
-//# sourceMappingURL=BatchProcessor.d.ts.map

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

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