@danielsimonjr/memory-mcp 0.47.1 → 9.8.0

package/dist/features/StreamingExporter.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Streaming Export Module
+ *
+ * Provides streaming export functionality for large knowledge graphs to avoid
+ * loading entire graphs into memory. Supports JSONL and CSV formats with
+ * incremental writing to disk.
+ *
+ * @module features/StreamingExporter
+ */
+import type { ReadonlyKnowledgeGraph, LongRunningOperationOptions } from '../types/types.js';
+/**
+ * Result summary from a streaming export operation.
+ *
+ * Provides statistics about the export including bytes written,
+ * entity/relation counts, and duration.
+ *
+ * @example
+ * ```typescript
+ * const result: StreamResult = {
+ *   bytesWritten: 125000,
+ *   entitiesWritten: 150,
+ *   relationsWritten: 320,
+ *   durationMs: 1250
+ * };
+ * ```
+ */
+export interface StreamResult {
+    /** Total bytes written to the output file */
+    bytesWritten: number;
+    /** Number of entities written */
+    entitiesWritten: number;
+    /** Number of relations written */
+    relationsWritten: number;
+    /** Duration of the export operation in milliseconds */
+    durationMs: number;
+}
+/**
+ * Streaming exporter for knowledge graphs.
+ *
+ * Provides memory-efficient export by streaming data directly to files
+ * instead of building large strings in memory. Supports JSONL and CSV formats.
+ *
+ * @example
+ * ```typescript
+ * const exporter = new StreamingExporter('/path/to/output.jsonl');
+ * const result = await exporter.streamJSONL(graph);
+ * console.log(`Wrote ${result.bytesWritten} bytes in ${result.durationMs}ms`);
+ * ```
+ */
+export declare class StreamingExporter {
+    private readonly filePath;
+    /**
+     * Create a new streaming exporter.
+     *
+     * @param filePath - Path to the output file
+     */
+    constructor(filePath: string);
+    /**
+     * Stream a knowledge graph to JSONL format.
+     *
+     * Each entity and relation is written as a separate JSON line.
+     * Memory usage is constant regardless of graph size.
+     *
+     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
+     *
+     * @param graph - The knowledge graph to export
+     * @param options - Optional progress/cancellation options (Phase 9B)
+     * @returns Promise resolving to export statistics
+     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.jsonl');
+     * const result = await exporter.streamJSONL(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities`);
+     *
+     * // With progress tracking (Phase 9B)
+     * const result = await exporter.streamJSONL(graph, {
+     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
+     * });
+     * ```
+     */
+    streamJSONL(graph: ReadonlyKnowledgeGraph, options?: LongRunningOperationOptions): Promise<StreamResult>;
+    /**
+     * Stream a knowledge graph to CSV format.
+     *
+     * Exports entities as CSV rows with proper escaping for special characters.
+     * Header row includes: name, type, observations, tags, importance, createdAt, lastModified.
+     *
+     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
+     *
+     * @param graph - The knowledge graph to export
+     * @param options - Optional progress/cancellation options (Phase 9B)
+     * @returns Promise resolving to export statistics
+     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.csv');
+     * const result = await exporter.streamCSV(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities as CSV`);
+     *
+     * // With progress tracking (Phase 9B)
+     * const result = await exporter.streamCSV(graph, {
+     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
+     * });
+     * ```
+     */
+    streamCSV(graph: ReadonlyKnowledgeGraph, options?: LongRunningOperationOptions): Promise<StreamResult>;
+    /**
+     * Convert an entity to a CSV row with proper escaping.
+     *
+     * Escapes double quotes by doubling them and wraps fields in quotes.
+     * Arrays (observations, tags) are joined with semicolons.
+     *
+     * @param entity - The entity to convert
+     * @returns CSV row string (without trailing newline)
+     *
+     * @private
+     */
+    private entityToCSVRow;
+}
+//# sourceMappingURL=StreamingExporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingExporter.d.ts","sourceRoot":"","sources":["../../src/features/StreamingExporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,KAAK,EAAU,sBAAsB,EAAE,2BAA2B,EAAE,MAAM,mBAAmB,CAAC;AAGrG;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,YAAY;IAC3B,6CAA6C;IAC7C,YAAY,EAAE,MAAM,CAAC;IAErB,iCAAiC;IACjC,eAAe,EAAE,MAAM,CAAC;IAExB,kCAAkC;IAClC,gBAAgB,EAAE,MAAM,CAAC;IAEzB,uDAAuD;IACvD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAiB;IAMhB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IALrC;;;;OAIG;gBAC0B,QAAQ,EAAE,MAAM;IAE7C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,WAAW,CACf,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,YAAY,CAAC;IA+DxB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,SAAS,CACb,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,YAAY,CAAC;IAuDxB;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;CAcvB"}

package/dist/features/StreamingExporter.js

@@ -0,0 +1,203 @@
+/**
+ * Streaming Export Module
+ *
+ * Provides streaming export functionality for large knowledge graphs to avoid
+ * loading entire graphs into memory. Supports JSONL and CSV formats with
+ * incremental writing to disk.
+ *
+ * @module features/StreamingExporter
+ */
+import { createWriteStream } from 'fs';
+import { checkCancellation, createProgressReporter, createProgress } from '../utils/index.js';
+/**
+ * Streaming exporter for knowledge graphs.
+ *
+ * Provides memory-efficient export by streaming data directly to files
+ * instead of building large strings in memory. Supports JSONL and CSV formats.
+ *
+ * @example
+ * ```typescript
+ * const exporter = new StreamingExporter('/path/to/output.jsonl');
+ * const result = await exporter.streamJSONL(graph);
+ * console.log(`Wrote ${result.bytesWritten} bytes in ${result.durationMs}ms`);
+ * ```
+ */
+export class StreamingExporter {
+    filePath;
+    /**
+     * Create a new streaming exporter.
+     *
+     * @param filePath - Path to the output file
+     */
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    /**
+     * Stream a knowledge graph to JSONL format.
+     *
+     * Each entity and relation is written as a separate JSON line.
+     * Memory usage is constant regardless of graph size.
+     *
+     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
+     *
+     * @param graph - The knowledge graph to export
+     * @param options - Optional progress/cancellation options (Phase 9B)
+     * @returns Promise resolving to export statistics
+     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.jsonl');
+     * const result = await exporter.streamJSONL(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities`);
+     *
+     * // With progress tracking (Phase 9B)
+     * const result = await exporter.streamJSONL(graph, {
+     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
+     * });
+     * ```
+     */
+    async streamJSONL(graph, options) {
+        // Check for early cancellation
+        checkCancellation(options?.signal, 'streamJSONL');
+        // Setup progress reporter
+        const reportProgress = createProgressReporter(options?.onProgress);
+        const total = graph.entities.length + graph.relations.length;
+        let processed = 0;
+        reportProgress?.(createProgress(0, total, 'streamJSONL'));
+        const start = Date.now();
+        let bytesWritten = 0;
+        let entitiesWritten = 0;
+        let relationsWritten = 0;
+        const writeStream = createWriteStream(this.filePath);
+        // Write entities
+        for (const entity of graph.entities) {
+            // Check for cancellation periodically
+            checkCancellation(options?.signal, 'streamJSONL');
+            const line = JSON.stringify(entity) + '\n';
+            writeStream.write(line);
+            bytesWritten += Buffer.byteLength(line, 'utf-8');
+            entitiesWritten++;
+            processed++;
+            reportProgress?.(createProgress(processed, total, 'writing entities'));
+        }
+        // Write relations
+        for (const relation of graph.relations) {
+            // Check for cancellation periodically
+            checkCancellation(options?.signal, 'streamJSONL');
+            const line = JSON.stringify(relation) + '\n';
+            writeStream.write(line);
+            bytesWritten += Buffer.byteLength(line, 'utf-8');
+            relationsWritten++;
+            processed++;
+            reportProgress?.(createProgress(processed, total, 'writing relations'));
+        }
+        // Check for cancellation before finalizing
+        checkCancellation(options?.signal, 'streamJSONL');
+        // Wait for stream to finish
+        await new Promise((resolve, reject) => {
+            writeStream.end(() => resolve());
+            writeStream.on('error', reject);
+        });
+        // Report completion
+        reportProgress?.(createProgress(total, total, 'streamJSONL'));
+        return {
+            bytesWritten,
+            entitiesWritten,
+            relationsWritten,
+            durationMs: Date.now() - start,
+        };
+    }
+    /**
+     * Stream a knowledge graph to CSV format.
+     *
+     * Exports entities as CSV rows with proper escaping for special characters.
+     * Header row includes: name, type, observations, tags, importance, createdAt, lastModified.
+     *
+     * Phase 9B: Supports progress tracking and cancellation via LongRunningOperationOptions.
+     *
+     * @param graph - The knowledge graph to export
+     * @param options - Optional progress/cancellation options (Phase 9B)
+     * @returns Promise resolving to export statistics
+     * @throws {OperationCancelledError} If operation is cancelled via signal (Phase 9B)
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.csv');
+     * const result = await exporter.streamCSV(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities as CSV`);
+     *
+     * // With progress tracking (Phase 9B)
+     * const result = await exporter.streamCSV(graph, {
+     *   onProgress: (p) => console.log(`${p.percentage}% complete`),
+     * });
+     * ```
+     */
+    async streamCSV(graph, options) {
+        // Check for early cancellation
+        checkCancellation(options?.signal, 'streamCSV');
+        // Setup progress reporter
+        const reportProgress = createProgressReporter(options?.onProgress);
+        const total = graph.entities.length;
+        let processed = 0;
+        reportProgress?.(createProgress(0, total, 'streamCSV'));
+        const start = Date.now();
+        let bytesWritten = 0;
+        let entitiesWritten = 0;
+        const relationsWritten = 0; // CSV format doesn't export relations
+        const writeStream = createWriteStream(this.filePath);
+        // Write header
+        const header = 'name,type,observations,tags,importance,createdAt,lastModified\n';
+        writeStream.write(header);
+        bytesWritten += Buffer.byteLength(header, 'utf-8');
+        // Write entity rows
+        for (const entity of graph.entities) {
+            // Check for cancellation periodically
+            checkCancellation(options?.signal, 'streamCSV');
+            const row = this.entityToCSVRow(entity) + '\n';
+            writeStream.write(row);
+            bytesWritten += Buffer.byteLength(row, 'utf-8');
+            entitiesWritten++;
+            processed++;
+            reportProgress?.(createProgress(processed, total, 'writing entities'));
+        }
+        // Check for cancellation before finalizing
+        checkCancellation(options?.signal, 'streamCSV');
+        // Wait for stream to finish
+        await new Promise((resolve, reject) => {
+            writeStream.end(() => resolve());
+            writeStream.on('error', reject);
+        });
+        // Report completion
+        reportProgress?.(createProgress(total, total, 'streamCSV'));
+        return {
+            bytesWritten,
+            entitiesWritten,
+            relationsWritten,
+            durationMs: Date.now() - start,
+        };
+    }
+    /**
+     * Convert an entity to a CSV row with proper escaping.
+     *
+     * Escapes double quotes by doubling them and wraps fields in quotes.
+     * Arrays (observations, tags) are joined with semicolons.
+     *
+     * @param entity - The entity to convert
+     * @returns CSV row string (without trailing newline)
+     *
+     * @private
+     */
+    entityToCSVRow(entity) {
+        const escape = (s) => `"${s.replace(/"/g, '""')}"`;
+        return [
+            escape(entity.name),
+            escape(entity.entityType),
+            escape(entity.observations.join('; ')),
+            escape((entity.tags ?? []).join('; ')),
+            entity.importance?.toString() ?? '',
+            entity.createdAt ?? '',
+            entity.lastModified ?? '',
+        ].join(',');
+    }
+}

package/dist/features/TagManager.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Tag Manager
+ *
+ * Manages tag aliases and canonical tag resolution.
+ *
+ * @module features/TagManager
+ */
+import type { TagAlias } from '../types/index.js';
+/**
+ * Manages tag alias system for synonym mapping.
+ */
+export declare class TagManager {
+    private tagAliasesFilePath;
+    constructor(tagAliasesFilePath: string);
+    /**
+     * Load all tag aliases from JSONL file.
+     *
+     * @returns Array of tag aliases
+     */
+    private loadTagAliases;
+    /**
+     * Save tag aliases to JSONL file.
+     *
+     * @param aliases - Array of tag aliases
+     */
+    private saveTagAliases;
+    /**
+     * Resolve a tag through aliases to get its canonical form.
+     *
+     * This method follows the alias chain to find the canonical (main) tag name.
+     * All tags are normalized to lowercase for consistency.
+     * If the tag has no alias, it returns the tag itself as canonical.
+     *
+     * @param tag - Tag to resolve (can be alias or canonical)
+     * @returns Canonical tag name (lowercase)
+     *
+     * @example
+     * ```typescript
+     * const manager = new TagManager(tagAliasesPath);
+     *
+     * // Set up: assume "js" is aliased to "javascript"
+     * await manager.addTagAlias('js', 'javascript');
+     *
+     * // Resolve alias to canonical
+     * const canonical = await manager.resolveTag('js');
+     * console.log(canonical); // "javascript"
+     *
+     * // Resolve canonical tag (returns as-is)
+     * const unchanged = await manager.resolveTag('javascript');
+     * console.log(unchanged); // "javascript"
+     *
+     * // Resolve unknown tag (returns normalized)
+     * const unknown = await manager.resolveTag('PYTHON');
+     * console.log(unknown); // "python"
+     * ```
+     */
+    resolveTag(tag: string): Promise<string>;
+    /**
+     * Add a tag alias (synonym mapping).
+     *
+     * Creates a mapping from an alias (synonym) to a canonical (main) tag.
+     * This enables flexible tagging where users can use different terms
+     * that all resolve to the same canonical tag.
+     *
+     * Validation rules:
+     * - Prevents duplicate aliases (same alias can't map to different canonicals)
+     * - Prevents chained aliases (alias must point to canonical, not another alias)
+     * - All tags are normalized to lowercase
+     *
+     * @param alias - The alias/synonym (will be normalized to lowercase)
+     * @param canonical - The canonical (main) tag name (will be normalized to lowercase)
+     * @param description - Optional description explaining the alias relationship
+     * @returns Newly created TagAlias object with metadata
+     * @throws {Error} If alias already exists or would create chained aliases
+     *
+     * @example
+     * ```typescript
+     * const manager = new TagManager(tagAliasesPath);
+     *
+     * // Create simple alias
+     * await manager.addTagAlias('js', 'javascript', 'Common abbreviation');
+     *
+     * // Create multiple aliases for same canonical
+     * await manager.addTagAlias('py', 'python');
+     * await manager.addTagAlias('py3', 'python', 'Python 3.x');
+     *
+     * // Error: duplicate alias
+     * try {
+     *   await manager.addTagAlias('js', 'ecmascript'); // Fails - 'js' already aliased
+     * } catch (error) {
+     *   console.error('Alias already exists');
+     * }
+     *
+     * // Error: chained alias
+     * await manager.addTagAlias('js', 'javascript');
+     * try {
+     *   await manager.addTagAlias('javascript', 'ecmascript'); // Fails - can't alias canonical
+     * } catch (error) {
+     *   console.error('Cannot create chained aliases');
+     * }
+     * ```
+     */
+    addTagAlias(alias: string, canonical: string, description?: string): Promise<TagAlias>;
+    /**
+     * List all tag aliases.
+     *
+     * @returns Array of all tag aliases
+     */
+    listTagAliases(): Promise<TagAlias[]>;
+    /**
+     * Remove a tag alias.
+     *
+     * @param alias - Alias to remove
+     * @returns True if removed, false if not found
+     */
+    removeTagAlias(alias: string): Promise<boolean>;
+    /**
+     * Get all aliases (synonyms) for a canonical tag.
+     *
+     * Returns all alias names that resolve to the specified canonical tag.
+     * Useful for discovering alternative names users might use for a tag.
+     * The canonical tag name is normalized to lowercase.
+     *
+     * @param canonicalTag - Canonical tag name (will be normalized to lowercase)
+     * @returns Array of alias names (all lowercase)
+     *
+     * @example
+     * ```typescript
+     * const manager = new TagManager(tagAliasesPath);
+     *
+     * // Set up some aliases
+     * await manager.addTagAlias('js', 'javascript');
+     * await manager.addTagAlias('ecmascript', 'javascript');
+     * await manager.addTagAlias('es6', 'javascript');
+     *
+     * // Get all aliases for canonical tag
+     * const aliases = await manager.getAliasesForTag('javascript');
+     * console.log(aliases); // ['js', 'ecmascript', 'es6']
+     *
+     * // Empty array if no aliases
+     * const noAliases = await manager.getAliasesForTag('python');
+     * console.log(noAliases); // []
+     * ```
+     */
+    getAliasesForTag(canonicalTag: string): Promise<string[]>;
+}
+//# sourceMappingURL=TagManager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TagManager.d.ts","sourceRoot":"","sources":["../../src/features/TagManager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAElD;;GAEG;AACH,qBAAa,UAAU;IACT,OAAO,CAAC,kBAAkB;gBAAlB,kBAAkB,EAAE,MAAM;IAE9C;;;;OAIG;YACW,cAAc;IAa5B;;;;OAIG;YACW,cAAc;IAK5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAc9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;IA8B5F;;;;OAIG;IACG,cAAc,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;IAI3C;;;;;OAKG;IACG,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAcrD;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;CAKhE"}

package/dist/features/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Features Module Barrel Export
+ * Phase 4: Re-extracted specialized managers for single responsibility
+ * Phase 7: Added streaming export utilities
+ */
+export { TagManager } from './TagManager.js';
+export { IOManager, type ExportFormat, type ImportFormat, type MergeStrategy, type BackupMetadata, type BackupInfo, } from './IOManager.js';
+export { AnalyticsManager } from './AnalyticsManager.js';
+export { CompressionManager } from './CompressionManager.js';
+export { ArchiveManager, type ArchiveCriteria, type ArchiveOptions, type ArchiveResult, } from './ArchiveManager.js';
+export { StreamingExporter, type StreamResult } from './StreamingExporter.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/features/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EACL,SAAS,EACT,KAAK,YAAY,EACjB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,UAAU,GAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,EACL,cAAc,EACd,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,aAAa,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,iBAAiB,EAAE,KAAK,YAAY,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/features/index.js

@@ -1,12 +1,11 @@
 /**
  * Features Module Barrel Export
+ * Phase 4: Re-extracted specialized managers for single responsibility
+ * Phase 7: Added streaming export utilities
  */
 export { TagManager } from './TagManager.js';
-export { HierarchyManager } from './HierarchyManager.js';
+export { IOManager, } from './IOManager.js';
 export { AnalyticsManager } from './AnalyticsManager.js';
 export { CompressionManager } from './CompressionManager.js';
-export { ArchiveManager } from './ArchiveManager.js';
-export { BackupManager } from './BackupManager.js';
-export { ExportManager } from './ExportManager.js';
-export { ImportManager } from './ImportManager.js';
-export { ImportExportManager } from './ImportExportManager.js';
+export { ArchiveManager, } from './ArchiveManager.js';
+export { StreamingExporter } from './StreamingExporter.js';

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { defaultMemoryPath, ensureMemoryFilePath } from './utils/index.js';
+import { ManagerContext } from './core/ManagerContext.js';
+import type { Entity, Relation, KnowledgeGraph, GraphStats, ValidationReport, ValidationIssue, ValidationWarning, SavedSearch, TagAlias, SearchResult, BooleanQueryNode, ImportResult, CompressionResult } from './types/index.js';
+export { defaultMemoryPath, ensureMemoryFilePath };
+export type { Entity, Relation, KnowledgeGraph, GraphStats, ValidationReport, ValidationIssue, ValidationWarning, SavedSearch, TagAlias, SearchResult, BooleanQueryNode, ImportResult, CompressionResult, };
+export { ManagerContext };
+export { ManagerContext as KnowledgeGraphManager };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA,OAAO,EAAU,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,KAAK,EACV,MAAM,EACN,QAAQ,EACR,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,EAClB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,CAAC;AAGnD,YAAY,EACV,MAAM,EACN,QAAQ,EACR,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,iBAAiB,GAClB,CAAC;AAGF,OAAO,EAAE,cAAc,EAAE,CAAC;AAG1B,OAAO,EAAE,cAAc,IAAI,qBAAqB,EAAE,CAAC"}

package/dist/index.js

@@ -1,54 +1,21 @@
 #!/usr/bin/env node
-import { promises as fs } from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { logger } from './utils/logger.js';
-import { KnowledgeGraphManager } from './core/KnowledgeGraphManager.js';
+import { logger, defaultMemoryPath, ensureMemoryFilePath } from './utils/index.js';
+import { ManagerContext } from './core/ManagerContext.js';
 import { MCPServer } from './server/MCPServer.js';
-// Define memory file path using environment variable with fallback
-export const defaultMemoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'memory.jsonl');
-// Handle backward compatibility: migrate memory.json to memory.jsonl if needed
-export async function ensureMemoryFilePath() {
-    if (process.env.MEMORY_FILE_PATH) {
-        // Custom path provided, use it as-is (with absolute path resolution)
-        return path.isAbsolute(process.env.MEMORY_FILE_PATH)
-            ? process.env.MEMORY_FILE_PATH
-            : path.join(path.dirname(fileURLToPath(import.meta.url)), process.env.MEMORY_FILE_PATH);
-    }
-    // No custom path set, check for backward compatibility migration
-    const oldMemoryPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'memory.json');
-    const newMemoryPath = defaultMemoryPath;
-    try {
-        // Check if old file exists and new file doesn't
-        await fs.access(oldMemoryPath);
-        try {
-            await fs.access(newMemoryPath);
-            // Both files exist, use new one (no migration needed)
-            return newMemoryPath;
-        }
-        catch {
-            // Old file exists, new file doesn't - migrate
-            logger.info('Found legacy memory.json file, migrating to memory.jsonl for JSONL format compatibility');
-            await fs.rename(oldMemoryPath, newMemoryPath);
-            logger.info('Successfully migrated memory.json to memory.jsonl');
-            return newMemoryPath;
-        }
-    }
-    catch {
-        // Old file doesn't exist, use new path
-        return newMemoryPath;
-    }
-}
-// Re-export KnowledgeGraphManager for backward compatibility
-export { KnowledgeGraphManager };
-let knowledgeGraphManager;
+// Re-export path utilities for backward compatibility
+export { defaultMemoryPath, ensureMemoryFilePath };
+// Re-export ManagerContext (replaces KnowledgeGraphManager)
+export { ManagerContext };
+// Backward compatibility alias
+export { ManagerContext as KnowledgeGraphManager };
+let managerContext;
 async function main() {
     // Initialize memory file path with backward compatibility
     const memoryFilePath = await ensureMemoryFilePath();
-    // Initialize knowledge graph manager with the memory file path
-    knowledgeGraphManager = new KnowledgeGraphManager(memoryFilePath);
+    // Initialize manager context with the memory file path
+    managerContext = new ManagerContext(memoryFilePath);
     // Initialize and start MCP server
-    const server = new MCPServer(knowledgeGraphManager);
+    const server = new MCPServer(managerContext);
     await server.start();
 }
 main().catch((error) => {