@danielsimonjr/memory-mcp 12.5.2 → 12.7.0

package/dist/features/StreamingExporter.d.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 } 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.
+     *
+     * @param graph - The knowledge graph to export
+     * @returns Promise resolving to export statistics
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.jsonl');
+     * const result = await exporter.streamJSONL(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities`);
+     * ```
+     */
+    streamJSONL(graph: ReadonlyKnowledgeGraph): 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.
+     *
+     * @param graph - The knowledge graph to export
+     * @returns Promise resolving to export statistics
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.csv');
+     * const result = await exporter.streamCSV(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities as CSV`);
+     * ```
+     */
+    streamCSV(graph: ReadonlyKnowledgeGraph): 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,MAAM,mBAAmB,CAAC;AAExE;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;OAeG;IACG,WAAW,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,YAAY,CAAC;IAsCvE;;;;;;;;;;;;;;;OAeG;IACG,SAAS,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,YAAY,CAAC;IAmCrE;;;;;;;;;;OAUG;IACH,OAAO,CAAC,cAAc;CAcvB"}

package/dist/features/StreamingExporter.js

@@ -0,0 +1,150 @@
+/**
+ * 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';
+/**
+ * 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.
+     *
+     * @param graph - The knowledge graph to export
+     * @returns Promise resolving to export statistics
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.jsonl');
+     * const result = await exporter.streamJSONL(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities`);
+     * ```
+     */
+    async streamJSONL(graph) {
+        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) {
+            const line = JSON.stringify(entity) + '\n';
+            writeStream.write(line);
+            bytesWritten += Buffer.byteLength(line, 'utf-8');
+            entitiesWritten++;
+        }
+        // Write relations
+        for (const relation of graph.relations) {
+            const line = JSON.stringify(relation) + '\n';
+            writeStream.write(line);
+            bytesWritten += Buffer.byteLength(line, 'utf-8');
+            relationsWritten++;
+        }
+        // Wait for stream to finish
+        await new Promise((resolve, reject) => {
+            writeStream.end(() => resolve());
+            writeStream.on('error', reject);
+        });
+        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.
+     *
+     * @param graph - The knowledge graph to export
+     * @returns Promise resolving to export statistics
+     *
+     * @example
+     * ```typescript
+     * const exporter = new StreamingExporter('export.csv');
+     * const result = await exporter.streamCSV(graph);
+     * console.log(`Exported ${result.entitiesWritten} entities as CSV`);
+     * ```
+     */
+    async streamCSV(graph) {
+        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) {
+            const row = this.entityToCSVRow(entity) + '\n';
+            writeStream.write(row);
+            bytesWritten += Buffer.byteLength(row, 'utf-8');
+            entitiesWritten++;
+        }
+        // Wait for stream to finish
+        await new Promise((resolve, reject) => {
+            writeStream.end(() => resolve());
+            writeStream.on('error', reject);
+        });
+        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/TagManager.js

@@ -0,0 +1,210 @@
+/**
+ * Tag Manager
+ *
+ * Manages tag aliases and canonical tag resolution.
+ *
+ * @module features/TagManager
+ */
+import * as fs from 'fs/promises';
+/**
+ * Manages tag alias system for synonym mapping.
+ */
+export class TagManager {
+    tagAliasesFilePath;
+    constructor(tagAliasesFilePath) {
+        this.tagAliasesFilePath = tagAliasesFilePath;
+    }
+    /**
+     * Load all tag aliases from JSONL file.
+     *
+     * @returns Array of tag aliases
+     */
+    async loadTagAliases() {
+        try {
+            const data = await fs.readFile(this.tagAliasesFilePath, 'utf-8');
+            const lines = data.split('\n').filter((line) => line.trim() !== '');
+            return lines.map((line) => JSON.parse(line));
+        }
+        catch (error) {
+            if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Save tag aliases to JSONL file.
+     *
+     * @param aliases - Array of tag aliases
+     */
+    async saveTagAliases(aliases) {
+        const lines = aliases.map(a => JSON.stringify(a));
+        await fs.writeFile(this.tagAliasesFilePath, lines.join('\n'));
+    }
+    /**
+     * 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"
+     * ```
+     */
+    async resolveTag(tag) {
+        const aliases = await this.loadTagAliases();
+        const normalized = tag.toLowerCase();
+        // Check if this tag is an alias
+        const alias = aliases.find(a => a.alias === normalized);
+        if (alias) {
+            return alias.canonical;
+        }
+        // Return as-is (might be canonical or unaliased tag)
+        return normalized;
+    }
+    /**
+     * 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');
+     * }
+     * ```
+     */
+    async addTagAlias(alias, canonical, description) {
+        const aliases = await this.loadTagAliases();
+        const normalizedAlias = alias.toLowerCase();
+        const normalizedCanonical = canonical.toLowerCase();
+        // Check if alias already exists
+        if (aliases.some(a => a.alias === normalizedAlias)) {
+            throw new Error(`Tag alias "${alias}" already exists`);
+        }
+        // Prevent aliasing to another alias (aliases should point to canonical tags)
+        if (aliases.some(a => a.canonical === normalizedAlias)) {
+            throw new Error(`Cannot create alias to "${alias}" because it is a canonical tag with existing aliases`);
+        }
+        const newAlias = {
+            alias: normalizedAlias,
+            canonical: normalizedCanonical,
+            description,
+            createdAt: new Date().toISOString(),
+        };
+        aliases.push(newAlias);
+        await this.saveTagAliases(aliases);
+        return newAlias;
+    }
+    /**
+     * List all tag aliases.
+     *
+     * @returns Array of all tag aliases
+     */
+    async listTagAliases() {
+        return await this.loadTagAliases();
+    }
+    /**
+     * Remove a tag alias.
+     *
+     * @param alias - Alias to remove
+     * @returns True if removed, false if not found
+     */
+    async removeTagAlias(alias) {
+        const aliases = await this.loadTagAliases();
+        const normalizedAlias = alias.toLowerCase();
+        const initialLength = aliases.length;
+        const filtered = aliases.filter(a => a.alias !== normalizedAlias);
+        if (filtered.length === initialLength) {
+            return false; // Alias not found
+        }
+        await this.saveTagAliases(filtered);
+        return true;
+    }
+    /**
+     * 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); // []
+     * ```
+     */
+    async getAliasesForTag(canonicalTag) {
+        const aliases = await this.loadTagAliases();
+        const normalized = canonicalTag.toLowerCase();
+        return aliases.filter(a => a.canonical === normalized).map(a => a.alias);
+    }
+}

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

@@ -0,0 +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 { IOManager, } from './IOManager.js';
+export { AnalyticsManager } from './AnalyticsManager.js';
+export { CompressionManager } from './CompressionManager.js';
+export { ArchiveManager, } from './ArchiveManager.js';
+export { StreamingExporter } from './StreamingExporter.js';

package/dist/index.js

@@ -20,8 +20,14 @@ let managerContext;
 // tearing down the connection). Without this, other event-loop refs — file
 // watchers, the embeddings pool, the consolidation timer — can keep the
 // process alive as an orphan until manually killed.
-process.stdin.on("end", () => process.exit(0));
-process.stdin.on("close", () => process.exit(0));
+// ctx.close() (memoryjs v3) releases storage handles before exit; it is a
+// no-op for JSONL but closes the SQLite handle when MEMORY_STORAGE_TYPE=sqlite.
+function shutdown() {
+    managerContext?.close();
+    process.exit(0);
+}
+process.stdin.on("end", shutdown);
+process.stdin.on("close", shutdown);
 async function main() {
     // Initialize memory file path with backward compatibility
     const memoryFilePath = await ensureMemoryFilePath();