@danielsimonjr/memory-mcp 12.2.3 → 12.5.2

package/dist/features/StreamingExporter.d.ts

@@ -1,105 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,150 +0,0 @@
-/**
- * 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

@@ -1,147 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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

@@ -1,210 +0,0 @@
-/**
- * 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

@@ -1,12 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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,11 +0,0 @@
-/**
- * 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';