monomind 1.16.11 → 1.17.1

package/packages/@monomind/cli/dist/src/commands/memory.js

@@ -1,1449 +1,18 @@
 /**
  * CLI Memory Command
  * Memory operations for LanceDB integration
+ *
+ * Split into sub-modules:
+ *   memory-crud.ts     — store, retrieve, search
+ *   memory-list.ts     — list, edit, templates
+ *   memory-admin.ts    — delete, stats, configure, cleanup
+ *   memory-transfer.ts — compress, export, import
  */
 import { output } from '../output.js';
-import { select, confirm, input } from '../prompt.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-import { configManager } from '../services/config-file-manager.js';
-// Memory backends
-const BACKENDS = [
-    { value: 'lancedb', label: 'LanceDB', hint: 'Vector database with ANN indexing' },
-    { value: 'sqlite', label: 'SQLite', hint: 'Lightweight local storage' },
-    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + LanceDB (recommended)' },
-    { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' }
-];
-// Store command
-const storeCommand = {
-    name: 'store',
-    description: 'Store data in memory',
-    options: [
-        {
-            name: 'key',
-            short: 'k',
-            description: 'Storage key/namespace',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'value',
-            // Note: No short flag - global -v is reserved for verbose
-            description: 'Value to store (use --value)',
-            type: 'string'
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Memory namespace',
-            type: 'string',
-            default: 'default'
-        },
-        {
-            name: 'ttl',
-            description: 'Time to live in seconds',
-            type: 'number'
-        },
-        {
-            name: 'tags',
-            description: 'Comma-separated tags',
-            type: 'string'
-        },
-        {
-            name: 'vector',
-            description: 'Store as vector embedding',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'upsert',
-            short: 'u',
-            description: 'Update if key exists (insert or replace)',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind memory store -k "api/auth" -v "JWT implementation"', description: 'Store text' },
-        { command: 'monomind memory store -k "pattern/singleton" --vector', description: 'Store vector' },
-        { command: 'monomind memory store -k "pattern" -v "updated" --upsert', description: 'Update existing' }
-    ],
-    action: async (ctx) => {
-        const key = ctx.flags.key;
-        let value = ctx.flags.value || ctx.args[0];
-        const namespace = ctx.flags.namespace;
-        const ttl = ctx.flags.ttl;
-        const tags = ctx.flags.tags ? ctx.flags.tags.split(',') : [];
-        const asVector = ctx.flags.vector;
-        const upsert = ctx.flags.upsert;
-        if (!key) {
-            output.printError('Key is required. Use --key or -k');
-            return { success: false, exitCode: 1 };
-        }
-        if (!value && ctx.interactive) {
-            value = await input({
-                message: 'Enter value to store:',
-                validate: (v) => v.length > 0 || 'Value is required'
-            });
-        }
-        if (!value) {
-            output.printError('Value is required. Use --value');
-            return { success: false, exitCode: 1 };
-        }
-        const storeData = {
-            key,
-            namespace,
-            value,
-            ttl,
-            tags,
-            asVector,
-            storedAt: new Date().toISOString(),
-            size: Buffer.byteLength(value, 'utf8')
-        };
-        output.printInfo(`Storing in ${namespace}/${key}...`);
-        // Use direct sql.js storage with automatic embedding generation
-        try {
-            const { storeEntry } = await import('../memory/memory-initializer.js');
-            if (asVector) {
-                output.writeln(output.dim('  Generating embedding vector...'));
-            }
-            const result = await storeEntry({
-                key,
-                value,
-                namespace,
-                generateEmbeddingFlag: true, // Always generate embeddings for semantic search
-                tags,
-                ttl,
-                upsert
-            });
-            if (!result.success) {
-                output.printError(result.error || 'Failed to store');
-                return { success: false, exitCode: 1 };
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'val', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'Key', val: key },
-                    { property: 'Namespace', val: namespace },
-                    { property: 'Size', val: `${storeData.size} bytes` },
-                    { property: 'TTL', val: ttl ? `${ttl}s` : 'None' },
-                    { property: 'Tags', val: tags.length > 0 ? tags.join(', ') : 'None' },
-                    { property: 'Vector', val: result.embedding ? `Yes (${result.embedding.dimensions}-dim)` : 'No' },
-                    { property: 'ID', val: result.id.substring(0, 20) }
-                ]
-            });
-            output.writeln();
-            output.printSuccess('Data stored successfully');
-            return { success: true, data: { ...storeData, id: result.id, embedding: result.embedding } };
-        }
-        catch (error) {
-            output.printError(`Failed to store: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Retrieve command
-const retrieveCommand = {
-    name: 'retrieve',
-    aliases: ['get'],
-    description: 'Retrieve data from memory',
-    options: [
-        {
-            name: 'key',
-            short: 'k',
-            description: 'Storage key',
-            type: 'string'
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Memory namespace',
-            type: 'string',
-            default: 'default'
-        }
-    ],
-    action: async (ctx) => {
-        const key = ctx.flags.key || ctx.args[0];
-        const namespace = ctx.flags.namespace;
-        if (!key) {
-            output.printError('Key is required');
-            return { success: false, exitCode: 1 };
-        }
-        // Use sql.js directly for consistent data access
-        try {
-            const { getEntry } = await import('../memory/memory-initializer.js');
-            const result = await getEntry({ key, namespace });
-            if (!result.success) {
-                output.printError(`Failed to retrieve: ${result.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            if (!result.found || !result.entry) {
-                output.printWarning(`Key not found: ${key}`);
-                return { success: false, exitCode: 1, data: { key, found: false } };
-            }
-            const entry = result.entry;
-            if (ctx.flags.format === 'json') {
-                output.printJson(entry);
-                return { success: true, data: entry };
-            }
-            output.writeln();
-            output.printBox([
-                `Namespace: ${entry.namespace}`,
-                `Key: ${entry.key}`,
-                `Size: ${entry.content.length} bytes`,
-                `Access Count: ${entry.accessCount}`,
-                `Tags: ${entry.tags.length > 0 ? entry.tags.join(', ') : 'None'}`,
-                `Vector: ${entry.hasEmbedding ? 'Yes' : 'No'}`,
-                '',
-                output.bold('Value:'),
-                entry.content
-            ].join('\n'), 'Memory Entry');
-            return { success: true, data: entry };
-        }
-        catch (error) {
-            output.printError(`Failed to retrieve: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Search command
-const searchCommand = {
-    name: 'search',
-    description: 'Search memory with semantic/vector search',
-    options: [
-        {
-            name: 'query',
-            short: 'q',
-            description: 'Search query',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Memory namespace',
-            type: 'string'
-        },
-        {
-            name: 'limit',
-            short: 'l',
-            description: 'Maximum results',
-            type: 'number',
-            default: 10
-        },
-        {
-            name: 'threshold',
-            description: 'Similarity threshold (0-1)',
-            type: 'number',
-            default: 0.7
-        },
-        {
-            name: 'type',
-            short: 't',
-            description: 'Search type (semantic, keyword, hybrid)',
-            type: 'string',
-            default: 'semantic',
-            choices: ['semantic', 'keyword', 'hybrid']
-        },
-        {
-            name: 'build-hnsw',
-            description: 'Build/rebuild pure-JS HNSW index before searching',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind memory search -q "authentication patterns"', description: 'Semantic search' },
-        { command: 'monomind memory search -q "JWT" -t keyword', description: 'Keyword search' },
-        { command: 'monomind memory search -q "test" --build-hnsw', description: 'Build HNSW index and search' }
-    ],
-    action: async (ctx) => {
-        const query = ctx.flags.query || ctx.args[0];
-        const namespace = ctx.flags.namespace || 'all';
-        const limit = ctx.flags.limit || 10;
-        const threshold = ctx.flags.threshold || 0.3;
-        const searchType = ctx.flags.type || 'semantic';
-        const buildHnsw = (ctx.flags['build-hnsw'] || ctx.flags.buildHnsw);
-        if (!query) {
-            output.printError('Query is required. Use --query or -q');
-            return { success: false, exitCode: 1 };
-        }
-        // Build/rebuild HNSW index if requested
-        if (buildHnsw) {
-            output.printInfo('Building HNSW index...');
-            try {
-                const { getHNSWIndex, getHNSWStatus } = await import('../memory/memory-initializer.js');
-                const startTime = Date.now();
-                const index = await getHNSWIndex({ forceRebuild: true });
-                const buildTime = Date.now() - startTime;
-                if (index) {
-                    const status = getHNSWStatus();
-                    output.printSuccess(`HNSW index built (${status.entryCount} vectors, ${buildTime}ms)`);
-                    output.writeln(output.dim(`  Dimensions: ${status.dimensions}, Metric: cosine`));
-                    output.writeln(output.dim(`  Complexity: O(log n) vs O(n) linear scan`));
-                }
-                else {
-                    output.printWarning('HNSW index not available');
-                }
-                output.writeln();
-            }
-            catch (error) {
-                output.printWarning(`HNSW build failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                output.writeln(output.dim('  Falling back to brute-force search'));
-                output.writeln();
-            }
-        }
-        output.printInfo(`Searching: "${query}" (${searchType})`);
-        output.writeln();
-        // Use direct sql.js search with vector similarity
-        try {
-            const { searchEntries } = await import('../memory/memory-initializer.js');
-            const searchResult = await searchEntries({
-                query,
-                namespace,
-                limit,
-                threshold
-            });
-            if (!searchResult.success) {
-                output.printError(searchResult.error || 'Search failed');
-                return { success: false, exitCode: 1 };
-            }
-            const results = searchResult.results.map(r => ({
-                key: r.key,
-                score: r.score,
-                namespace: r.namespace,
-                preview: r.content
-            }));
-            if (ctx.flags.format === 'json') {
-                output.printJson({ query, searchType, results, searchTime: `${searchResult.searchTime}ms` });
-                return { success: true, data: results };
-            }
-            // Performance stats
-            output.writeln(output.dim(`  Search time: ${searchResult.searchTime}ms`));
-            output.writeln();
-            if (results.length === 0) {
-                output.printWarning('No results found');
-                output.writeln(output.dim('Try: monomind memory store -k "key" --value "data"'));
-                return { success: true, data: [] };
-            }
-            output.printTable({
-                columns: [
-                    { key: 'key', header: 'Key', width: 20 },
-                    { key: 'score', header: 'Score', width: 8, align: 'right', format: (v) => Number(v).toFixed(2) },
-                    { key: 'namespace', header: 'Namespace', width: 12 },
-                    { key: 'preview', header: 'Preview', width: 35 }
-                ],
-                data: results
-            });
-            output.writeln();
-            output.printInfo(`Found ${results.length} results`);
-            return { success: true, data: results };
-        }
-        catch (error) {
-            output.printError(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// List command
-const listCommand = {
-    name: 'list',
-    aliases: ['ls'],
-    description: 'List memory entries',
-    options: [
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Filter by namespace',
-            type: 'string'
-        },
-        {
-            name: 'tags',
-            short: 't',
-            description: 'Filter by tags (comma-separated)',
-            type: 'string'
-        },
-        {
-            name: 'limit',
-            short: 'l',
-            description: 'Maximum entries',
-            type: 'number',
-            default: 20
-        }
-    ],
-    action: async (ctx) => {
-        const namespace = ctx.flags.namespace;
-        const limit = ctx.flags.limit;
-        // Use sql.js directly for consistent data access
-        try {
-            const { listEntries } = await import('../memory/memory-initializer.js');
-            const listResult = await listEntries({ namespace, limit, offset: 0 });
-            if (!listResult.success) {
-                output.printError(`Failed to list: ${listResult.error}`);
-                return { success: false, exitCode: 1 };
-            }
-            // Format entries for display
-            const entries = listResult.entries.map(e => ({
-                key: e.key,
-                namespace: e.namespace,
-                size: e.size + ' B',
-                vector: e.hasEmbedding ? '✓' : '-',
-                accessCount: e.accessCount,
-                updated: formatRelativeTime(e.updatedAt)
-            }));
-            if (ctx.flags.format === 'json') {
-                output.printJson(listResult.entries);
-                return { success: true, data: listResult.entries };
-            }
-            output.writeln();
-            output.writeln(output.bold('Memory Entries'));
-            output.writeln();
-            if (entries.length === 0) {
-                output.printWarning('No entries found');
-                output.printInfo('Store data: monomind memory store -k "key" --value "data"');
-                return { success: true, data: [] };
-            }
-            output.printTable({
-                columns: [
-                    { key: 'key', header: 'Key', width: 25 },
-                    { key: 'namespace', header: 'Namespace', width: 12 },
-                    { key: 'size', header: 'Size', width: 10, align: 'right' },
-                    { key: 'vector', header: 'Vector', width: 8, align: 'center' },
-                    { key: 'accessCount', header: 'Accessed', width: 10, align: 'right' },
-                    { key: 'updated', header: 'Updated', width: 12 }
-                ],
-                data: entries
-            });
-            output.writeln();
-            output.printInfo(`Showing ${entries.length} of ${listResult.total} entries`);
-            return { success: true, data: listResult.entries };
-        }
-        catch (error) {
-            output.printError(`Failed to list: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Helper function to format relative time
-function formatRelativeTime(isoDate) {
-    const now = Date.now();
-    const date = new Date(isoDate).getTime();
-    const diff = now - date;
-    const seconds = Math.floor(diff / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    if (days > 0)
-        return `${days}d ago`;
-    if (hours > 0)
-        return `${hours}h ago`;
-    if (minutes > 0)
-        return `${minutes}m ago`;
-    return 'just now';
-}
-// Edit command
-const editCommand = {
-    name: 'edit',
-    description: 'Edit a memory entry (LanceDB, Memory Palace, or knowledge chunk)',
-    options: [
-        { name: 'key', short: 'k', description: 'Storage key', type: 'string' },
-        { name: 'namespace', short: 'n', description: 'Memory namespace', type: 'string', default: 'default' },
-        { name: 'value', description: 'New value/content', type: 'string' },
-        { name: 'source', short: 's', description: 'Source to edit: lancedb, palace, knowledge', type: 'string', default: 'lancedb', choices: ['lancedb', 'palace', 'knowledge'] },
-        { name: 'id', description: 'Entry ID (palace/knowledge)', type: 'string' }
-    ],
-    examples: [
-        { command: 'monomind memory edit -k "pattern/auth" --value "updated content"', description: 'Edit LanceDB entry' },
-        { command: 'monomind memory edit --source palace --id "abc123" --value "new content"', description: 'Edit Memory Palace drawer' },
-        { command: 'monomind memory edit --source knowledge --id "chunk-42" --value "updated"', description: 'Edit knowledge chunk' }
-    ],
-    action: async (ctx) => {
-        const source = ctx.flags.source || 'lancedb';
-        let value = ctx.flags.value || ctx.args[0];
-        const fs = await import('fs');
-        const path = await import('path');
-        if (source === 'lancedb') {
-            const key = ctx.flags.key;
-            const namespace = ctx.flags.namespace || 'default';
-            if (!key) {
-                output.printError('Key is required for lancedb edit. Use --key or -k');
-                return { success: false, exitCode: 1 };
-            }
-            if (!value && ctx.interactive) {
-                value = await input({ message: 'Enter new value:', validate: v => v.length > 0 || 'Value required' });
-            }
-            if (!value) {
-                output.printError('Value is required. Use --value');
-                return { success: false, exitCode: 1 };
-            }
-            try {
-                const { storeEntry } = await import('../memory/memory-initializer.js');
-                const result = await storeEntry({ key, value, namespace, generateEmbeddingFlag: true, upsert: true });
-                if (!result.success) {
-                    output.printError(result.error || 'Failed to update');
-                    return { success: false, exitCode: 1 };
-                }
-                output.printSuccess(`Updated "${key}" in namespace "${namespace}"`);
-                return { success: true, data: result };
-            }
-            catch (error) {
-                output.printError(`Failed to edit: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                return { success: false, exitCode: 1 };
-            }
-        }
-        // palace or knowledge — JSONL file edit
-        const id = ctx.flags.id;
-        if (!id) {
-            output.printError('Entry ID is required for palace/knowledge edit. Use --id');
-            return { success: false, exitCode: 1 };
-        }
-        if (!/^[a-zA-Z0-9_\-]{1,128}$/.test(id)) {
-            output.printError('ID must be 1-128 chars: alphanumeric, underscore, or hyphen only');
-            return { success: false, exitCode: 1 };
-        }
-        const filePath = source === 'palace'
-            ? path.join(process.cwd(), '.monomind', 'palace', 'drawers.jsonl')
-            : path.join(process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl');
-        if (!fs.existsSync(filePath)) {
-            output.printError(`File not found: ${filePath}`);
-            return { success: false, exitCode: 1 };
-        }
-        const MAX_MEMORY_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
-        if (fs.statSync(filePath).size > MAX_MEMORY_FILE_BYTES) {
-            output.printError(`Memory file too large (> 50 MB): ${filePath}`);
-            return { success: false, exitCode: 1 };
-        }
-        let entries;
-        try {
-            const raw = fs.readFileSync(filePath, 'utf8');
-            entries = [];
-            for (const line of raw.split('\n').filter(Boolean)) {
-                try {
-                    entries.push(JSON.parse(line));
-                }
-                catch {
-                    output.printError(`Malformed JSONL entry in ${source} file`);
-                    return { success: false, exitCode: 1 };
-                }
-            }
-        }
-        catch (err) {
-            output.printError(`Failed to read ${source} file: ${err instanceof Error ? err.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-        const idx = entries.findIndex(e => e.id === id);
-        if (idx === -1) {
-            output.printWarning(`Entry not found with id "${id}"`);
-            return { success: false, exitCode: 1 };
-        }
-        if (!value && ctx.interactive) {
-            output.writeln(output.dim('Current content:'));
-            output.writeln(entries[idx].content || '(empty)');
-            output.writeln();
-            value = await input({ message: 'Enter new content:', validate: v => v.length > 0 || 'Content required' });
-        }
-        if (!value) {
-            output.printError('Value is required. Use --value');
-            return { success: false, exitCode: 1 };
-        }
-        entries[idx] = { ...entries[idx], content: value, ts: new Date().toISOString() };
-        try {
-            const tmpPath = filePath + '.tmp';
-            fs.writeFileSync(tmpPath, entries.map(e => JSON.stringify(e)).join('\n') + '\n');
-            fs.renameSync(tmpPath, filePath);
-            output.printSuccess(`Updated ${source} entry "${id}"`);
-            return { success: true, data: entries[idx] };
-        }
-        catch (err) {
-            output.printError(`Failed to write ${source} file: ${err instanceof Error ? err.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Templates command
-const templatesCommand = {
-    name: 'templates',
-    description: 'Show best-practice templates for memory entries',
-    options: [
-        { name: 'type', short: 't', description: 'Template type: user, feedback, project, reference', type: 'string', choices: ['user', 'feedback', 'project', 'reference'] }
-    ],
-    examples: [
-        { command: 'monomind memory templates', description: 'Show all templates' },
-        { command: 'monomind memory templates -t feedback', description: 'Show feedback template only' }
-    ],
-    action: async (ctx) => {
-        const filter = ctx.flags.type;
-        const templates = {
-            user: {
-                label: 'User Memory',
-                description: 'Role, goals, preferences, knowledge level',
-                example: [
-                    '---',
-                    'name: user_role',
-                    'description: <one-line summary of user role and context>',
-                    'type: user',
-                    '---',
-                    '',
-                    '<Role and experience description. What does the user know well? What are they new to?>',
-                    'Frame explanations accordingly.'
-                ].join('\n')
-            },
-            feedback: {
-                label: 'Feedback Memory',
-                description: 'How to approach work — corrections and validated choices',
-                example: [
-                    '---',
-                    'name: feedback_<topic>',
-                    'description: <one-line rule that triggers on lookup>',
-                    'type: feedback',
-                    '---',
-                    '',
-                    '<The rule itself — what to do or avoid.>',
-                    '',
-                    '**Why:** <Reason the user gave — past incident, strong preference, etc.>',
-                    '',
-                    '**How to apply:** <When does this kick in? What edge cases does it cover?>'
-                ].join('\n')
-            },
-            project: {
-                label: 'Project Memory',
-                description: 'Ongoing work context, goals, decisions, deadlines',
-                example: [
-                    '---',
-                    'name: project_<initiative>',
-                    'description: <one-line fact about the project decision or constraint>',
-                    'type: project',
-                    '---',
-                    '',
-                    '<The fact or decision — what is happening and what was decided.>',
-                    '',
-                    '**Why:** <Motivation — constraint, deadline, stakeholder ask, compliance issue.>',
-                    '',
-                    '**How to apply:** <How should this shape future suggestions and decisions?>'
-                ].join('\n')
-            },
-            reference: {
-                label: 'Reference Memory',
-                description: 'Pointers to external resources and where to find information',
-                example: [
-                    '---',
-                    'name: reference_<resource>',
-                    'description: <what this resource contains and when to use it>',
-                    'type: reference',
-                    '---',
-                    '',
-                    '<Resource name and location (URL, project name, channel, etc.)>',
-                    '',
-                    'Use this when: <specific scenarios where this reference is relevant>.'
-                ].join('\n')
-            }
-        };
-        output.writeln();
-        output.writeln(output.bold('Memory Entry Templates'));
-        output.writeln(output.dim('Best-practice scaffolds for .claude/projects/.../memory/ entries'));
-        output.writeln();
-        const keys = filter ? [filter] : Object.keys(templates);
-        for (const key of keys) {
-            const t = templates[key];
-            if (!t) {
-                output.printError(`Unknown type: "${key}". Valid types: user, feedback, project, reference`);
-                return { success: false, exitCode: 1 };
-            }
-            output.writeln(output.bold(`── ${t.label}  (--type ${key})`));
-            output.writeln(output.dim(`   ${t.description}`));
-            output.writeln();
-            output.writeln(t.example);
-            output.writeln();
-        }
-        output.writeln(output.dim('Save with: monomind memory store -k "<name>" --value "<content>" --namespace auto-memory'));
-        return { success: true };
-    }
-};
-// Delete command
-const deleteCommand = {
-    name: 'delete',
-    aliases: ['rm'],
-    description: 'Delete a memory entry (LanceDB, Memory Palace, or knowledge chunk)',
-    options: [
-        {
-            name: 'key',
-            short: 'k',
-            description: 'Storage key',
-            type: 'string'
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Memory namespace',
-            type: 'string',
-            default: 'default'
-        },
-        {
-            name: 'source',
-            short: 's',
-            description: 'Source to delete from: lancedb, palace, knowledge',
-            type: 'string',
-            default: 'lancedb',
-            choices: ['lancedb', 'palace', 'knowledge']
-        },
-        {
-            name: 'id',
-            description: 'Entry ID (palace/knowledge)',
-            type: 'string'
-        },
-        {
-            name: 'force',
-            short: 'f',
-            description: 'Skip confirmation',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind memory delete -k "mykey"', description: 'Delete memory entry' },
-        { command: 'monomind memory delete -k "lesson" -n "lessons"', description: 'Delete from specific namespace' },
-        { command: 'monomind memory delete --source palace --id "abc123"', description: 'Delete Memory Palace drawer' },
-        { command: 'monomind memory delete --source knowledge --id "chunk-42" -f', description: 'Delete knowledge chunk (no confirm)' }
-    ],
-    action: async (ctx) => {
-        const source = ctx.flags.source || 'lancedb';
-        const force = ctx.flags.force;
-        if (source === 'lancedb') {
-            const key = ctx.flags.key || ctx.args[0];
-            const namespace = ctx.flags.namespace || 'default';
-            if (!key) {
-                output.printError('Key is required. Use: memory delete -k "key" [-n "namespace"]');
-                return { success: false, exitCode: 1 };
-            }
-            if (!force && ctx.interactive) {
-                const confirmed = await confirm({
-                    message: `Delete memory entry "${key}" from namespace "${namespace}"?`,
-                    default: false
-                });
-                if (!confirmed) {
-                    output.printInfo('Operation cancelled');
-                    return { success: true };
-                }
-            }
-            try {
-                const { deleteEntry } = await import('../memory/memory-initializer.js');
-                const result = await deleteEntry({ key, namespace });
-                if (!result.success) {
-                    output.printError(result.error || 'Failed to delete');
-                    return { success: false, exitCode: 1 };
-                }
-                if (result.deleted) {
-                    output.printSuccess(`Deleted "${key}" from namespace "${namespace}"`);
-                    output.printInfo(`Remaining entries: ${result.remainingEntries}`);
-                }
-                else {
-                    output.printWarning(`Key not found: "${key}" in namespace "${namespace}"`);
-                }
-                return { success: result.deleted, data: result };
-            }
-            catch (error) {
-                output.printError(`Failed to delete: ${error instanceof Error ? error.message : 'Unknown error'}`);
-                return { success: false, exitCode: 1 };
-            }
-        }
-        // palace or knowledge — JSONL file delete
-        const id = ctx.flags.id || ctx.args[0];
-        if (!id) {
-            output.printError('Entry ID is required for palace/knowledge delete. Use --id');
-            return { success: false, exitCode: 1 };
-        }
-        if (!/^[a-zA-Z0-9_\-]{1,128}$/.test(id)) {
-            output.printError('ID must be 1-128 chars: alphanumeric, underscore, or hyphen only');
-            return { success: false, exitCode: 1 };
-        }
-        const fs = await import('fs');
-        const path = await import('path');
-        const filePath = source === 'palace'
-            ? path.join(process.cwd(), '.monomind', 'palace', 'drawers.jsonl')
-            : path.join(process.cwd(), '.monomind', 'knowledge', 'chunks.jsonl');
-        if (!fs.existsSync(filePath)) {
-            output.printError(`File not found: ${filePath}`);
-            return { success: false, exitCode: 1 };
-        }
-        const MAX_MEMORY_FILE_BYTES = 50 * 1024 * 1024; // 50 MB
-        if (fs.statSync(filePath).size > MAX_MEMORY_FILE_BYTES) {
-            output.printError(`Memory file too large (> 50 MB): ${filePath}`);
-            return { success: false, exitCode: 1 };
-        }
-        let entries;
-        try {
-            const raw = fs.readFileSync(filePath, 'utf8');
-            entries = [];
-            for (const line of raw.split('\n').filter(Boolean)) {
-                try {
-                    entries.push(JSON.parse(line));
-                }
-                catch {
-                    output.printError(`Malformed JSONL entry in ${source} file`);
-                    return { success: false, exitCode: 1 };
-                }
-            }
-        }
-        catch (err) {
-            output.printError(`Failed to read ${source} file: ${err instanceof Error ? err.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-        const idx = entries.findIndex(e => e.id === id);
-        if (idx === -1) {
-            output.printWarning(`Entry not found with id "${id}"`);
-            return { success: false, exitCode: 1 };
-        }
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Delete ${source} entry "${id}"?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        entries.splice(idx, 1);
-        try {
-            const tmpPath = filePath + '.tmp';
-            fs.writeFileSync(tmpPath, entries.map(e => JSON.stringify(e)).join('\n') + (entries.length ? '\n' : ''));
-            fs.renameSync(tmpPath, filePath);
-            output.printSuccess(`Deleted ${source} entry "${id}"`);
-            output.printInfo(`Remaining entries: ${entries.length}`);
-            return { success: true, data: { id, deleted: true, remainingEntries: entries.length } };
-        }
-        catch (err) {
-            output.printError(`Failed to write ${source} file: ${err instanceof Error ? err.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Stats command
-const statsCommand = {
-    name: 'stats',
-    description: 'Show memory statistics',
-    action: async (ctx) => {
-        // Call MCP memory/stats tool for real statistics
-        try {
-            const statsResult = await callMCPTool('memory_stats', {});
-            const stats = {
-                backend: statsResult.backend,
-                entries: {
-                    total: statsResult.totalEntries,
-                    vectors: 0, // Would need vector backend support
-                    text: statsResult.totalEntries
-                },
-                storage: {
-                    total: statsResult.totalSize,
-                    location: statsResult.location
-                },
-                version: statsResult.version,
-                oldestEntry: statsResult.oldestEntry,
-                newestEntry: statsResult.newestEntry
-            };
-            if (ctx.flags.format === 'json') {
-                output.printJson(stats);
-                return { success: true, data: stats };
-            }
-            output.writeln();
-            output.writeln(output.bold('Memory Statistics'));
-            output.writeln();
-            output.writeln(output.bold('Overview'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'value', header: 'Value', width: 30, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Backend', value: stats.backend },
-                    { metric: 'Version', value: stats.version },
-                    { metric: 'Total Entries', value: stats.entries.total.toLocaleString() },
-                    { metric: 'Total Storage', value: stats.storage.total },
-                    { metric: 'Location', value: stats.storage.location }
-                ]
-            });
-            output.writeln();
-            output.writeln(output.bold('Timeline'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 20 },
-                    { key: 'value', header: 'Value', width: 30, align: 'right' }
-                ],
-                data: [
-                    { metric: 'Oldest Entry', value: stats.oldestEntry || 'N/A' },
-                    { metric: 'Newest Entry', value: stats.newestEntry || 'N/A' }
-                ]
-            });
-            output.writeln();
-            output.printInfo('v1 Performance: O(log n) pure-JS HNSW vector search');
-            return { success: true, data: stats };
-        }
-        catch (error) {
-            output.printError(`Failed to get stats: ${error instanceof Error ? error.message : 'Unknown error'}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Configure command
-const configureCommand = {
-    name: 'configure',
-    aliases: ['config'],
-    description: 'Configure memory backend',
-    options: [
-        {
-            name: 'backend',
-            short: 'b',
-            description: 'Memory backend',
-            type: 'string',
-            choices: BACKENDS.map(b => b.value)
-        },
-        {
-            name: 'path',
-            description: 'Storage path',
-            type: 'string'
-        },
-        {
-            name: 'cache-size',
-            description: 'Cache size in MB',
-            type: 'number'
-        },
-        {
-            name: 'hnsw-m',
-            description: 'HNSW M parameter',
-            type: 'number',
-            default: 16
-        },
-        {
-            name: 'hnsw-ef',
-            description: 'HNSW ef parameter',
-            type: 'number',
-            default: 200
-        }
-    ],
-    action: async (ctx) => {
-        let backend = ctx.flags.backend;
-        if (!backend && ctx.interactive) {
-            backend = await select({
-                message: 'Select memory backend:',
-                options: BACKENDS,
-                default: 'hybrid'
-            });
-        }
-        const config = {
-            backend: backend || 'hybrid',
-            path: ctx.flags.path || './data/memory',
-            cacheSize: ctx.flags['cache-size'] || 256,
-            hnsw: {
-                m: ctx.flags['hnsw-m'] || 16,
-                ef: ctx.flags['hnsw-ef'] || 200
-            }
-        };
-        output.writeln();
-        output.printInfo('Memory Configuration');
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'setting', header: 'Setting', width: 20 },
-                { key: 'value', header: 'Value', width: 25 }
-            ],
-            data: [
-                { setting: 'Backend', value: config.backend },
-                { setting: 'Storage Path', value: config.path },
-                { setting: 'Cache Size', value: `${config.cacheSize} MB` },
-                { setting: 'HNSW M', value: config.hnsw.m },
-                { setting: 'HNSW ef', value: config.hnsw.ef }
-            ]
-        });
-        output.writeln();
-        configManager.set(ctx.cwd, 'memory', config);
-        output.printSuccess('Memory configuration updated');
-        return { success: true, data: config };
-    }
-};
-// Cleanup command
-const cleanupCommand = {
-    name: 'cleanup',
-    description: 'Clean up stale and expired memory entries',
-    options: [
-        {
-            name: 'dry-run',
-            short: 'd',
-            description: 'Show what would be deleted',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'older-than',
-            short: 'o',
-            description: 'Delete entries older than (e.g., "7d", "30d")',
-            type: 'string'
-        },
-        {
-            name: 'expired-only',
-            short: 'e',
-            description: 'Only delete expired TTL entries',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'low-quality',
-            short: 'l',
-            description: 'Delete low quality patterns (threshold)',
-            type: 'number'
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Clean specific namespace only',
-            type: 'string'
-        },
-        {
-            name: 'force',
-            short: 'f',
-            description: 'Skip confirmation',
-            type: 'boolean',
-            default: false
-        }
-    ],
-    examples: [
-        { command: 'monomind memory cleanup --dry-run', description: 'Preview cleanup' },
-        { command: 'monomind memory cleanup --older-than 30d', description: 'Delete entries older than 30 days' },
-        { command: 'monomind memory cleanup --expired-only', description: 'Clean expired entries' }
-    ],
-    action: async (ctx) => {
-        const dryRun = ctx.flags['dry-run'];
-        const force = ctx.flags.force;
-        if (dryRun) {
-            output.writeln(output.warning('DRY RUN - No changes will be made'));
-        }
-        output.printInfo('Analyzing memory for cleanup...');
-        try {
-            const result = await callMCPTool('memory_cleanup', {
-                dryRun,
-                olderThan: ctx.flags['older-than'],
-                expiredOnly: ctx.flags['expired-only'],
-                lowQualityThreshold: ctx.flags['low-quality'],
-                namespace: ctx.flags.namespace,
-            });
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Cleanup Analysis'));
-            output.printTable({
-                columns: [
-                    { key: 'category', header: 'Category', width: 20 },
-                    { key: 'count', header: 'Count', width: 15, align: 'right' }
-                ],
-                data: [
-                    { category: 'Expired (TTL)', count: result.candidates.expired },
-                    { category: 'Stale (unused)', count: result.candidates.stale },
-                    { category: 'Low Quality', count: result.candidates.lowQuality },
-                    { category: output.bold('Total'), count: output.bold(String(result.candidates.total)) }
-                ]
-            });
-            if (!dryRun && result.candidates.total > 0 && !force) {
-                const confirmed = await confirm({
-                    message: `Delete ${result.candidates.total} entries (${result.freed.formatted})?`,
-                    default: false
-                });
-                if (!confirmed) {
-                    output.printInfo('Cleanup cancelled');
-                    return { success: true, data: result };
-                }
-            }
-            if (!dryRun) {
-                output.writeln();
-                output.printSuccess(`Cleaned ${result.deleted.entries} entries`);
-                output.printList([
-                    `Vectors removed: ${result.deleted.vectors}`,
-                    `Patterns removed: ${result.deleted.patterns}`,
-                    `Space freed: ${result.freed.formatted}`,
-                    `Duration: ${result.duration}ms`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Cleanup error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Compress command
-const compressCommand = {
-    name: 'compress',
-    description: 'Compress and optimize memory storage',
-    options: [
-        {
-            name: 'level',
-            short: 'l',
-            description: 'Compression level (fast, balanced, max)',
-            type: 'string',
-            choices: ['fast', 'balanced', 'max'],
-            default: 'balanced'
-        },
-        {
-            name: 'target',
-            short: 't',
-            description: 'Target (vectors, text, patterns, all)',
-            type: 'string',
-            choices: ['vectors', 'text', 'patterns', 'all'],
-            default: 'all'
-        },
-        {
-            name: 'quantize',
-            short: 'z',
-            description: 'Enable vector quantization (reduces memory 4-32x)',
-            type: 'boolean',
-            default: false
-        },
-        {
-            name: 'bits',
-            description: 'Quantization bits (4, 8, 16)',
-            type: 'number',
-            default: 8
-        },
-        {
-            name: 'rebuild-index',
-            short: 'r',
-            description: 'Rebuild HNSW index after compression',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    examples: [
-        { command: 'monomind memory compress', description: 'Balanced compression' },
-        { command: 'monomind memory compress --quantize --bits 4', description: '4-bit quantization (32x reduction)' },
-        { command: 'monomind memory compress -l max -t vectors', description: 'Max compression on vectors' }
-    ],
-    action: async (ctx) => {
-        const level = ctx.flags.level || 'balanced';
-        const target = ctx.flags.target || 'all';
-        const quantize = ctx.flags.quantize;
-        const bits = ctx.flags.bits || 8;
-        const rebuildIndex = ctx.flags.rebuildIndex ?? true;
-        output.writeln();
-        output.writeln(output.bold('Memory Compression'));
-        output.writeln(output.dim(`Level: ${level}, Target: ${target}, Quantize: ${quantize ? `${bits}-bit` : 'no'}`));
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Analyzing current storage...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const result = await callMCPTool('memory_compress', {
-                level,
-                target,
-                quantize,
-                bits,
-                rebuildIndex,
-            });
-            spinner.succeed('Compression complete');
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-                return { success: true, data: result };
-            }
-            output.writeln();
-            output.writeln(output.bold('Storage Comparison'));
-            output.printTable({
-                columns: [
-                    { key: 'category', header: 'Category', width: 15 },
-                    { key: 'before', header: 'Before', width: 12, align: 'right' },
-                    { key: 'after', header: 'After', width: 12, align: 'right' },
-                    { key: 'saved', header: 'Saved', width: 12, align: 'right' }
-                ],
-                data: [
-                    { category: 'Vectors', before: result.before.vectorsSize, after: result.after.vectorsSize, saved: '-' },
-                    { category: 'Text', before: result.before.textSize, after: result.after.textSize, saved: '-' },
-                    { category: 'Patterns', before: result.before.patternsSize, after: result.after.patternsSize, saved: '-' },
-                    { category: 'Index', before: result.before.indexSize, after: result.after.indexSize, saved: '-' },
-                    { category: output.bold('Total'), before: result.before.totalSize, after: result.after.totalSize, saved: output.success(result.compression.formattedSaved) }
-                ]
-            });
-            output.writeln();
-            output.printBox([
-                `Compression Ratio: ${result.compression.ratio.toFixed(2)}x`,
-                `Space Saved: ${result.compression.formattedSaved}`,
-                `Quantization: ${result.compression.quantizationApplied ? `Yes (${bits}-bit)` : 'No'}`,
-                `Index Rebuilt: ${result.compression.indexRebuilt ? 'Yes' : 'No'}`,
-                `Duration: ${(result.duration / 1000).toFixed(1)}s`
-            ].join('\n'), 'Results');
-            if (result.performance) {
-                output.writeln();
-                output.writeln(output.bold('Performance Impact'));
-                output.printList([
-                    `Search latency: ${result.performance.searchLatencyBefore.toFixed(2)}ms → ${result.performance.searchLatencyAfter.toFixed(2)}ms`,
-                    `Speedup: ${output.success(result.performance.searchSpeedup)}`
-                ]);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Compression failed');
-            if (error instanceof MCPClientError) {
-                output.printError(`Compression error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Export command
-const exportCommand = {
-    name: 'export',
-    description: 'Export memory to file',
-    options: [
-        {
-            name: 'output',
-            short: 'o',
-            description: 'Output file path',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'format',
-            short: 'f',
-            description: 'Export format (json, csv, binary, okf)',
-            type: 'string',
-            choices: ['json', 'csv', 'binary', 'okf'],
-            default: 'json'
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Export specific namespace',
-            type: 'string'
-        },
-        {
-            name: 'include-vectors',
-            description: 'Include vector embeddings',
-            type: 'boolean',
-            default: true
-        }
-    ],
-    examples: [
-        { command: 'monomind memory export -o ./backup.json', description: 'Export all to JSON' },
-        { command: 'monomind memory export -o ./data.csv -f csv', description: 'Export to CSV' },
-        { command: 'monomind memory export -o ./knowledge -f okf', description: 'Export as OKF bundle (directory of .md files)' }
-    ],
-    action: async (ctx) => {
-        const outputPath = ctx.flags.output;
-        const format = ctx.flags.format || 'json';
-        if (!outputPath) {
-            output.printError('Output path is required. Use --output or -o');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Exporting memory to ${outputPath}...`);
-        // OKF bundle: native export — directory of .md files with YAML frontmatter
-        if (format === 'okf') {
-            try {
-                const fs = await import('fs');
-                const path = await import('path');
-                const { listEntries, getEntry } = await import('../memory/memory-initializer.js');
-                const namespace = ctx.flags.namespace;
-                const listed = await listEntries({ namespace, limit: 10000 });
-                if (!listed.success) {
-                    output.printError(`Failed to list entries: ${listed.error}`);
-                    return { success: false, exitCode: 1 };
-                }
-                let written = 0;
-                for (const entry of listed.entries) {
-                    const got = await getEntry({ key: entry.key, namespace: entry.namespace });
-                    if (!got.found || !got.entry)
-                        continue;
-                    const { key, namespace: ns, content, tags, createdAt } = got.entry;
-                    const safeKey = key.replace(/[/\\:*?"<>|]/g, '-');
-                    const dir = path.join(outputPath, ns);
-                    fs.mkdirSync(dir, { recursive: true });
-                    const yamlEscape = (s) => s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-                    const tagsLine = tags.length > 0 ? `tags: [${tags.join(', ')}]\n` : '';
-                    const md = `---\ntype: Memory\nkey: "${yamlEscape(key)}"\nnamespace: "${yamlEscape(ns)}"\n${tagsLine}timestamp: ${createdAt}\n---\n\n${content}`;
-                    fs.writeFileSync(path.join(dir, `${safeKey}.md`), md, 'utf-8');
-                    written++;
-                }
-                output.printSuccess(`Exported ${written} entries to ${outputPath}`);
-                if (listed.total > 10000) {
-                    output.printInfo(`Note: only first 10000 of ${listed.total} entries exported`);
-                }
-                return { success: true, data: { written, outputPath } };
-            }
-            catch (error) {
-                output.printError(`OKF export error: ${String(error)}`);
-                return { success: false, exitCode: 1 };
-            }
-        }
-        try {
-            const result = await callMCPTool('memory_export', {
-                outputPath,
-                format,
-                namespace: ctx.flags.namespace,
-                includeVectors: ctx.flags.includeVectors ?? true,
-            });
-            output.printSuccess(`Exported to ${result.outputPath}`);
-            output.printList([
-                `Entries: ${result.exported.entries}`,
-                `Vectors: ${result.exported.vectors}`,
-                `Patterns: ${result.exported.patterns}`,
-                `File size: ${result.fileSize}`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Export error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
-// Import command
-const importCommand = {
-    name: 'import',
-    description: 'Import memory from file',
-    options: [
-        {
-            name: 'input',
-            short: 'i',
-            description: 'Input file path',
-            type: 'string',
-            required: true
-        },
-        {
-            name: 'merge',
-            short: 'm',
-            description: 'Merge with existing (skip duplicates)',
-            type: 'boolean',
-            default: true
-        },
-        {
-            name: 'namespace',
-            short: 'n',
-            description: 'Import into specific namespace',
-            type: 'string'
-        }
-    ],
-    examples: [
-        { command: 'monomind memory import -i ./backup.json', description: 'Import from file' },
-        { command: 'monomind memory import -i ./data.json -n archive', description: 'Import to namespace' }
-    ],
-    action: async (ctx) => {
-        const inputPath = ctx.flags.input || ctx.args[0];
-        if (!inputPath) {
-            output.printError('Input path is required. Use --input or -i');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Importing memory from ${inputPath}...`);
-        // OKF bundle: native import — detect directory of .md files with YAML frontmatter
-        const fsCheck = await import('fs');
-        const isDir = fsCheck.existsSync(inputPath) && fsCheck.statSync(inputPath).isDirectory();
-        if (isDir) {
-            try {
-                const fs = await import('fs');
-                const path = await import('path');
-                const { storeEntry } = await import('../memory/memory-initializer.js');
-                function parseOkfFrontmatter(raw) {
-                    if (!raw.startsWith('---\n'))
-                        return { meta: {}, body: raw };
-                    const end = raw.indexOf('\n---\n', 4);
-                    if (end === -1)
-                        return { meta: {}, body: raw };
-                    const meta = {};
-                    for (const line of raw.slice(4, end).split('\n')) {
-                        const colon = line.indexOf(':');
-                        if (colon <= 0)
-                            continue;
-                        const k = line.slice(0, colon).trim();
-                        const rawV = line.slice(colon + 1).trim();
-                        const isQuoted = rawV.startsWith('"') && rawV.endsWith('"') && rawV.length >= 2;
-                        const v = isQuoted ? rawV.slice(1, -1).replace(/\\(["\\])/g, '$1') : rawV;
-                        if (v.startsWith('[') && v.endsWith(']')) {
-                            meta[k] = v.slice(1, -1).split(',').map(s => s.trim()).filter(Boolean);
-                        }
-                        else {
-                            meta[k] = v;
-                        }
-                    }
-                    return { meta, body: raw.slice(end + 5) };
-                }
-                function findMdFiles(dir) {
-                    const results = [];
-                    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-                        const full = path.join(dir, entry.name);
-                        if (entry.isDirectory())
-                            results.push(...findMdFiles(full));
-                        else if (entry.name.endsWith('.md'))
-                            results.push(full);
-                    }
-                    return results;
-                }
-                const overrideNs = ctx.flags.namespace;
-                const merge = ctx.flags.merge ?? true;
-                const files = findMdFiles(inputPath);
-                let imported = 0, skipped = 0;
-                const start = Date.now();
-                for (const file of files) {
-                    const raw = fs.readFileSync(file, 'utf-8');
-                    const { meta, body } = parseOkfFrontmatter(raw);
-                    const key = meta['key'] || path.basename(file, '.md');
-                    const ns = overrideNs || meta['namespace'] || path.basename(path.dirname(file));
-                    const tags = Array.isArray(meta['tags']) ? meta['tags'] : meta['tags'] ? [meta['tags']] : [];
-                    const result = await storeEntry({ key, value: body.trim(), namespace: ns, tags, upsert: !merge });
-                    if (result.success)
-                        imported++;
-                    else
-                        skipped++;
-                }
-                output.printSuccess(`Imported ${imported} entries from ${inputPath}`);
-                if (skipped > 0)
-                    output.printInfo(`Skipped ${skipped} entries (duplicates or errors)`);
-                output.printInfo(`Duration: ${Date.now() - start}ms`);
-                return { success: true, data: { imported, skipped } };
-            }
-            catch (error) {
-                output.printError(`OKF import error: ${String(error)}`);
-                return { success: false, exitCode: 1 };
-            }
-        }
-        try {
-            const result = await callMCPTool('memory_import', {
-                inputPath,
-                merge: ctx.flags.merge ?? true,
-                namespace: ctx.flags.namespace,
-            });
-            output.printSuccess(`Imported from ${result.inputPath}`);
-            output.printList([
-                `Entries: ${result.imported.entries}`,
-                `Vectors: ${result.imported.vectors}`,
-                `Patterns: ${result.imported.patterns}`,
-                `Skipped (duplicates): ${result.skipped}`,
-                `Duration: ${result.duration}ms`
-            ]);
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Import error: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
-            }
-            return { success: false, exitCode: 1 };
-        }
-    }
-};
+import { storeCommand, retrieveCommand, searchCommand } from './memory-crud.js';
+import { listCommand, editCommand, templatesCommand } from './memory-list.js';
+import { deleteCommand, statsCommand, configureCommand, cleanupCommand } from './memory-admin.js';
+import { compressCommand, exportCommand, importCommand } from './memory-transfer.js';
 // Init subcommand - initialize memory database using sql.js
 const initMemoryCommand = {
     name: 'init',