monomind 1.17.0 → 1.17.2

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

@@ -0,0 +1,342 @@
+/**
+ * Memory CRUD Commands
+ * store, retrieve, search
+ */
+import { output } from '../output.js';
+import { input } from '../prompt.js';
+// Store command
+export 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
+export 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
+export 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 };
+        }
+    }
+};
+//# sourceMappingURL=memory-crud.js.map

package/packages/@monomind/cli/dist/src/commands/memory-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Memory List Commands
+ * formatRelativeTime, listCommand, editCommand, templatesCommand
+ */
+import type { Command } from '../types.js';
+export declare function formatRelativeTime(isoDate: string): string;
+export declare const listCommand: Command;
+export declare const editCommand: Command;
+export declare const templatesCommand: Command;
+//# sourceMappingURL=memory-list.d.ts.map

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

@@ -0,0 +1,321 @@
+/**
+ * Memory List Commands
+ * formatRelativeTime, listCommand, editCommand, templatesCommand
+ */
+import { output } from '../output.js';
+import { input } from '../prompt.js';
+// Helper function to format relative time
+export 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';
+}
+// List command
+export 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 };
+        }
+    }
+};
+// Edit command
+export 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
+export 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 };
+    }
+};
+//# sourceMappingURL=memory-list.js.map

package/packages/@monomind/cli/dist/src/commands/memory-transfer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Memory Transfer Commands
+ * compressCommand, exportCommand, importCommand
+ */
+import type { Command } from '../types.js';
+export declare const compressCommand: Command;
+export declare const exportCommand: Command;
+export declare const importCommand: Command;
+//# sourceMappingURL=memory-transfer.d.ts.map