@danielsimonjr/memory-mcp 11.0.1 → 11.1.1

package/dist/features/ArchiveManager.js

@@ -10,7 +10,7 @@
  */
 import { promises as fs } from 'fs';
 import { dirname, join } from 'path';
-import { compress, COMPRESSION_CONFIG, checkCancellation, createProgressReporter, createProgress, } from '../utils/index.js';
+import { compress, COMPRESSION_CONFIG } from '../utils/index.js';
 /**
  * Manages archive operations for the knowledge graph.
  *
@@ -38,12 +38,9 @@ export class ArchiveManager {
      * being removed from the active graph. Use `saveToFile: false` to
      * skip creating the archive file.
      *
-     * Phase 9B: Supports progress tracking and cancellation via options.
-     *
      * @param criteria - Archiving criteria
-     * @param options - Archive options (dryRun, saveToFile, onProgress, signal)
+     * @param options - Archive options (dryRun, saveToFile)
      * @returns Archive result with count, entity names, and compression stats
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      *
      * @example
      * ```typescript
@@ -57,13 +54,6 @@ export class ArchiveManager {
      *
      * // Preview without making changes
      * const preview = await manager.archiveEntities(criteria, { dryRun: true });
-     *
-     * // With progress tracking and cancellation (Phase 9B)
-     * const controller = new AbortController();
-     * const result = await manager.archiveEntities(criteria, {
-     *   signal: controller.signal,
-     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
-     * });
      * ```
      */
     async archiveEntities(criteria, options = {}) {
@@ -71,21 +61,10 @@ export class ArchiveManager {
         const opts = typeof options === 'boolean'
             ? { dryRun: options, saveToFile: true }
             : { saveToFile: true, ...options };
-        // Check for early cancellation
-        checkCancellation(opts.signal, 'archiveEntities');
-        // Setup progress reporter
-        const reportProgress = createProgressReporter(opts.onProgress);
-        reportProgress?.(createProgress(0, 100, 'archiveEntities'));
         // Use read-only graph for analysis
         const readGraph = await this.storage.loadGraph();
         const toArchive = [];
-        const totalEntities = readGraph.entities.length;
-        let processedEntities = 0;
-        // Phase 1: Identify entities to archive (0-40% progress)
-        reportProgress?.(createProgress(5, 100, 'analyzing entities'));
         for (const entity of readGraph.entities) {
-            // Check for cancellation periodically
-            checkCancellation(opts.signal, 'archiveEntities');
             let shouldArchive = false;
             // Check age criteria
             if (criteria.olderThan && entity.lastModified) {
@@ -113,15 +92,9 @@ export class ArchiveManager {
             if (shouldArchive) {
                 toArchive.push(entity);
             }
-            processedEntities++;
-            // Map analysis progress (0-100%) to overall progress (0-40%)
-            const analysisProgress = totalEntities > 0 ? Math.round((processedEntities / totalEntities) * 40) : 40;
-            reportProgress?.(createProgress(analysisProgress, 100, 'analyzing entities'));
         }
-        reportProgress?.(createProgress(40, 100, 'analysis complete'));
         // Dry run - return preview without changes
         if (opts.dryRun) {
-            reportProgress?.(createProgress(100, 100, 'archiveEntities'));
             return {
                 archived: toArchive.length,
                 entityNames: toArchive.map(e => e.name),
@@ -129,35 +102,23 @@ export class ArchiveManager {
         }
         // No entities to archive
         if (toArchive.length === 0) {
-            reportProgress?.(createProgress(100, 100, 'archiveEntities'));
             return {
                 archived: 0,
                 entityNames: [],
             };
         }
-        // Check for cancellation before archiving
-        checkCancellation(opts.signal, 'archiveEntities');
-        // Phase 2: Save to compressed archive file (40-80% progress)
+        // Save to compressed archive file
         let archivePath;
         let originalSize;
         let compressedSize;
         let compressionRatio;
         if (opts.saveToFile) {
-            reportProgress?.(createProgress(50, 100, 'compressing archive'));
             const archiveResult = await this.saveToArchive(toArchive);
             archivePath = archiveResult.archivePath;
             originalSize = archiveResult.originalSize;
             compressedSize = archiveResult.compressedSize;
             compressionRatio = archiveResult.compressionRatio;
-            reportProgress?.(createProgress(80, 100, 'archive saved'));
-        }
-        else {
-            reportProgress?.(createProgress(80, 100, 'skipped archive file'));
         }
-        // Check for cancellation before graph modification
-        checkCancellation(opts.signal, 'archiveEntities');
-        // Phase 3: Remove from main graph (80-100% progress)
-        reportProgress?.(createProgress(85, 100, 'updating graph'));
         // Get mutable copy for write operation
         const graph = await this.storage.getGraphForMutation();
         // Remove archived entities from main graph
@@ -165,8 +126,6 @@ export class ArchiveManager {
         graph.entities = graph.entities.filter(e => !archiveNames.has(e.name));
         graph.relations = graph.relations.filter(r => !archiveNames.has(r.from) && !archiveNames.has(r.to));
         await this.storage.saveGraph(graph);
-        // Report completion
-        reportProgress?.(createProgress(100, 100, 'archiveEntities'));
         return {
             archived: toArchive.length,
             entityNames: toArchive.map(e => e.name),

package/dist/features/CompressionManager.d.ts

@@ -6,7 +6,7 @@
  *
  * @module features/CompressionManager
  */
-import type { Entity, CompressionResult, KnowledgeGraph, LongRunningOperationOptions } from '../types/index.js';
+import type { Entity, CompressionResult, KnowledgeGraph } from '../types/index.js';
 import type { GraphStorage } from '../core/GraphStorage.js';
 /**
  * Manages compression operations for the knowledge graph.
@@ -18,10 +18,8 @@ export declare class CompressionManager {
      * Prepare an entity for efficient similarity comparisons.
      * Pre-computes all normalized data to avoid repeated computation.
      *
-     * Phase 12 Sprint 1: Added nameHash for fast bucketing.
-     *
      * @param entity - The entity to prepare
-     * @returns PreparedEntity with pre-computed data including hash
+     * @returns PreparedEntity with pre-computed data
      */
     private prepareEntity;
     /**
@@ -67,16 +65,12 @@ export declare class CompressionManager {
      * 2. Within each type, buckets by name prefix (first 2 chars normalized)
      * 3. Only compares entities within same or adjacent buckets
      *
-     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
-     *
      * Complexity: O(n·k) where k is average bucket size (typically << n)
      *
      * @param threshold - Similarity threshold (0.0 to 1.0), default DEFAULT_DUPLICATE_THRESHOLD
-     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Array of duplicate groups (each group has similar entities)
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      */
-    findDuplicates(threshold?: number, options?: LongRunningOperationOptions): Promise<string[][]>;
+    findDuplicates(threshold?: number): Promise<string[][]>;
     /**
      * Merge a group of entities into a single entity.
      *
@@ -106,14 +100,10 @@ export declare class CompressionManager {
      * Compress the knowledge graph by finding and merging duplicates.
      * OPTIMIZED: Loads graph once, performs all merges, saves once.
      *
-     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
-     *
      * @param threshold - Similarity threshold for duplicate detection (0.0 to 1.0), default DEFAULT_DUPLICATE_THRESHOLD
      * @param dryRun - If true, only report what would be compressed without applying changes
-     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Compression result with statistics
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      */
-    compressGraph(threshold?: number, dryRun?: boolean, options?: LongRunningOperationOptions): Promise<CompressionResult>;
+    compressGraph(threshold?: number, dryRun?: boolean): Promise<CompressionResult>;
 }
 //# sourceMappingURL=CompressionManager.d.ts.map

package/dist/features/CompressionManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CompressionManager.d.ts","sourceRoot":"","sources":["../../src/features/CompressionManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAY,iBAAiB,EAAE,cAAc,EAAE,2BAA2B,EAAkB,MAAM,mBAAmB,CAAC;AAC1I,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAW5D;;GAEG;AACH,qBAAa,kBAAkB;IACjB,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY;IAEzC;;;;;;;;OAQG;IACH,OAAO,CAAC,aAAa;IAYrB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;;;;;;;OAWG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAwCzD;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;;;;;;OAOG;IACH,OAAO,CAAC,2BAA2B;IAoCnC;;;;;;;;;;;;;;;;OAgBG;IACG,cAAc,CAClB,SAAS,GAAE,MAAoC,EAC/C,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IA0GtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,aAAa,CACjB,WAAW,EAAE,MAAM,EAAE,EACrB,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,GAAE;QACP,KAAK,CAAC,EAAE,cAAc,CAAC;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACf,GACL,OAAO,CAAC,MAAM,CAAC;IA8FlB;;;;;;;;;;;OAWG;IACG,aAAa,CACjB,SAAS,GAAE,MAAoC,EAC/C,MAAM,GAAE,OAAe,EACvB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,iBAAiB,CAAC;CAgH9B"}
+{"version":3,"file":"CompressionManager.d.ts","sourceRoot":"","sources":["../../src/features/CompressionManager.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAY,iBAAiB,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAsB5D;;GAEG;AACH,qBAAa,kBAAkB;IACjB,OAAO,CAAC,OAAO;gBAAP,OAAO,EAAE,YAAY;IAEzC;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAUrB;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAQvB;;;;;;;;;;;OAWG;IACH,yBAAyB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM;IAwCzD;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAU3B;;;;;;;OAOG;IACH,OAAO,CAAC,2BAA2B;IAoCnC;;;;;;;;;;;;OAYG;IACG,cAAc,CAAC,SAAS,GAAE,MAAoC,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;IAiF1F;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,aAAa,CACjB,WAAW,EAAE,MAAM,EAAE,EACrB,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,GAAE;QACP,KAAK,CAAC,EAAE,cAAc,CAAC;QACvB,QAAQ,CAAC,EAAE,OAAO,CAAC;KACf,GACL,OAAO,CAAC,MAAM,CAAC;IA8FlB;;;;;;;OAOG;IACG,aAAa,CAAC,SAAS,GAAE,MAAoC,EAAE,MAAM,GAAE,OAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC;CAoE1H"}

package/dist/features/CompressionManager.js

@@ -6,7 +6,7 @@
  *
  * @module features/CompressionManager
  */
-import { levenshteinDistance, checkCancellation, createProgressReporter, createProgress, fnv1aHash, } from '../utils/index.js';
+import { levenshteinDistance } from '../utils/index.js';
 import { EntityNotFoundError, InsufficientEntitiesError } from '../utils/errors.js';
 import { SIMILARITY_WEIGHTS, DEFAULT_DUPLICATE_THRESHOLD } from '../utils/constants.js';
 /**
@@ -21,20 +21,16 @@ export class CompressionManager {
      * Prepare an entity for efficient similarity comparisons.
      * Pre-computes all normalized data to avoid repeated computation.
      *
-     * Phase 12 Sprint 1: Added nameHash for fast bucketing.
-     *
      * @param entity - The entity to prepare
-     * @returns PreparedEntity with pre-computed data including hash
+     * @returns PreparedEntity with pre-computed data
      */
     prepareEntity(entity) {
-        const nameLower = entity.name.toLowerCase();
         return {
             entity,
-            nameLower,
+            nameLower: entity.name.toLowerCase(),
             typeLower: entity.entityType.toLowerCase(),
             observationSet: new Set(entity.observations.map(o => o.toLowerCase())),
             tagSet: new Set((entity.tags ?? []).map(t => t.toLowerCase())),
-            nameHash: fnv1aHash(nameLower),
         };
     }
     /**
@@ -157,26 +153,15 @@ export class CompressionManager {
      * 2. Within each type, buckets by name prefix (first 2 chars normalized)
      * 3. Only compares entities within same or adjacent buckets
      *
-     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
-     *
      * Complexity: O(n·k) where k is average bucket size (typically << n)
      *
      * @param threshold - Similarity threshold (0.0 to 1.0), default DEFAULT_DUPLICATE_THRESHOLD
-     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Array of duplicate groups (each group has similar entities)
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      */
-    async findDuplicates(threshold = DEFAULT_DUPLICATE_THRESHOLD, options) {
-        // Check for early cancellation
-        checkCancellation(options?.signal, 'findDuplicates');
+    async findDuplicates(threshold = DEFAULT_DUPLICATE_THRESHOLD) {
         const graph = await this.storage.loadGraph();
         const duplicateGroups = [];
         const processed = new Set();
-        // Setup progress reporter
-        const reportProgress = createProgressReporter(options?.onProgress);
-        const totalEntities = graph.entities.length;
-        let processedCount = 0;
-        reportProgress?.(createProgress(0, totalEntities, 'findDuplicates'));
         // OPTIMIZATION: Pre-prepare all entities once before comparisons
         const preparedEntities = this.prepareEntities(graph.entities);
         // Step 1: Bucket entities by type (reduces comparisons drastically)
@@ -190,14 +175,9 @@ export class CompressionManager {
         }
         // Step 2: For each type bucket, sub-bucket by name prefix
         for (const entities of typeMap.values()) {
-            // Check for cancellation between type buckets
-            checkCancellation(options?.signal, 'findDuplicates');
             // Skip single-entity types (no duplicates possible)
-            if (entities.length < 2) {
-                processedCount += entities.length;
-                reportProgress?.(createProgress(processedCount, totalEntities, 'findDuplicates'));
+            if (entities.length < 2)
                 continue;
-            }
             // Create name prefix buckets (first 2 chars, normalized)
             const prefixMap = new Map();
             for (const entity of entities) {
@@ -210,8 +190,6 @@ export class CompressionManager {
             // Step 3: Compare only within buckets (or adjacent buckets for fuzzy matching)
             const prefixKeys = Array.from(prefixMap.keys()).sort();
             for (let bucketIdx = 0; bucketIdx < prefixKeys.length; bucketIdx++) {
-                // Check for cancellation between prefix buckets
-                checkCancellation(options?.signal, 'findDuplicates');
                 const currentPrefix = prefixKeys[bucketIdx];
                 const currentBucket = prefixMap.get(currentPrefix);
                 // Collect entities to compare: current bucket + adjacent buckets
@@ -244,13 +222,9 @@ export class CompressionManager {
                         duplicateGroups.push(group);
                         processed.add(entity1.name);
                     }
-                    processedCount++;
-                    reportProgress?.(createProgress(processedCount, totalEntities, 'findDuplicates'));
                 }
             }
         }
-        // Report completion
-        reportProgress?.(createProgress(totalEntities, totalEntities, 'findDuplicates'));
         return duplicateGroups;
     }
     /**
@@ -363,32 +337,12 @@ export class CompressionManager {
      * Compress the knowledge graph by finding and merging duplicates.
      * OPTIMIZED: Loads graph once, performs all merges, saves once.
      *
-     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
-     *
      * @param threshold - Similarity threshold for duplicate detection (0.0 to 1.0), default DEFAULT_DUPLICATE_THRESHOLD
      * @param dryRun - If true, only report what would be compressed without applying changes
-     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Compression result with statistics
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      */
-    async compressGraph(threshold = DEFAULT_DUPLICATE_THRESHOLD, dryRun = false, options) {
-        // Check for early cancellation
-        checkCancellation(options?.signal, 'compressGraph');
-        // Setup progress reporter (we'll use phases: 50% finding duplicates, 50% merging)
-        const reportProgress = createProgressReporter(options?.onProgress);
-        reportProgress?.(createProgress(0, 100, 'compressGraph'));
-        // Phase 1: Find duplicates (0-50% progress)
-        const duplicateGroups = await this.findDuplicates(threshold, {
-            signal: options?.signal,
-            onProgress: (p) => {
-                // Map findDuplicates progress (0-100%) to compressGraph progress (0-50%)
-                const compressProgress = Math.round(p.percentage * 0.5);
-                reportProgress?.(createProgress(compressProgress, 100, 'finding duplicates'));
-            },
-        });
-        // Check for cancellation after finding duplicates
-        checkCancellation(options?.signal, 'compressGraph');
-        reportProgress?.(createProgress(50, 100, 'compressGraph'));
+    async compressGraph(threshold = DEFAULT_DUPLICATE_THRESHOLD, dryRun = false) {
+        const duplicateGroups = await this.findDuplicates(threshold);
         // OPTIMIZATION: Load graph once for all operations
         const graph = await this.storage.getGraphForMutation();
         const initialSize = JSON.stringify(graph).length;
@@ -409,26 +363,15 @@ export class CompressionManager {
                 });
                 result.entitiesMerged += group.length - 1;
             }
-            reportProgress?.(createProgress(100, 100, 'compressGraph'));
             return result;
         }
-        // Phase 2: Merge duplicates (50-100% progress)
-        const totalGroups = duplicateGroups.length;
-        let mergedGroups = 0;
-        // OPTIMIZATION: Build entity lookup map for O(1) access during merges
-        const entityMap = new Map();
-        for (const entity of graph.entities) {
-            entityMap.set(entity.name, entity);
-        }
         // Merge all duplicates using the same graph instance
         for (const group of duplicateGroups) {
-            // Check for cancellation between merges
-            checkCancellation(options?.signal, 'compressGraph');
             try {
-                // Count observations before merge using O(1) lookup
+                // Count observations before merge using loaded graph
                 let totalObservationsBefore = 0;
                 for (const name of group) {
-                    const entity = entityMap.get(name);
+                    const entity = graph.entities.find(e => e.name === name);
                     if (entity) {
                         totalObservationsBefore += entity.observations.length;
                     }
@@ -450,20 +393,12 @@ export class CompressionManager {
                 // Skip groups that fail to merge
                 console.error(`Failed to merge group ${group}:`, error);
             }
-            mergedGroups++;
-            // Map merge progress (0-100%) to compressGraph progress (50-100%)
-            const mergeProgress = totalGroups > 0 ? Math.round(50 + (mergedGroups / totalGroups) * 50) : 100;
-            reportProgress?.(createProgress(mergeProgress, 100, 'merging entities'));
         }
-        // Check for cancellation before final save
-        checkCancellation(options?.signal, 'compressGraph');
         // OPTIMIZATION: Save once after all merges complete
         await this.storage.saveGraph(graph);
         const finalSize = JSON.stringify(graph).length;
         result.spaceFreed = initialSize - finalSize;
         result.relationsConsolidated = result.entitiesMerged;
-        // Report completion
-        reportProgress?.(createProgress(100, 100, 'compressGraph'));
         return result;
     }
 }

package/dist/features/IOManager.d.ts

@@ -6,7 +6,7 @@
  *
  * @module features/IOManager
  */
-import type { ReadonlyKnowledgeGraph, ImportResult, BackupOptions, BackupResult, RestoreResult, ExportOptions, ExportResult, LongRunningOperationOptions } from '../types/index.js';
+import type { ReadonlyKnowledgeGraph, ImportResult, BackupOptions, BackupResult, RestoreResult, ExportOptions, ExportResult } from '../types/index.js';
 import type { GraphStorage } from '../core/GraphStorage.js';
 /**
  * Supported export formats.
@@ -132,17 +132,13 @@ export declare class IOManager {
     /**
      * Import graph from formatted data.
      *
-     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
-     *
      * @param format - Import format
      * @param data - Import data string
      * @param mergeStrategy - How to handle conflicts
      * @param dryRun - If true, preview changes without applying
-     * @param options - Optional progress/cancellation options (Phase 9B)
      * @returns Import result with statistics
-     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
      */
-    importGraph(format: ImportFormat, data: string, mergeStrategy?: MergeStrategy, dryRun?: boolean, options?: LongRunningOperationOptions): Promise<ImportResult>;
+    importGraph(format: ImportFormat, data: string, mergeStrategy?: MergeStrategy, dryRun?: boolean): Promise<ImportResult>;
     private parseJsonImport;
     private parseCsvImport;
     private parseGraphMLImport;

package/dist/features/IOManager.d.ts.map

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