@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/features/BackupManager.js

@@ -1,311 +0,0 @@
-/**
- * Backup Manager
- *
- * Manages backup and restore operations for the knowledge graph.
- * Provides point-in-time recovery and data protection.
- *
- * @module features/BackupManager
- */
-import { promises as fs } from 'fs';
-import { dirname, join } from 'path';
-import { FileOperationError } from '../utils/errors.js';
-/**
- * Manages backup and restore operations for the knowledge graph.
- *
- * Backup files are stored in a `.backups` directory next to the main graph file.
- * Each backup includes the graph data and metadata about the backup.
- *
- * @example
- * ```typescript
- * const storage = new GraphStorage('/data/memory.jsonl');
- * const backup = new BackupManager(storage);
- *
- * // Create a backup
- * const backupPath = await backup.createBackup('Before compression');
- *
- * // List available backups
- * const backups = await backup.listBackups();
- *
- * // Restore from backup
- * await backup.restoreFromBackup(backupPath);
- *
- * // Clean old backups (keep last 10)
- * await backup.cleanOldBackups(10);
- * ```
- */
-export class BackupManager {
-    storage;
-    backupDir;
-    constructor(storage) {
-        this.storage = storage;
-        const filePath = this.storage.getFilePath();
-        const dir = dirname(filePath);
-        this.backupDir = join(dir, '.backups');
-    }
-    /**
-     * Ensure backup directory exists.
-     *
-     * @private
-     */
-    async ensureBackupDir() {
-        try {
-            await fs.mkdir(this.backupDir, { recursive: true });
-        }
-        catch (error) {
-            throw new FileOperationError('create backup directory', this.backupDir, error);
-        }
-    }
-    /**
-     * Generate backup file name with timestamp.
-     *
-     * Format: backup_YYYY-MM-DD_HH-MM-SS-mmm.jsonl
-     *
-     * @private
-     */
-    generateBackupFileName() {
-        const now = new Date();
-        const timestamp = now.toISOString()
-            .replace(/:/g, '-')
-            .replace(/\./g, '-')
-            .replace('T', '_')
-            .replace('Z', '');
-        return `backup_${timestamp}.jsonl`;
-    }
-    /**
-     * Create a backup of the current knowledge graph.
-     *
-     * Backup includes:
-     * - Complete graph data (entities and relations)
-     * - Metadata (timestamp, counts, file size, description)
-     *
-     * @param description - Optional description for this backup
-     * @returns Promise resolving to the backup file path
-     * @throws {FileOperationError} If backup creation fails
-     *
-     * @example
-     * ```typescript
-     * // Create backup with description
-     * const backupPath = await manager.createBackup('Before merging duplicates');
-     *
-     * // Create backup without description
-     * const backupPath = await manager.createBackup();
-     * ```
-     */
-    async createBackup(description) {
-        await this.ensureBackupDir();
-        // Load current graph
-        const graph = await this.storage.loadGraph();
-        const fileName = this.generateBackupFileName();
-        const backupPath = join(this.backupDir, fileName);
-        try {
-            // Read the current file content to preserve exact formatting
-            const originalPath = this.storage.getFilePath();
-            let fileContent;
-            try {
-                fileContent = await fs.readFile(originalPath, 'utf-8');
-            }
-            catch (error) {
-                // File doesn't exist yet - generate content from graph
-                const lines = [
-                    ...graph.entities.map(e => JSON.stringify({ type: 'entity', ...e })),
-                    ...graph.relations.map(r => JSON.stringify({ type: 'relation', ...r })),
-                ];
-                fileContent = lines.join('\n');
-            }
-            // Write backup file
-            await fs.writeFile(backupPath, fileContent);
-            // Get file stats
-            const stats = await fs.stat(backupPath);
-            // Create metadata
-            const metadata = {
-                timestamp: new Date().toISOString(),
-                entityCount: graph.entities.length,
-                relationCount: graph.relations.length,
-                fileSize: stats.size,
-                description,
-            };
-            // Write metadata file
-            const metadataPath = `${backupPath}.meta.json`;
-            await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-            return backupPath;
-        }
-        catch (error) {
-            throw new FileOperationError('create backup', backupPath, error);
-        }
-    }
-    /**
-     * List all available backups, sorted by timestamp (newest first).
-     *
-     * @returns Promise resolving to array of backup information
-     * @throws {FileOperationError} If listing fails
-     *
-     * @example
-     * ```typescript
-     * const backups = await manager.listBackups();
-     * console.log(`Found ${backups.length} backups`);
-     *
-     * for (const backup of backups) {
-     *   console.log(`${backup.fileName}: ${backup.metadata.entityCount} entities`);
-     * }
-     * ```
-     */
-    async listBackups() {
-        try {
-            // Check if backup directory exists
-            try {
-                await fs.access(this.backupDir);
-            }
-            catch {
-                // Directory doesn't exist - no backups
-                return [];
-            }
-            const files = await fs.readdir(this.backupDir);
-            const backupFiles = files.filter(f => f.startsWith('backup_') && f.endsWith('.jsonl'));
-            const backups = [];
-            for (const fileName of backupFiles) {
-                const filePath = join(this.backupDir, fileName);
-                const metadataPath = `${filePath}.meta.json`;
-                try {
-                    // Read metadata if it exists
-                    const metadataContent = await fs.readFile(metadataPath, 'utf-8');
-                    const metadata = JSON.parse(metadataContent);
-                    backups.push({
-                        fileName,
-                        filePath,
-                        metadata,
-                    });
-                }
-                catch {
-                    // Metadata file doesn't exist or is corrupt - skip this backup
-                    continue;
-                }
-            }
-            // Sort by timestamp (newest first)
-            backups.sort((a, b) => new Date(b.metadata.timestamp).getTime() - new Date(a.metadata.timestamp).getTime());
-            return backups;
-        }
-        catch (error) {
-            throw new FileOperationError('list backups', this.backupDir, error);
-        }
-    }
-    /**
-     * Restore the knowledge graph from a backup file.
-     *
-     * CAUTION: This operation overwrites the current graph with backup data.
-     * Consider creating a backup before restoring.
-     *
-     * @param backupPath - Path to the backup file to restore from
-     * @returns Promise that resolves when restore is complete
-     * @throws {FileOperationError} If restore fails
-     *
-     * @example
-     * ```typescript
-     * // List backups and restore the most recent
-     * const backups = await manager.listBackups();
-     * if (backups.length > 0) {
-     *   await manager.restoreFromBackup(backups[0].filePath);
-     * }
-     *
-     * // Restore specific backup by path
-     * await manager.restoreFromBackup('/data/.backups/backup_2024-01-15_10-30-00.jsonl');
-     * ```
-     */
-    async restoreFromBackup(backupPath) {
-        try {
-            // Verify backup file exists
-            await fs.access(backupPath);
-            // Read backup content
-            const backupContent = await fs.readFile(backupPath, 'utf-8');
-            // Write to main graph file
-            const mainPath = this.storage.getFilePath();
-            await fs.writeFile(mainPath, backupContent);
-            // Clear storage cache to force reload
-            this.storage.clearCache();
-        }
-        catch (error) {
-            throw new FileOperationError('restore from backup', backupPath, error);
-        }
-    }
-    /**
-     * Delete a specific backup file.
-     *
-     * Also deletes the associated metadata file.
-     *
-     * @param backupPath - Path to the backup file to delete
-     * @returns Promise that resolves when deletion is complete
-     * @throws {FileOperationError} If deletion fails
-     *
-     * @example
-     * ```typescript
-     * const backups = await manager.listBackups();
-     * // Delete oldest backup
-     * if (backups.length > 0) {
-     *   await manager.deleteBackup(backups[backups.length - 1].filePath);
-     * }
-     * ```
-     */
-    async deleteBackup(backupPath) {
-        try {
-            // Delete backup file
-            await fs.unlink(backupPath);
-            // Delete metadata file (ignore errors if it doesn't exist)
-            try {
-                await fs.unlink(`${backupPath}.meta.json`);
-            }
-            catch {
-                // Metadata file doesn't exist - that's ok
-            }
-        }
-        catch (error) {
-            throw new FileOperationError('delete backup', backupPath, error);
-        }
-    }
-    /**
-     * Clean old backups, keeping only the most recent N backups.
-     *
-     * Backups are sorted by timestamp, and older backups are deleted.
-     *
-     * @param keepCount - Number of recent backups to keep (default: 10)
-     * @returns Promise resolving to number of backups deleted
-     * @throws {FileOperationError} If cleanup fails
-     *
-     * @example
-     * ```typescript
-     * // Keep only the 5 most recent backups
-     * const deleted = await manager.cleanOldBackups(5);
-     * console.log(`Deleted ${deleted} old backups`);
-     *
-     * // Keep default 10 most recent backups
-     * await manager.cleanOldBackups();
-     * ```
-     */
-    async cleanOldBackups(keepCount = 10) {
-        const backups = await this.listBackups();
-        // If we have fewer backups than keepCount, nothing to delete
-        if (backups.length <= keepCount) {
-            return 0;
-        }
-        // Delete backups beyond keepCount
-        const backupsToDelete = backups.slice(keepCount);
-        let deletedCount = 0;
-        for (const backup of backupsToDelete) {
-            try {
-                await this.deleteBackup(backup.filePath);
-                deletedCount++;
-            }
-            catch {
-                // Continue deleting other backups even if one fails
-                continue;
-            }
-        }
-        return deletedCount;
-    }
-    /**
-     * Get the path to the backup directory.
-     *
-     * @returns The backup directory path
-     */
-    getBackupDir() {
-        return this.backupDir;
-    }
-}

package/dist/features/ExportManager.js

@@ -1,305 +0,0 @@
-/**
- * Export Manager
- *
- * Exports knowledge graphs to various formats (JSON, CSV, GraphML, GEXF, DOT, Markdown, Mermaid).
- *
- * @module features/ExportManager
- */
-/**
- * Manages knowledge graph exports to multiple formats.
- */
-export class ExportManager {
-    /**
-     * Export graph to specified format.
-     *
-     * @param graph - Knowledge graph to export
-     * @param format - Export format
-     * @returns Formatted export string
-     */
-    exportGraph(graph, format) {
-        switch (format) {
-            case 'json':
-                return this.exportAsJson(graph);
-            case 'csv':
-                return this.exportAsCsv(graph);
-            case 'graphml':
-                return this.exportAsGraphML(graph);
-            case 'gexf':
-                return this.exportAsGEXF(graph);
-            case 'dot':
-                return this.exportAsDOT(graph);
-            case 'markdown':
-                return this.exportAsMarkdown(graph);
-            case 'mermaid':
-                return this.exportAsMermaid(graph);
-            default:
-                throw new Error(`Unsupported export format: ${format}`);
-        }
-    }
-    /**
-     * Export as pretty-printed JSON.
-     */
-    exportAsJson(graph) {
-        return JSON.stringify(graph, null, 2);
-    }
-    /**
-     * Export as CSV with proper escaping.
-     */
-    exportAsCsv(graph) {
-        const lines = [];
-        const escapeCsvField = (field) => {
-            if (field === undefined || field === null)
-                return '';
-            const str = String(field);
-            if (str.includes(',') || str.includes('"') || str.includes('\n')) {
-                return `"${str.replace(/"/g, '""')}"`;
-            }
-            return str;
-        };
-        // Entities section
-        lines.push('# ENTITIES');
-        lines.push('name,entityType,observations,createdAt,lastModified,tags,importance');
-        for (const entity of graph.entities) {
-            const observationsStr = entity.observations.join('; ');
-            const tagsStr = entity.tags ? entity.tags.join('; ') : '';
-            const importanceStr = entity.importance !== undefined ? String(entity.importance) : '';
-            lines.push([
-                escapeCsvField(entity.name),
-                escapeCsvField(entity.entityType),
-                escapeCsvField(observationsStr),
-                escapeCsvField(entity.createdAt),
-                escapeCsvField(entity.lastModified),
-                escapeCsvField(tagsStr),
-                escapeCsvField(importanceStr),
-            ].join(','));
-        }
-        // Relations section
-        lines.push('');
-        lines.push('# RELATIONS');
-        lines.push('from,to,relationType,createdAt,lastModified');
-        for (const relation of graph.relations) {
-            lines.push([
-                escapeCsvField(relation.from),
-                escapeCsvField(relation.to),
-                escapeCsvField(relation.relationType),
-                escapeCsvField(relation.createdAt),
-                escapeCsvField(relation.lastModified),
-            ].join(','));
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Export as GraphML XML format.
-     */
-    exportAsGraphML(graph) {
-        const lines = [];
-        const escapeXml = (str) => {
-            if (str === undefined || str === null)
-                return '';
-            return String(str)
-                .replace(/&/g, '&')
-                .replace(/</g, '&lt;')
-                .replace(/>/g, '&gt;')
-                .replace(/"/g, '&quot;')
-                .replace(/'/g, '&apos;');
-        };
-        lines.push('<?xml version="1.0" encoding="UTF-8"?>');
-        lines.push('<graphml xmlns="http://graphml.graphdrawing.org/xmlns">');
-        lines.push('  <key id="d0" for="node" attr.name="entityType" attr.type="string"/>');
-        lines.push('  <key id="d1" for="node" attr.name="observations" attr.type="string"/>');
-        lines.push('  <key id="d2" for="node" attr.name="createdAt" attr.type="string"/>');
-        lines.push('  <key id="d3" for="node" attr.name="lastModified" attr.type="string"/>');
-        lines.push('  <key id="d4" for="node" attr.name="tags" attr.type="string"/>');
-        lines.push('  <key id="d5" for="node" attr.name="importance" attr.type="double"/>');
-        lines.push('  <key id="e0" for="edge" attr.name="relationType" attr.type="string"/>');
-        lines.push('  <key id="e1" for="edge" attr.name="createdAt" attr.type="string"/>');
-        lines.push('  <key id="e2" for="edge" attr.name="lastModified" attr.type="string"/>');
-        lines.push('  <graph id="G" edgedefault="directed">');
-        // Nodes
-        for (const entity of graph.entities) {
-            const nodeId = escapeXml(entity.name);
-            lines.push(`    <node id="${nodeId}">`);
-            lines.push(`      <data key="d0">${escapeXml(entity.entityType)}</data>`);
-            lines.push(`      <data key="d1">${escapeXml(entity.observations.join('; '))}</data>`);
-            if (entity.createdAt)
-                lines.push(`      <data key="d2">${escapeXml(entity.createdAt)}</data>`);
-            if (entity.lastModified)
-                lines.push(`      <data key="d3">${escapeXml(entity.lastModified)}</data>`);
-            if (entity.tags?.length)
-                lines.push(`      <data key="d4">${escapeXml(entity.tags.join('; '))}</data>`);
-            if (entity.importance !== undefined)
-                lines.push(`      <data key="d5">${entity.importance}</data>`);
-            lines.push('    </node>');
-        }
-        // Edges
-        let edgeId = 0;
-        for (const relation of graph.relations) {
-            const sourceId = escapeXml(relation.from);
-            const targetId = escapeXml(relation.to);
-            lines.push(`    <edge id="e${edgeId}" source="${sourceId}" target="${targetId}">`);
-            lines.push(`      <data key="e0">${escapeXml(relation.relationType)}</data>`);
-            if (relation.createdAt)
-                lines.push(`      <data key="e1">${escapeXml(relation.createdAt)}</data>`);
-            if (relation.lastModified)
-                lines.push(`      <data key="e2">${escapeXml(relation.lastModified)}</data>`);
-            lines.push('    </edge>');
-            edgeId++;
-        }
-        lines.push('  </graph>');
-        lines.push('</graphml>');
-        return lines.join('\n');
-    }
-    /**
-     * Export as GEXF format for Gephi.
-     */
-    exportAsGEXF(graph) {
-        const lines = [];
-        const escapeXml = (str) => {
-            if (str === undefined || str === null)
-                return '';
-            return String(str)
-                .replace(/&/g, '&amp;')
-                .replace(/</g, '&lt;')
-                .replace(/>/g, '&gt;')
-                .replace(/"/g, '&quot;')
-                .replace(/'/g, '&apos;');
-        };
-        lines.push('<?xml version="1.0" encoding="UTF-8"?>');
-        lines.push('<gexf xmlns="http://www.gexf.net/1.2draft" version="1.2">');
-        lines.push('  <meta>');
-        lines.push('    <creator>Memory MCP Server</creator>');
-        lines.push('  </meta>');
-        lines.push('  <graph mode="static" defaultedgetype="directed">');
-        lines.push('    <attributes class="node">');
-        lines.push('      <attribute id="0" title="entityType" type="string"/>');
-        lines.push('      <attribute id="1" title="observations" type="string"/>');
-        lines.push('    </attributes>');
-        lines.push('    <nodes>');
-        for (const entity of graph.entities) {
-            const nodeId = escapeXml(entity.name);
-            lines.push(`      <node id="${nodeId}" label="${nodeId}">`);
-            lines.push('        <attvalues>');
-            lines.push(`          <attvalue for="0" value="${escapeXml(entity.entityType)}"/>`);
-            lines.push(`          <attvalue for="1" value="${escapeXml(entity.observations.join('; '))}"/>`);
-            lines.push('        </attvalues>');
-            lines.push('      </node>');
-        }
-        lines.push('    </nodes>');
-        lines.push('    <edges>');
-        let edgeId = 0;
-        for (const relation of graph.relations) {
-            const sourceId = escapeXml(relation.from);
-            const targetId = escapeXml(relation.to);
-            const label = escapeXml(relation.relationType);
-            lines.push(`      <edge id="${edgeId}" source="${sourceId}" target="${targetId}" label="${label}"/>`);
-            edgeId++;
-        }
-        lines.push('    </edges>');
-        lines.push('  </graph>');
-        lines.push('</gexf>');
-        return lines.join('\n');
-    }
-    /**
-     * Export as DOT format for GraphViz.
-     */
-    exportAsDOT(graph) {
-        const lines = [];
-        const escapeDot = (str) => {
-            return '"' + str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n') + '"';
-        };
-        lines.push('digraph KnowledgeGraph {');
-        lines.push('  rankdir=LR;');
-        lines.push('  node [shape=box, style=rounded];');
-        lines.push('');
-        for (const entity of graph.entities) {
-            const nodeId = escapeDot(entity.name);
-            const label = [`${entity.name}`, `Type: ${entity.entityType}`];
-            if (entity.tags?.length)
-                label.push(`Tags: ${entity.tags.join(', ')}`);
-            const labelStr = escapeDot(label.join('\\n'));
-            lines.push(`  ${nodeId} [label=${labelStr}];`);
-        }
-        lines.push('');
-        for (const relation of graph.relations) {
-            const fromId = escapeDot(relation.from);
-            const toId = escapeDot(relation.to);
-            const label = escapeDot(relation.relationType);
-            lines.push(`  ${fromId} -> ${toId} [label=${label}];`);
-        }
-        lines.push('}');
-        return lines.join('\n');
-    }
-    /**
-     * Export as Markdown documentation.
-     */
-    exportAsMarkdown(graph) {
-        const lines = [];
-        lines.push('# Knowledge Graph Export');
-        lines.push('');
-        lines.push(`**Exported:** ${new Date().toISOString()}`);
-        lines.push(`**Entities:** ${graph.entities.length}`);
-        lines.push(`**Relations:** ${graph.relations.length}`);
-        lines.push('');
-        lines.push('## Entities');
-        lines.push('');
-        for (const entity of graph.entities) {
-            lines.push(`### ${entity.name}`);
-            lines.push('');
-            lines.push(`- **Type:** ${entity.entityType}`);
-            if (entity.tags?.length)
-                lines.push(`- **Tags:** ${entity.tags.map(t => `\`${t}\``).join(', ')}`);
-            if (entity.importance !== undefined)
-                lines.push(`- **Importance:** ${entity.importance}/10`);
-            if (entity.observations.length > 0) {
-                lines.push('');
-                lines.push('**Observations:**');
-                for (const obs of entity.observations) {
-                    lines.push(`- ${obs}`);
-                }
-            }
-            lines.push('');
-        }
-        if (graph.relations.length > 0) {
-            lines.push('## Relations');
-            lines.push('');
-            for (const relation of graph.relations) {
-                lines.push(`- **${relation.from}** → *${relation.relationType}* → **${relation.to}**`);
-            }
-            lines.push('');
-        }
-        return lines.join('\n');
-    }
-    /**
-     * Export as Mermaid diagram.
-     */
-    exportAsMermaid(graph) {
-        const lines = [];
-        const sanitizeId = (str) => str.replace(/[^a-zA-Z0-9_]/g, '_');
-        const escapeLabel = (str) => str.replace(/"/g, '#quot;');
-        lines.push('graph LR');
-        lines.push('  %% Knowledge Graph');
-        lines.push('');
-        const nodeIds = new Map();
-        for (const entity of graph.entities) {
-            nodeIds.set(entity.name, sanitizeId(entity.name));
-        }
-        for (const entity of graph.entities) {
-            const nodeId = nodeIds.get(entity.name);
-            const labelParts = [entity.name, `Type: ${entity.entityType}`];
-            if (entity.tags?.length)
-                labelParts.push(`Tags: ${entity.tags.join(', ')}`);
-            const label = escapeLabel(labelParts.join('<br/>'));
-            lines.push(`  ${nodeId}["${label}"]`);
-        }
-        lines.push('');
-        for (const relation of graph.relations) {
-            const fromId = nodeIds.get(relation.from);
-            const toId = nodeIds.get(relation.to);
-            if (fromId && toId) {
-                const label = escapeLabel(relation.relationType);
-                lines.push(`  ${fromId} -->|"${label}"| ${toId}`);
-            }
-        }
-        return lines.join('\n');
-    }
-}

package/dist/features/ImportExportManager.js

@@ -1,50 +0,0 @@
-/**
- * Import/Export Manager
- *
- * Orchestrates import and export operations with optional filtering.
- *
- * @module features/ImportExportManager
- */
-/**
- * Orchestrates import and export operations.
- */
-export class ImportExportManager {
-    basicSearch;
-    exportManager;
-    importManager;
-    constructor(exportManager, importManager, basicSearch) {
-        this.basicSearch = basicSearch;
-        this.exportManager = exportManager;
-        this.importManager = importManager;
-    }
-    /**
-     * Export graph to specified format with optional filtering.
-     *
-     * @param format - Export format
-     * @param filter - Optional export filter
-     * @returns Formatted export string
-     */
-    async exportGraph(format, filter) {
-        let graph;
-        if (filter) {
-            graph = await this.basicSearch.searchByDateRange(filter.startDate, filter.endDate, filter.entityType, filter.tags);
-        }
-        else {
-            // Get full graph via basicSearch's storage
-            graph = await this.basicSearch.storage.loadGraph();
-        }
-        return this.exportManager.exportGraph(graph, format);
-    }
-    /**
-     * Import graph from formatted data.
-     *
-     * @param format - Import format
-     * @param data - Import data string
-     * @param mergeStrategy - How to handle conflicts
-     * @param dryRun - If true, preview changes without applying
-     * @returns Import result with statistics
-     */
-    async importGraph(format, data, mergeStrategy, dryRun) {
-        return this.importManager.importGraph(format, data, mergeStrategy, dryRun);
-    }
-}