@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/features/CompressionManager.js

@@ -1,27 +1,60 @@
 /**
  * Compression Manager
  *
- * Detects and merges duplicate entities to compress the knowledge graph.
+ * Handles duplicate detection, entity merging, and graph compression.
+ * Extracted from SearchManager (Phase 4: Consolidate God Objects).
  *
  * @module features/CompressionManager
  */
-import { levenshteinDistance } from '../utils/levenshtein.js';
+import { levenshteinDistance, checkCancellation, createProgressReporter, createProgress, } from '../utils/index.js';
 import { EntityNotFoundError, InsufficientEntitiesError } from '../utils/errors.js';
 import { SIMILARITY_WEIGHTS, DEFAULT_DUPLICATE_THRESHOLD } from '../utils/constants.js';
 /**
- * Manages graph compression through duplicate detection and merging.
+ * Manages compression operations for the knowledge graph.
  */
 export class CompressionManager {
     storage;
     constructor(storage) {
         this.storage = storage;
     }
+    /**
+     * Prepare an entity for efficient similarity comparisons.
+     * Pre-computes all normalized data to avoid repeated computation.
+     *
+     * @param entity - The entity to prepare
+     * @returns PreparedEntity with pre-computed data
+     */
+    prepareEntity(entity) {
+        return {
+            entity,
+            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())),
+        };
+    }
+    /**
+     * Prepare multiple entities for efficient similarity comparisons.
+     * Use this before batch comparison operations.
+     *
+     * @param entities - Entities to prepare
+     * @returns Map of entity name to PreparedEntity
+     */
+    prepareEntities(entities) {
+        const prepared = new Map();
+        for (const entity of entities) {
+            prepared.set(entity.name, this.prepareEntity(entity));
+        }
+        return prepared;
+    }
     /**
      * Calculate similarity between two entities using multiple heuristics.
      *
      * Uses configurable weights defined in SIMILARITY_WEIGHTS constant.
      * See SIMILARITY_WEIGHTS for the breakdown of scoring factors.
      *
+     * NOTE: For batch comparisons, use prepareEntities() + calculatePreparedSimilarity() for better performance.
+     *
      * @param e1 - First entity
      * @param e2 - Second entity
      * @returns Similarity score from 0 (completely different) to 1 (identical)
@@ -60,6 +93,58 @@ export class CompressionManager {
         }
         return factors > 0 ? score / factors : 0;
     }
+    /**
+     * Efficiently calculate intersection size of two Sets without creating a new Set.
+     * Iterates over the smaller set for O(min(m,n)) complexity.
+     */
+    setIntersectionSize(a, b) {
+        // Always iterate over smaller set
+        const [smaller, larger] = a.size <= b.size ? [a, b] : [b, a];
+        let count = 0;
+        for (const item of smaller) {
+            if (larger.has(item))
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Calculate similarity between two prepared entities.
+     * OPTIMIZED: Uses pre-computed Sets to avoid O(n) set creation per comparison.
+     *
+     * @param p1 - First prepared entity
+     * @param p2 - Second prepared entity
+     * @returns Similarity score from 0 (completely different) to 1 (identical)
+     */
+    calculatePreparedSimilarity(p1, p2) {
+        let score = 0;
+        let factors = 0;
+        // Name similarity (Levenshtein-based) - use pre-computed lowercase
+        const nameDistance = levenshteinDistance(p1.nameLower, p2.nameLower);
+        const maxNameLength = Math.max(p1.nameLower.length, p2.nameLower.length);
+        const nameSimilarity = 1 - nameDistance / maxNameLength;
+        score += nameSimilarity * SIMILARITY_WEIGHTS.NAME;
+        factors += SIMILARITY_WEIGHTS.NAME;
+        // Type similarity (exact match) - use pre-computed lowercase
+        if (p1.typeLower === p2.typeLower) {
+            score += SIMILARITY_WEIGHTS.TYPE;
+        }
+        factors += SIMILARITY_WEIGHTS.TYPE;
+        // Observation overlap (Jaccard similarity) - use pre-computed Sets
+        const obsIntersectionSize = this.setIntersectionSize(p1.observationSet, p2.observationSet);
+        const obsUnionSize = p1.observationSet.size + p2.observationSet.size - obsIntersectionSize;
+        const observationSimilarity = obsUnionSize > 0 ? obsIntersectionSize / obsUnionSize : 0;
+        score += observationSimilarity * SIMILARITY_WEIGHTS.OBSERVATIONS;
+        factors += SIMILARITY_WEIGHTS.OBSERVATIONS;
+        // Tag overlap (Jaccard similarity) - use pre-computed Sets
+        if (p1.tagSet.size > 0 || p2.tagSet.size > 0) {
+            const tagIntersectionSize = this.setIntersectionSize(p1.tagSet, p2.tagSet);
+            const tagUnionSize = p1.tagSet.size + p2.tagSet.size - tagIntersectionSize;
+            const tagSimilarity = tagUnionSize > 0 ? tagIntersectionSize / tagUnionSize : 0;
+            score += tagSimilarity * SIMILARITY_WEIGHTS.TAGS;
+            factors += SIMILARITY_WEIGHTS.TAGS;
+        }
+        return factors > 0 ? score / factors : 0;
+    }
     /**
      * Find duplicate entities in the graph based on similarity threshold.
      *
@@ -68,15 +153,28 @@ 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) {
+    async findDuplicates(threshold = DEFAULT_DUPLICATE_THRESHOLD, options) {
+        // Check for early cancellation
+        checkCancellation(options?.signal, 'findDuplicates');
         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)
         const typeMap = new Map();
         for (const entity of graph.entities) {
@@ -88,9 +186,14 @@ 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)
+            if (entities.length < 2) {
+                processedCount += entities.length;
+                reportProgress?.(createProgress(processedCount, totalEntities, 'findDuplicates'));
                 continue;
+            }
             // Create name prefix buckets (first 2 chars, normalized)
             const prefixMap = new Map();
             for (const entity of entities) {
@@ -103,6 +206,8 @@ 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
@@ -116,12 +221,16 @@ export class CompressionManager {
                     const entity1 = currentBucket[i];
                     if (processed.has(entity1.name))
                         continue;
+                    // OPTIMIZATION: Use prepared entity for comparison
+                    const prepared1 = preparedEntities.get(entity1.name);
                     const group = [entity1.name];
                     for (let j = 0; j < candidateEntities.length; j++) {
                         const entity2 = candidateEntities[j];
                         if (entity1.name === entity2.name || processed.has(entity2.name))
                             continue;
-                        const similarity = this.calculateEntitySimilarity(entity1, entity2);
+                        // OPTIMIZATION: Use prepared entity and optimized similarity
+                        const prepared2 = preparedEntities.get(entity2.name);
+                        const similarity = this.calculatePreparedSimilarity(prepared1, prepared2);
                         if (similarity >= threshold) {
                             group.push(entity2.name);
                             processed.add(entity2.name);
@@ -131,9 +240,13 @@ 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;
     }
     /**
@@ -150,15 +263,19 @@ export class CompressionManager {
      *
      * @param entityNames - Names of entities to merge (first one is kept)
      * @param targetName - Optional new name for merged entity (default: first entity name)
+     * @param options - Optional configuration
+     * @param options.graph - Pre-loaded graph to use (avoids reload)
+     * @param options.skipSave - If true, don't save (caller will save)
      * @returns The merged entity
      * @throws {InsufficientEntitiesError} If less than 2 entities provided
      * @throws {EntityNotFoundError} If any entity not found
      */
-    async mergeEntities(entityNames, targetName) {
+    async mergeEntities(entityNames, targetName, options = {}) {
         if (entityNames.length < 2) {
             throw new InsufficientEntitiesError('merging', 2, entityNames.length);
         }
-        const graph = await this.storage.loadGraph();
+        // Use provided graph or load fresh
+        const graph = options.graph ?? await this.storage.getGraphForMutation();
         const entitiesToMerge = entityNames.map(name => {
             const entity = graph.entities.find(e => e.name === name);
             if (!entity) {
@@ -232,20 +349,45 @@ export class CompressionManager {
         // Remove merged entities
         const mergeNames = new Set(mergeEntities.map(e => e.name));
         graph.entities = graph.entities.filter(e => !mergeNames.has(e.name));
-        await this.storage.saveGraph(graph);
+        // Save unless caller said to skip
+        if (!options.skipSave) {
+            await this.storage.saveGraph(graph);
+        }
         return keepEntity;
     }
     /**
      * 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) {
-        const initialGraph = await this.storage.loadGraph();
-        const initialSize = JSON.stringify(initialGraph).length;
-        const duplicateGroups = await this.findDuplicates(threshold);
+    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'));
+        // OPTIMIZATION: Load graph once for all operations
+        const graph = await this.storage.getGraphForMutation();
+        const initialSize = JSON.stringify(graph).length;
         const result = {
             duplicatesFound: duplicateGroups.reduce((sum, group) => sum + group.length, 0),
             entitiesMerged: 0,
@@ -263,12 +405,32 @@ export class CompressionManager {
                 });
                 result.entitiesMerged += group.length - 1;
             }
+            reportProgress?.(createProgress(100, 100, 'compressGraph'));
             return result;
         }
-        // Actually merge duplicates
+        // Phase 2: Merge duplicates (50-100% progress)
+        const totalGroups = duplicateGroups.length;
+        let mergedGroups = 0;
+        // Merge all duplicates using the same graph instance
         for (const group of duplicateGroups) {
+            // Check for cancellation between merges
+            checkCancellation(options?.signal, 'compressGraph');
             try {
-                await this.mergeEntities(group);
+                // Count observations before merge using loaded graph
+                let totalObservationsBefore = 0;
+                for (const name of group) {
+                    const entity = graph.entities.find(e => e.name === name);
+                    if (entity) {
+                        totalObservationsBefore += entity.observations.length;
+                    }
+                }
+                // OPTIMIZATION: Pass graph and skip individual saves
+                const mergedEntity = await this.mergeEntities(group, undefined, {
+                    graph,
+                    skipSave: true,
+                });
+                const observationsAfter = mergedEntity.observations.length;
+                result.observationsCompressed += totalObservationsBefore - observationsAfter;
                 result.mergedEntities.push({
                     kept: group[0],
                     merged: group.slice(1),
@@ -279,13 +441,20 @@ 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'));
         }
-        // Calculate space saved
-        const finalGraph = await this.storage.loadGraph();
-        const finalSize = JSON.stringify(finalGraph).length;
+        // 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;
-        // Count compressed observations (approximation)
-        result.observationsCompressed = result.entitiesMerged;
+        result.relationsConsolidated = result.entitiesMerged;
+        // Report completion
+        reportProgress?.(createProgress(100, 100, 'compressGraph'));
         return result;
     }
 }

package/dist/features/IOManager.d.ts

@@ -0,0 +1,225 @@
+/**
+ * IO Manager
+ *
+ * Unified manager for import, export, and backup operations.
+ * Consolidates BackupManager, ExportManager, and ImportManager (Sprint 11.4).
+ *
+ * @module features/IOManager
+ */
+import type { ReadonlyKnowledgeGraph, ImportResult, BackupOptions, BackupResult, RestoreResult, ExportOptions, ExportResult, LongRunningOperationOptions } from '../types/index.js';
+import type { GraphStorage } from '../core/GraphStorage.js';
+/**
+ * Supported export formats.
+ */
+export type ExportFormat = 'json' | 'csv' | 'graphml' | 'gexf' | 'dot' | 'markdown' | 'mermaid';
+/**
+ * Supported import formats.
+ */
+export type ImportFormat = 'json' | 'csv' | 'graphml';
+/**
+ * Merge strategies for handling existing entities during import.
+ */
+export type MergeStrategy = 'replace' | 'skip' | 'merge' | 'fail';
+/**
+ * Metadata stored with each backup.
+ * Extended with compression information for Phase 3 Sprint 2.
+ */
+export interface BackupMetadata {
+    /** Timestamp when backup was created (ISO 8601) */
+    timestamp: string;
+    /** Number of entities in the backup */
+    entityCount: number;
+    /** Number of relations in the backup */
+    relationCount: number;
+    /** File size in bytes (compressed size if compressed) */
+    fileSize: number;
+    /** Optional description/reason for backup */
+    description?: string;
+    /** Whether the backup is compressed (default: true for new backups) */
+    compressed?: boolean;
+    /** Original size before compression in bytes */
+    originalSize?: number;
+    /** Compression ratio achieved (compressedSize / originalSize) */
+    compressionRatio?: number;
+    /** Compression format used */
+    compressionFormat?: 'brotli' | 'none';
+}
+/**
+ * Information about a backup file.
+ * Extended with compression details for Phase 3 Sprint 2.
+ */
+export interface BackupInfo {
+    /** Backup file name */
+    fileName: string;
+    /** Full path to backup file */
+    filePath: string;
+    /** Backup metadata */
+    metadata: BackupMetadata;
+    /** Whether the backup is compressed */
+    compressed: boolean;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Unified manager for import, export, and backup operations.
+ *
+ * Combines functionality from:
+ * - ExportManager: Graph export to various formats
+ * - ImportManager: Graph import from various formats
+ * - BackupManager: Point-in-time backup and restore
+ */
+export declare class IOManager {
+    private storage;
+    private readonly backupDir;
+    constructor(storage: GraphStorage);
+    /**
+     * Export graph to specified format.
+     *
+     * @param graph - Knowledge graph to export
+     * @param format - Export format
+     * @returns Formatted export string
+     */
+    exportGraph(graph: ReadonlyKnowledgeGraph, format: ExportFormat): string;
+    /**
+     * Export graph with optional brotli compression.
+     *
+     * Compression is applied when:
+     * - `options.compress` is explicitly set to `true`
+     * - The exported content exceeds 100KB (auto-compress threshold)
+     *
+     * Compressed content is returned as base64-encoded string.
+     * Uncompressed content is returned as UTF-8 string.
+     *
+     * @param graph - Knowledge graph to export
+     * @param format - Export format
+     * @param options - Export options including compression settings
+     * @returns Export result with content and compression metadata
+     *
+     * @example
+     * ```typescript
+     * // Export with explicit compression
+     * const result = await manager.exportGraphWithCompression(graph, 'json', {
+     *   compress: true,
+     *   compressionQuality: 11
+     * });
+     *
+     * // Export with auto-compression for large graphs
+     * const result = await manager.exportGraphWithCompression(graph, 'json');
+     * // Compresses automatically if content > 100KB
+     * ```
+     */
+    exportGraphWithCompression(graph: ReadonlyKnowledgeGraph, format: ExportFormat, options?: ExportOptions): Promise<ExportResult>;
+    /**
+     * Stream export to a file for large graphs.
+     *
+     * Uses StreamingExporter to write entities and relations incrementally
+     * to avoid loading the entire export content into memory.
+     *
+     * @param format - Export format
+     * @param graph - Knowledge graph to export
+     * @param options - Export options with required outputPath
+     * @returns Export result with streaming metadata
+     * @private
+     */
+    private streamExport;
+    private exportAsJson;
+    private exportAsCsv;
+    private exportAsGraphML;
+    private exportAsGEXF;
+    private exportAsDOT;
+    private exportAsMarkdown;
+    private exportAsMermaid;
+    /**
+     * 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>;
+    private parseJsonImport;
+    private parseCsvImport;
+    private parseGraphMLImport;
+    private mergeImportedGraph;
+    /**
+     * Ensure backup directory exists.
+     */
+    private ensureBackupDir;
+    /**
+     * Generate backup file name with timestamp.
+     * @param compressed - Whether the backup will be compressed (affects extension)
+     */
+    private generateBackupFileName;
+    /**
+     * Create a backup of the current knowledge graph.
+     *
+     * By default, backups are compressed with brotli for 50-70% space reduction.
+     * Use `options.compress = false` to create uncompressed backups.
+     *
+     * @param options - Backup options (compress, description) or legacy description string
+     * @returns Promise resolving to BackupResult with compression statistics
+     *
+     * @example
+     * ```typescript
+     * // Compressed backup (default)
+     * const result = await manager.createBackup({ description: 'Pre-migration backup' });
+     * console.log(`Compressed from ${result.originalSize} to ${result.compressedSize} bytes`);
+     *
+     * // Uncompressed backup
+     * const result = await manager.createBackup({ compress: false });
+     * ```
+     */
+    createBackup(options?: BackupOptions | string): Promise<BackupResult>;
+    /**
+     * List all available backups, sorted by timestamp (newest first).
+     *
+     * Detects both compressed (.jsonl.br) and uncompressed (.jsonl) backups.
+     *
+     * @returns Promise resolving to array of backup information with compression details
+     */
+    listBackups(): Promise<BackupInfo[]>;
+    /**
+     * Restore the knowledge graph from a backup file.
+     *
+     * Automatically detects and decompresses brotli-compressed backups (.br extension).
+     * Maintains backward compatibility with uncompressed backups.
+     *
+     * @param backupPath - Path to the backup file to restore from
+     * @returns Promise resolving to RestoreResult with restoration details
+     *
+     * @example
+     * ```typescript
+     * // Restore from compressed backup
+     * const result = await manager.restoreFromBackup('/path/to/backup.jsonl.br');
+     * console.log(`Restored ${result.entityCount} entities from compressed backup`);
+     *
+     * // Restore from uncompressed backup (legacy)
+     * const result = await manager.restoreFromBackup('/path/to/backup.jsonl');
+     * ```
+     */
+    restoreFromBackup(backupPath: string): Promise<RestoreResult>;
+    /**
+     * Delete a specific backup file.
+     *
+     * @param backupPath - Path to the backup file to delete
+     */
+    deleteBackup(backupPath: string): Promise<void>;
+    /**
+     * Clean old backups, keeping only the most recent N backups.
+     *
+     * @param keepCount - Number of recent backups to keep (default: 10)
+     * @returns Promise resolving to number of backups deleted
+     */
+    cleanOldBackups(keepCount?: number): Promise<number>;
+    /**
+     * Get the path to the backup directory.
+     */
+    getBackupDir(): string;
+}
+//# sourceMappingURL=IOManager.d.ts.map

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

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