@danielsimonjr/memoryjs 1.0.0 → 1.1.0

package/dist/features/IOManager.js

@@ -1,1093 +0,0 @@
-/**
- * IO Manager
- *
- * Unified manager for import, export, and backup operations.
- * Consolidates BackupManager, ExportManager, and ImportManager (Sprint 11.4).
- *
- * @module features/IOManager
- */
-import { promises as fs } from 'fs';
-import { dirname, join } from 'path';
-import { FileOperationError } from '../utils/errors.js';
-import { compress, decompress, hasBrotliExtension, COMPRESSION_CONFIG, STREAMING_CONFIG, checkCancellation, createProgressReporter, createProgress, validateFilePath, sanitizeObject, escapeCsvFormula, } from '../utils/index.js';
-import { StreamingExporter } from './StreamingExporter.js';
-// ============================================================
-// IO MANAGER CLASS
-// ============================================================
-/**
- * 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 class IOManager {
-    storage;
-    backupDir;
-    constructor(storage) {
-        this.storage = storage;
-        const filePath = this.storage.getFilePath();
-        const dir = dirname(filePath);
-        this.backupDir = join(dir, '.backups');
-    }
-    // ============================================================
-    // EXPORT OPERATIONS
-    // ============================================================
-    /**
-     * 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 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
-     * ```
-     */
-    async exportGraphWithCompression(graph, format, options) {
-        // Check if streaming should be used
-        const shouldStream = options?.streaming ||
-            (options?.outputPath && graph.entities.length >= STREAMING_CONFIG.STREAMING_THRESHOLD);
-        if (shouldStream && options?.outputPath) {
-            return this.streamExport(format, graph, options);
-        }
-        // Generate export content using existing method
-        const content = this.exportGraph(graph, format);
-        const originalSize = Buffer.byteLength(content, 'utf-8');
-        // Determine if compression should be applied
-        const shouldCompress = options?.compress === true ||
-            (options?.compress !== false &&
-                originalSize > COMPRESSION_CONFIG.AUTO_COMPRESS_EXPORT_SIZE);
-        if (shouldCompress) {
-            const quality = options?.compressionQuality ?? COMPRESSION_CONFIG.BROTLI_QUALITY_BATCH;
-            const compressionResult = await compress(content, {
-                quality,
-                mode: 'text',
-            });
-            return {
-                format,
-                content: compressionResult.compressed.toString('base64'),
-                entityCount: graph.entities.length,
-                relationCount: graph.relations.length,
-                compressed: true,
-                encoding: 'base64',
-                originalSize,
-                compressedSize: compressionResult.compressedSize,
-                compressionRatio: compressionResult.ratio,
-            };
-        }
-        // Return uncompressed content
-        return {
-            format,
-            content,
-            entityCount: graph.entities.length,
-            relationCount: graph.relations.length,
-            compressed: false,
-            encoding: 'utf-8',
-            originalSize,
-            compressedSize: originalSize,
-            compressionRatio: 1,
-        };
-    }
-    /**
-     * 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
-     */
-    async streamExport(format, graph, options) {
-        // Validate path to prevent path traversal attacks (defense in depth)
-        const validatedOutputPath = validateFilePath(options.outputPath);
-        const exporter = new StreamingExporter(validatedOutputPath);
-        let result;
-        switch (format) {
-            case 'json':
-                // Use JSONL format for streaming (line-delimited JSON)
-                result = await exporter.streamJSONL(graph);
-                break;
-            case 'csv':
-                result = await exporter.streamCSV(graph);
-                break;
-            default:
-                // Fallback to in-memory export for unsupported streaming formats
-                const content = this.exportGraph(graph, format);
-                await fs.writeFile(validatedOutputPath, content);
-                result = {
-                    bytesWritten: Buffer.byteLength(content, 'utf-8'),
-                    entitiesWritten: graph.entities.length,
-                    relationsWritten: graph.relations.length,
-                    durationMs: 0,
-                };
-        }
-        return {
-            format,
-            content: `Streamed to ${validatedOutputPath}`,
-            entityCount: result.entitiesWritten,
-            relationCount: result.relationsWritten,
-            compressed: false,
-            encoding: 'utf-8',
-            originalSize: result.bytesWritten,
-            compressedSize: result.bytesWritten,
-            compressionRatio: 1,
-            streamed: true,
-            outputPath: validatedOutputPath,
-        };
-    }
-    exportAsJson(graph) {
-        return JSON.stringify(graph, null, 2);
-    }
-    exportAsCsv(graph) {
-        const lines = [];
-        const escapeCsvField = (field) => {
-            if (field === undefined || field === null)
-                return '';
-            // First protect against CSV formula injection
-            let str = escapeCsvFormula(String(field));
-            // Then handle CSV special characters
-            if (str.includes(',') || str.includes('"') || str.includes('\n')) {
-                return `"${str.replace(/"/g, '""')}"`;
-            }
-            return str;
-        };
-        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(','));
-        }
-        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');
-    }
-    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">');
-        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>');
-        }
-        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');
-    }
-    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');
-    }
-    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');
-    }
-    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');
-    }
-    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');
-    }
-    // ============================================================
-    // IMPORT OPERATIONS
-    // ============================================================
-    /**
-     * 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)
-     */
-    async importGraph(format, data, mergeStrategy = 'skip', dryRun = false, options) {
-        // Check for early cancellation
-        checkCancellation(options?.signal, 'importGraph');
-        // Setup progress reporter
-        const reportProgress = createProgressReporter(options?.onProgress);
-        reportProgress?.(createProgress(0, 100, 'importGraph'));
-        let importedGraph;
-        try {
-            // Parsing phase (0-20% progress)
-            reportProgress?.(createProgress(5, 100, 'parsing data'));
-            checkCancellation(options?.signal, 'importGraph');
-            switch (format) {
-                case 'json':
-                    importedGraph = this.parseJsonImport(data);
-                    break;
-                case 'csv':
-                    importedGraph = this.parseCsvImport(data);
-                    break;
-                case 'graphml':
-                    importedGraph = this.parseGraphMLImport(data);
-                    break;
-                default:
-                    throw new Error(`Unsupported import format: ${format}`);
-            }
-            reportProgress?.(createProgress(20, 100, 'parsing complete'));
-        }
-        catch (error) {
-            return {
-                entitiesAdded: 0,
-                entitiesSkipped: 0,
-                entitiesUpdated: 0,
-                relationsAdded: 0,
-                relationsSkipped: 0,
-                errors: [`Failed to parse ${format} data: ${error instanceof Error ? error.message : String(error)}`],
-            };
-        }
-        // Merging phase (20-100% progress)
-        return await this.mergeImportedGraph(importedGraph, mergeStrategy, dryRun, options);
-    }
-    parseJsonImport(data) {
-        // Security: Limit input size to prevent DoS (10MB max)
-        const MAX_IMPORT_SIZE = 10 * 1024 * 1024;
-        if (data.length > MAX_IMPORT_SIZE) {
-            throw new FileOperationError(`JSON import data exceeds maximum size of ${MAX_IMPORT_SIZE / (1024 * 1024)}MB`, 'json-import');
-        }
-        const parsed = JSON.parse(data);
-        if (!parsed.entities || !Array.isArray(parsed.entities)) {
-            throw new Error('Invalid JSON: missing or invalid entities array');
-        }
-        if (!parsed.relations || !Array.isArray(parsed.relations)) {
-            throw new Error('Invalid JSON: missing or invalid relations array');
-        }
-        // Security: Limit maximum number of entities/relations
-        const MAX_ITEMS = 100000;
-        if (parsed.entities.length > MAX_ITEMS) {
-            throw new FileOperationError(`JSON import exceeds maximum entity count of ${MAX_ITEMS}`, 'json-import');
-        }
-        if (parsed.relations.length > MAX_ITEMS) {
-            throw new FileOperationError(`JSON import exceeds maximum relation count of ${MAX_ITEMS}`, 'json-import');
-        }
-        return {
-            entities: parsed.entities,
-            relations: parsed.relations,
-        };
-    }
-    parseCsvImport(data) {
-        // Security: Limit input size to prevent DoS (10MB max)
-        const MAX_IMPORT_SIZE = 10 * 1024 * 1024;
-        if (data.length > MAX_IMPORT_SIZE) {
-            throw new FileOperationError(`CSV import data exceeds maximum size of ${MAX_IMPORT_SIZE / (1024 * 1024)}MB`, 'csv-import');
-        }
-        // Security: Limit maximum number of entities/relations
-        const MAX_ITEMS = 100000;
-        const lines = data
-            .split('\n')
-            .map(line => line.trim())
-            .filter(line => line);
-        const entities = [];
-        const relations = [];
-        let section = null;
-        let headerParsed = false;
-        const parseCsvLine = (line) => {
-            const fields = [];
-            let current = '';
-            let inQuotes = false;
-            for (let i = 0; i < line.length; i++) {
-                const char = line[i];
-                if (char === '"') {
-                    if (inQuotes && line[i + 1] === '"') {
-                        current += '"';
-                        i++;
-                    }
-                    else {
-                        inQuotes = !inQuotes;
-                    }
-                }
-                else if (char === ',' && !inQuotes) {
-                    fields.push(current);
-                    current = '';
-                }
-                else {
-                    current += char;
-                }
-            }
-            fields.push(current);
-            return fields;
-        };
-        for (const line of lines) {
-            if (line.startsWith('# ENTITIES')) {
-                section = 'entities';
-                headerParsed = false;
-                continue;
-            }
-            else if (line.startsWith('# RELATIONS')) {
-                section = 'relations';
-                headerParsed = false;
-                continue;
-            }
-            if (line.startsWith('#'))
-                continue;
-            if (section === 'entities') {
-                if (!headerParsed) {
-                    headerParsed = true;
-                    continue;
-                }
-                const fields = parseCsvLine(line);
-                if (fields.length >= 2) {
-                    // Security: Check entity limit
-                    if (entities.length >= MAX_ITEMS) {
-                        throw new FileOperationError(`CSV import exceeds maximum entity count of ${MAX_ITEMS}`, 'csv-import');
-                    }
-                    const entity = {
-                        name: fields[0],
-                        entityType: fields[1],
-                        observations: fields[2]
-                            ? fields[2]
-                                .split(';')
-                                .map(s => s.trim())
-                                .filter(s => s)
-                            : [],
-                        createdAt: fields[3] || undefined,
-                        lastModified: fields[4] || undefined,
-                        tags: fields[5]
-                            ? fields[5]
-                                .split(';')
-                                .map(s => s.trim().toLowerCase())
-                                .filter(s => s)
-                            : undefined,
-                        importance: fields[6] ? parseFloat(fields[6]) : undefined,
-                    };
-                    entities.push(entity);
-                }
-            }
-            else if (section === 'relations') {
-                if (!headerParsed) {
-                    headerParsed = true;
-                    continue;
-                }
-                const fields = parseCsvLine(line);
-                if (fields.length >= 3) {
-                    // Security: Check relation limit
-                    if (relations.length >= MAX_ITEMS) {
-                        throw new FileOperationError(`CSV import exceeds maximum relation count of ${MAX_ITEMS}`, 'csv-import');
-                    }
-                    const relation = {
-                        from: fields[0],
-                        to: fields[1],
-                        relationType: fields[2],
-                        createdAt: fields[3] || undefined,
-                        lastModified: fields[4] || undefined,
-                    };
-                    relations.push(relation);
-                }
-            }
-        }
-        return { entities, relations };
-    }
-    parseGraphMLImport(data) {
-        const entities = [];
-        const relations = [];
-        // Security: Limit input size to prevent ReDoS attacks (10MB max)
-        const MAX_IMPORT_SIZE = 10 * 1024 * 1024;
-        if (data.length > MAX_IMPORT_SIZE) {
-            throw new FileOperationError(`GraphML import data exceeds maximum size of ${MAX_IMPORT_SIZE / (1024 * 1024)}MB`, 'graphml-import');
-        }
-        // Security: Limit maximum number of entities/relations to prevent infinite loops
-        const MAX_ITEMS = 100000;
-        let nodeCount = 0;
-        let relationCount = 0;
-        // Use non-greedy patterns with character class restrictions
-        const nodeRegex = /<node\s+id="([^"]+)"[^>]*>([\s\S]*?)<\/node>/g;
-        let nodeMatch;
-        while ((nodeMatch = nodeRegex.exec(data)) !== null) {
-            // Security: Limit iterations to prevent ReDoS
-            if (++nodeCount > MAX_ITEMS) {
-                throw new FileOperationError(`GraphML import exceeds maximum entity count of ${MAX_ITEMS}`, 'graphml-import');
-            }
-            const nodeId = nodeMatch[1];
-            const nodeContent = nodeMatch[2];
-            const getDataValue = (key) => {
-                const dataRegex = new RegExp(`<data\\s+key="${key}">([^<]*)<\/data>`);
-                const match = dataRegex.exec(nodeContent);
-                return match ? match[1] : undefined;
-            };
-            const entity = {
-                name: nodeId,
-                entityType: getDataValue('d0') || getDataValue('entityType') || 'unknown',
-                observations: (getDataValue('d1') || getDataValue('observations') || '')
-                    .split(';')
-                    .map(s => s.trim())
-                    .filter(s => s),
-                createdAt: getDataValue('d2') || getDataValue('createdAt'),
-                lastModified: getDataValue('d3') || getDataValue('lastModified'),
-                tags: (getDataValue('d4') || getDataValue('tags') || '')
-                    .split(';')
-                    .map(s => s.trim().toLowerCase())
-                    .filter(s => s),
-                importance: getDataValue('d5') || getDataValue('importance') ? parseFloat(getDataValue('d5') || getDataValue('importance') || '0') : undefined,
-            };
-            entities.push(entity);
-        }
-        const edgeRegex = /<edge\s+[^>]*source="([^"]+)"\s+target="([^"]+)"[^>]*>([\s\S]*?)<\/edge>/g;
-        let edgeMatch;
-        while ((edgeMatch = edgeRegex.exec(data)) !== null) {
-            // Security: Limit iterations to prevent ReDoS
-            if (++relationCount > MAX_ITEMS) {
-                throw new FileOperationError(`GraphML import exceeds maximum relation count of ${MAX_ITEMS}`, 'graphml-import');
-            }
-            const source = edgeMatch[1];
-            const target = edgeMatch[2];
-            const edgeContent = edgeMatch[3];
-            const getDataValue = (key) => {
-                const dataRegex = new RegExp(`<data\\s+key="${key}">([^<]*)<\/data>`);
-                const match = dataRegex.exec(edgeContent);
-                return match ? match[1] : undefined;
-            };
-            const relation = {
-                from: source,
-                to: target,
-                relationType: getDataValue('e0') || getDataValue('relationType') || 'related_to',
-                createdAt: getDataValue('e1') || getDataValue('createdAt'),
-                lastModified: getDataValue('e2') || getDataValue('lastModified'),
-            };
-            relations.push(relation);
-        }
-        return { entities, relations };
-    }
-    async mergeImportedGraph(importedGraph, mergeStrategy, dryRun, options) {
-        // Check for cancellation
-        checkCancellation(options?.signal, 'importGraph');
-        // Setup progress reporter (we're at 20% from parsing, need to go to 100%)
-        const reportProgress = createProgressReporter(options?.onProgress);
-        const existingGraph = await this.storage.getGraphForMutation();
-        const result = {
-            entitiesAdded: 0,
-            entitiesSkipped: 0,
-            entitiesUpdated: 0,
-            relationsAdded: 0,
-            relationsSkipped: 0,
-            errors: [],
-        };
-        const existingEntitiesMap = new Map();
-        for (const entity of existingGraph.entities) {
-            existingEntitiesMap.set(entity.name, entity);
-        }
-        const existingRelationsSet = new Set();
-        for (const relation of existingGraph.relations) {
-            existingRelationsSet.add(`${relation.from}|${relation.to}|${relation.relationType}`);
-        }
-        // Process entities (20-60% progress)
-        const totalEntities = importedGraph.entities.length;
-        const totalRelations = importedGraph.relations.length;
-        let processedEntities = 0;
-        for (const importedEntity of importedGraph.entities) {
-            // Check for cancellation periodically
-            checkCancellation(options?.signal, 'importGraph');
-            const existing = existingEntitiesMap.get(importedEntity.name);
-            if (!existing) {
-                result.entitiesAdded++;
-                if (!dryRun) {
-                    existingGraph.entities.push(importedEntity);
-                    existingEntitiesMap.set(importedEntity.name, importedEntity);
-                }
-            }
-            else {
-                switch (mergeStrategy) {
-                    case 'replace':
-                        result.entitiesUpdated++;
-                        if (!dryRun) {
-                            // Sanitize imported entity to prevent prototype pollution
-                            Object.assign(existing, sanitizeObject(importedEntity));
-                        }
-                        break;
-                    case 'skip':
-                        result.entitiesSkipped++;
-                        break;
-                    case 'merge':
-                        result.entitiesUpdated++;
-                        if (!dryRun) {
-                            existing.observations = [
-                                ...new Set([...existing.observations, ...importedEntity.observations]),
-                            ];
-                            if (importedEntity.tags) {
-                                existing.tags = existing.tags || [];
-                                existing.tags = [...new Set([...existing.tags, ...importedEntity.tags])];
-                            }
-                            if (importedEntity.importance !== undefined) {
-                                existing.importance = importedEntity.importance;
-                            }
-                            existing.lastModified = new Date().toISOString();
-                        }
-                        break;
-                    case 'fail':
-                        result.errors.push(`Entity "${importedEntity.name}" already exists`);
-                        break;
-                }
-            }
-            processedEntities++;
-            // Map entity progress (0-100%) to overall progress (20-60%)
-            const entityProgress = totalEntities > 0 ? Math.round(20 + (processedEntities / totalEntities) * 40) : 60;
-            reportProgress?.(createProgress(entityProgress, 100, 'importing entities'));
-        }
-        reportProgress?.(createProgress(60, 100, 'importing relations'));
-        // Process relations (60-95% progress)
-        let processedRelations = 0;
-        for (const importedRelation of importedGraph.relations) {
-            // Check for cancellation periodically
-            checkCancellation(options?.signal, 'importGraph');
-            const relationKey = `${importedRelation.from}|${importedRelation.to}|${importedRelation.relationType}`;
-            if (!existingEntitiesMap.has(importedRelation.from)) {
-                result.errors.push(`Relation source entity "${importedRelation.from}" does not exist`);
-                processedRelations++;
-                continue;
-            }
-            if (!existingEntitiesMap.has(importedRelation.to)) {
-                result.errors.push(`Relation target entity "${importedRelation.to}" does not exist`);
-                processedRelations++;
-                continue;
-            }
-            if (!existingRelationsSet.has(relationKey)) {
-                result.relationsAdded++;
-                if (!dryRun) {
-                    existingGraph.relations.push(importedRelation);
-                    existingRelationsSet.add(relationKey);
-                }
-            }
-            else {
-                if (mergeStrategy === 'fail') {
-                    result.errors.push(`Relation "${relationKey}" already exists`);
-                }
-                else {
-                    result.relationsSkipped++;
-                }
-            }
-            processedRelations++;
-            // Map relation progress (0-100%) to overall progress (60-95%)
-            const relationProgress = totalRelations > 0 ? Math.round(60 + (processedRelations / totalRelations) * 35) : 95;
-            reportProgress?.(createProgress(relationProgress, 100, 'importing relations'));
-        }
-        // Check for cancellation before final save
-        checkCancellation(options?.signal, 'importGraph');
-        reportProgress?.(createProgress(95, 100, 'saving graph'));
-        if (!dryRun && (mergeStrategy !== 'fail' || result.errors.length === 0)) {
-            await this.storage.saveGraph(existingGraph);
-        }
-        // Report completion
-        reportProgress?.(createProgress(100, 100, 'importGraph'));
-        return result;
-    }
-    // ============================================================
-    // BACKUP OPERATIONS
-    // ============================================================
-    /**
-     * Ensure backup directory exists.
-     */
-    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.
-     * @param compressed - Whether the backup will be compressed (affects extension)
-     */
-    generateBackupFileName(compressed = true) {
-        const now = new Date();
-        const timestamp = now.toISOString()
-            .replace(/:/g, '-')
-            .replace(/\./g, '-')
-            .replace('T', '_')
-            .replace('Z', '');
-        const extension = compressed ? '.jsonl.br' : '.jsonl';
-        return `backup_${timestamp}${extension}`;
-    }
-    /**
-     * 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 });
-     * ```
-     */
-    async createBackup(options) {
-        await this.ensureBackupDir();
-        // Handle legacy string argument (backward compatibility)
-        const opts = typeof options === 'string'
-            ? { description: options, compress: COMPRESSION_CONFIG.AUTO_COMPRESS_BACKUP }
-            : { compress: COMPRESSION_CONFIG.AUTO_COMPRESS_BACKUP, ...options };
-        const shouldCompress = opts.compress ?? COMPRESSION_CONFIG.AUTO_COMPRESS_BACKUP;
-        const graph = await this.storage.loadGraph();
-        const timestamp = new Date().toISOString();
-        const fileName = this.generateBackupFileName(shouldCompress);
-        const backupPath = join(this.backupDir, fileName);
-        try {
-            const originalPath = this.storage.getFilePath();
-            let fileContent;
-            try {
-                fileContent = await fs.readFile(originalPath, 'utf-8');
-            }
-            catch {
-                // If file doesn't exist, 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');
-            }
-            const originalSize = Buffer.byteLength(fileContent, 'utf-8');
-            let compressedSize = originalSize;
-            let compressionRatio = 1;
-            if (shouldCompress) {
-                // Compress with maximum quality for backups (archive quality)
-                const compressionResult = await compress(fileContent, {
-                    quality: COMPRESSION_CONFIG.BROTLI_QUALITY_ARCHIVE,
-                    mode: 'text',
-                });
-                await fs.writeFile(backupPath, compressionResult.compressed);
-                compressedSize = compressionResult.compressedSize;
-                compressionRatio = compressionResult.ratio;
-            }
-            else {
-                // Write uncompressed backup
-                await fs.writeFile(backupPath, fileContent);
-            }
-            const stats = await fs.stat(backupPath);
-            const metadata = {
-                timestamp,
-                entityCount: graph.entities.length,
-                relationCount: graph.relations.length,
-                fileSize: stats.size,
-                description: opts.description,
-                compressed: shouldCompress,
-                originalSize,
-                compressionRatio: shouldCompress ? compressionRatio : undefined,
-                compressionFormat: shouldCompress ? 'brotli' : 'none',
-            };
-            const metadataPath = `${backupPath}.meta.json`;
-            await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-            return {
-                path: backupPath,
-                timestamp,
-                entityCount: graph.entities.length,
-                relationCount: graph.relations.length,
-                compressed: shouldCompress,
-                originalSize,
-                compressedSize,
-                compressionRatio,
-                description: opts.description,
-            };
-        }
-        catch (error) {
-            throw new FileOperationError('create backup', backupPath, error);
-        }
-    }
-    /**
-     * 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
-     */
-    async listBackups() {
-        try {
-            try {
-                await fs.access(this.backupDir);
-            }
-            catch {
-                return [];
-            }
-            const files = await fs.readdir(this.backupDir);
-            // Match both .jsonl and .jsonl.br backup files, exclude metadata files
-            const backupFiles = files.filter(f => f.startsWith('backup_') &&
-                (f.endsWith('.jsonl') || f.endsWith('.jsonl.br')) &&
-                !f.endsWith('.meta.json'));
-            const backups = [];
-            for (const fileName of backupFiles) {
-                const filePath = join(this.backupDir, fileName);
-                const isCompressed = hasBrotliExtension(fileName);
-                // Try to read metadata file (handles both .jsonl.meta.json and .jsonl.br.meta.json)
-                const metadataPath = `${filePath}.meta.json`;
-                try {
-                    const [metadataContent, stats] = await Promise.all([
-                        fs.readFile(metadataPath, 'utf-8'),
-                        fs.stat(filePath),
-                    ]);
-                    const metadata = JSON.parse(metadataContent);
-                    // Ensure compression fields are present (backward compatibility)
-                    if (metadata.compressed === undefined) {
-                        metadata.compressed = isCompressed;
-                    }
-                    if (metadata.compressionFormat === undefined) {
-                        metadata.compressionFormat = isCompressed ? 'brotli' : 'none';
-                    }
-                    backups.push({
-                        fileName,
-                        filePath,
-                        metadata,
-                        compressed: isCompressed,
-                        size: stats.size,
-                    });
-                }
-                catch {
-                    // Skip backups without valid metadata
-                    continue;
-                }
-            }
-            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.
-     *
-     * 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');
-     * ```
-     */
-    async restoreFromBackup(backupPath) {
-        try {
-            await fs.access(backupPath);
-            const isCompressed = hasBrotliExtension(backupPath);
-            const backupBuffer = await fs.readFile(backupPath);
-            let backupContent;
-            if (isCompressed) {
-                // Decompress the backup
-                const decompressedBuffer = await decompress(backupBuffer);
-                backupContent = decompressedBuffer.toString('utf-8');
-            }
-            else {
-                // Read as plain text
-                backupContent = backupBuffer.toString('utf-8');
-            }
-            const mainPath = this.storage.getFilePath();
-            await fs.writeFile(mainPath, backupContent);
-            this.storage.clearCache();
-            // Load the restored graph to get counts
-            const graph = await this.storage.loadGraph();
-            return {
-                entityCount: graph.entities.length,
-                relationCount: graph.relations.length,
-                restoredFrom: backupPath,
-                wasCompressed: isCompressed,
-            };
-        }
-        catch (error) {
-            throw new FileOperationError('restore from backup', backupPath, error);
-        }
-    }
-    /**
-     * Delete a specific backup file.
-     *
-     * @param backupPath - Path to the backup file to delete
-     */
-    async deleteBackup(backupPath) {
-        try {
-            await fs.unlink(backupPath);
-            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.
-     *
-     * @param keepCount - Number of recent backups to keep (default: 10)
-     * @returns Promise resolving to number of backups deleted
-     */
-    async cleanOldBackups(keepCount = 10) {
-        const backups = await this.listBackups();
-        if (backups.length <= keepCount) {
-            return 0;
-        }
-        const backupsToDelete = backups.slice(keepCount);
-        let deletedCount = 0;
-        for (const backup of backupsToDelete) {
-            try {
-                await this.deleteBackup(backup.filePath);
-                deletedCount++;
-            }
-            catch {
-                continue;
-            }
-        }
-        return deletedCount;
-    }
-    /**
-     * Get the path to the backup directory.
-     */
-    getBackupDir() {
-        return this.backupDir;
-    }
-}
-//# sourceMappingURL=IOManager.js.map