monomind 1.18.13 → 1.19.0

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

@@ -1,128 +1,8 @@
 /**
  * Memory Transfer Commands
- * compressCommand, exportCommand, importCommand
+ * exportCommand, importCommand
  */
 import { output } from '../output.js';
-import { callMCPTool, MCPClientError } from '../mcp-client.js';
-// Compress command
-export 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
 export const exportCommand = {
     name: 'export',
@@ -207,31 +87,8 @@ export const exportCommand = {
                 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 };
-        }
+        output.printError(`Unsupported export format: ${format}. Use --format okf for file-based export.`);
+        return { success: false, exitCode: 1 };
     }
 };
 // Import command
@@ -342,31 +199,8 @@ export const importCommand = {
                 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 };
-        }
+        output.printError(`Unsupported import format. Provide a directory of .md files (OKF bundle) for file-based import.`);
+        return { success: false, exitCode: 1 };
     }
 };
 //# sourceMappingURL=memory-transfer.js.map

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

@@ -11,8 +11,8 @@
 import { output } from '../output.js';
 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';
+import { deleteCommand, statsCommand, configureCommand } from './memory-admin.js';
+import { exportCommand, importCommand } from './memory-transfer.js';
 // Init subcommand - initialize memory database using sql.js
 const initMemoryCommand = {
     name: 'init',
@@ -209,7 +209,6 @@ const initMemoryCommand = {
             output.printList([
                 `Store data: ${output.highlight('monomind memory store -k "key" --value "data"')}`,
                 `Search: ${output.highlight('monomind memory search -q "query"')}`,
-                `Train patterns: ${output.highlight('monomind neural train -p coordination')}`,
                 `View stats: ${output.highlight('monomind memory stats')}`
             ]);
             // Also sync to .claude directory
@@ -248,7 +247,7 @@ const initMemoryCommand = {
 export const memoryCommand = {
     name: 'memory',
     description: 'Memory management commands',
-    subcommands: [initMemoryCommand, storeCommand, editCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, templatesCommand, statsCommand, configureCommand, cleanupCommand, compressCommand, exportCommand, importCommand],
+    subcommands: [initMemoryCommand, storeCommand, editCommand, retrieveCommand, searchCommand, listCommand, deleteCommand, templatesCommand, statsCommand, configureCommand, exportCommand, importCommand],
     options: [],
     examples: [
         { command: 'monomind memory store -k "key" -v "value"', description: 'Store data' },
@@ -273,8 +272,6 @@ export const memoryCommand = {
             `${output.highlight('templates')}   - Show best-practice entry templates`,
             `${output.highlight('stats')}       - Show statistics`,
             `${output.highlight('configure')}   - Configure backend`,
-            `${output.highlight('cleanup')}     - Clean expired entries`,
-            `${output.highlight('compress')}    - Compress database`,
             `${output.highlight('export')}      - Export memory to file`,
             `${output.highlight('import')}      - Import from file`
         ]);

package/packages/@monomind/cli/dist/src/commands/neural-core.d.ts

@@ -1,8 +1,10 @@
 /**
- * Neural core commands — status, patterns, predict
+ * Neural core commands — train, status, patterns, predict
+ * Pattern storage and similarity search (no ML/neural-network training)
  */
 import type { Command } from '../types.js';
 export declare const statusCommand: Command;
 export declare const patternsCommand: Command;
+export declare const trainCommand: Command;
 export declare const predictCommand: Command;
 //# sourceMappingURL=neural-core.d.ts.map

package/packages/@monomind/cli/dist/src/commands/neural-core.js

@@ -1,11 +1,12 @@
 /**
- * Neural core commands — status, patterns, predict
+ * Neural core commands — train, status, patterns, predict
+ * Pattern storage and similarity search (no ML/neural-network training)
  */
 import { output } from '../output.js';
 // ─── status subcommand ───────────────────────────────────────────────────────
 export const statusCommand = {
     name: 'status',
-    description: 'Check pattern-learning status (JS intelligence layer)',
+    description: 'Check pattern storage and similarity search status',
     options: [
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
     ],
@@ -96,7 +97,7 @@ export const statusCommand = {
 // ─── patterns subcommand ─────────────────────────────────────────────────────
 export const patternsCommand = {
     name: 'patterns',
-    description: 'Analyze and manage cognitive patterns',
+    description: 'List and search stored patterns',
     options: [
         { name: 'action', short: 'a', type: 'string', description: 'Action: analyze, learn, predict, list', default: 'list' },
         { name: 'query', short: 'q', type: 'string', description: 'Pattern query for search' },
@@ -188,10 +189,148 @@ export const patternsCommand = {
         }
     },
 };
+// ─── train subcommand ───────────────────────────────────────────────────────
+export const trainCommand = {
+    name: 'train',
+    description: 'Ingest outcome and edit history into the pattern store for routing optimization',
+    options: [
+        { name: 'pattern-type', short: 't', type: 'string', description: 'Pattern type label (e.g. general, security, refactor)', default: 'general' },
+        { name: 'verbose', short: 'v', type: 'boolean', description: 'Show each ingested pattern' },
+    ],
+    examples: [
+        { command: 'monomind neural train', description: 'Ingest outcomes and edits into pattern store' },
+        { command: 'monomind neural train -t security -v', description: 'Ingest with type label, verbose' },
+    ],
+    action: async (ctx) => {
+        const patternType = ctx.flags['pattern-type'] || 'general';
+        const verbose = ctx.flags.verbose === true;
+        output.writeln();
+        output.writeln(output.bold('Pattern Store — Train'));
+        output.writeln(output.dim('Reads outcome/edit history and stores patterns for routing'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Initializing intelligence layer...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const crypto = await import('crypto');
+            const { initializeIntelligence, getReasoningBank, flushPatterns, getIntelligenceStats } = await import('../memory/intelligence.js');
+            await initializeIntelligence();
+            const bank = getReasoningBank();
+            if (!bank) {
+                spinner.fail('ReasoningBank not available');
+                return { success: false, exitCode: 1 };
+            }
+            const dataDir = path.join(process.cwd(), '.monomind', 'data');
+            const outcomesFile = path.join(dataDir, 'intelligence-outcomes.jsonl');
+            const editsFile = path.join(dataDir, 'recent-edits.jsonl');
+            let stored = 0;
+            const MAX_FILE_BYTES = 50 * 1024 * 1024;
+            // Helper: read a JSONL file safely, return parsed lines
+            const readJsonl = (filePath) => {
+                if (!fs.existsSync(filePath))
+                    return [];
+                const stat = fs.statSync(filePath);
+                if (stat.size > MAX_FILE_BYTES) {
+                    output.writeln(output.warning(`Skipping ${path.basename(filePath)}: too large (${stat.size} bytes)`));
+                    return [];
+                }
+                const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(l => l.trim());
+                const results = [];
+                for (const line of lines) {
+                    try {
+                        const obj = JSON.parse(line);
+                        if (obj && typeof obj === 'object' && !('__proto__' in obj)) {
+                            results.push(obj);
+                        }
+                    }
+                    catch {
+                        // skip malformed lines
+                    }
+                }
+                return results;
+            };
+            // --- 1. Ingest intelligence-outcomes.jsonl (successful outcomes) ---
+            spinner.setText('Reading intelligence outcomes...');
+            const outcomes = readJsonl(outcomesFile);
+            const successOutcomes = outcomes.filter(o => o.success === true || o.verdict === 'success');
+            for (const outcome of successOutcomes) {
+                const content = (outcome.description || outcome.task || outcome.content || outcome.command || '');
+                if (!content || typeof content !== 'string' || content.length > 4096)
+                    continue;
+                const id = `outcome_${crypto.createHash('sha256').update(content).digest('hex').substring(0, 16)}`;
+                bank.store({
+                    id,
+                    type: patternType,
+                    content,
+                    confidence: typeof outcome.confidence === 'number' ? outcome.confidence : 0.8,
+                    embedding: [],
+                    metadata: { source: 'intelligence-outcomes', originalType: outcome.type },
+                });
+                stored++;
+                if (verbose)
+                    output.writeln(output.dim(`  + ${id}: ${content.substring(0, 60)}`));
+            }
+            // --- 2. Ingest recent-edits.jsonl (edit history) ---
+            spinner.setText('Reading edit history...');
+            const edits = readJsonl(editsFile);
+            for (const edit of edits) {
+                const file = (edit.file || edit.path || '');
+                const operation = (edit.operation || edit.action || 'edit');
+                if (!file || typeof file !== 'string')
+                    continue;
+                const content = `${operation}: ${file}`;
+                const id = `edit_${crypto.createHash('sha256').update(content + String(edit.timestamp || '')).digest('hex').substring(0, 16)}`;
+                bank.store({
+                    id,
+                    type: patternType,
+                    content,
+                    confidence: 0.7,
+                    embedding: [],
+                    metadata: { source: 'recent-edits', file, operation },
+                });
+                stored++;
+                if (verbose)
+                    output.writeln(output.dim(`  + ${id}: ${content.substring(0, 60)}`));
+            }
+            // --- 3. Flush to disk ---
+            spinner.setText('Persisting patterns...');
+            flushPatterns();
+            const stats = getIntelligenceStats();
+            spinner.succeed(`Stored ${stored} patterns from outcome/edit history`);
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 28 },
+                    { key: 'value', header: 'Value', width: 20 },
+                ],
+                data: [
+                    { metric: 'Outcomes Ingested', value: String(successOutcomes.length) },
+                    { metric: 'Edits Ingested', value: String(edits.length) },
+                    { metric: 'Patterns Stored', value: String(stored) },
+                    { metric: 'Total Patterns (bank)', value: String(stats.patternsLearned) },
+                    { metric: 'Pattern Type', value: patternType },
+                ],
+            });
+            if (stored === 0) {
+                output.writeln();
+                output.writeln(output.dim('No data found to ingest. Patterns are stored as you work:'));
+                output.writeln(output.dim('  - Outcomes: .monomind/data/intelligence-outcomes.jsonl'));
+                output.writeln(output.dim('  - Edits:    .monomind/data/recent-edits.jsonl'));
+            }
+            return { success: true, data: { stored, outcomes: successOutcomes.length, edits: edits.length } };
+        }
+        catch (error) {
+            spinner.fail('Training failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
+};
 // ─── predict subcommand ──────────────────────────────────────────────────────
 export const predictCommand = {
     name: 'predict',
-    description: 'Make AI predictions using trained models',
+    description: 'Find similar patterns by similarity search',
     options: [
         { name: 'input', short: 'i', type: 'string', description: 'Input text to predict routing for', required: true },
         { name: 'k', short: 'k', type: 'number', description: 'Number of top predictions', default: '5' },
@@ -210,9 +349,9 @@ export const predictCommand = {
             return { success: false, exitCode: 1 };
         }
         output.writeln();
-        output.writeln(output.bold('Neural Prediction (Real)'));
+        output.writeln(output.bold('Pattern Similarity Search'));
         output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Running inference...', spinner: 'dots' });
+        const spinner = output.createSpinner({ text: 'Searching patterns...', spinner: 'dots' });
         spinner.start();
         try {
             const { initializeIntelligence, findSimilarPatterns } = await import('../memory/intelligence.js');

package/packages/@monomind/cli/dist/src/commands/neural-optimize.js

@@ -5,7 +5,7 @@ import { output } from '../output.js';
 // ─── optimize subcommand ─────────────────────────────────────────────────────
 export const optimizeCommand = {
     name: 'optimize',
-    description: 'Optimize neural patterns (Int8 quantization, memory compression)',
+    description: 'Optimize pattern storage (Int8 quantization, memory compression)',
     options: [
         { name: 'method', type: 'string', description: 'Method: quantize, analyze, compact', default: 'quantize' },
         { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
@@ -138,7 +138,7 @@ export const optimizeCommand = {
 // ─── export subcommand ───────────────────────────────────────────────────────
 export const exportCommand = {
     name: 'export',
-    description: 'Export trained models to IPFS for sharing (Ed25519 signed)',
+    description: 'Export stored patterns to IPFS for sharing (Ed25519 signed)',
     options: [
         { name: 'model', short: 'm', type: 'string', description: 'Model ID or category to export' },
         { name: 'output', short: 'o', type: 'string', description: 'Output file path (optional)' },
@@ -159,7 +159,7 @@ export const exportCommand = {
         const stripPii = ctx.flags['strip-pii'] !== false;
         const customName = ctx.flags.name;
         output.writeln();
-        output.writeln(output.bold('Secure Model Export'));
+        output.writeln(output.bold('Secure Pattern Export'));
         output.writeln(output.dim('─'.repeat(50)));
         const spinner = output.createSpinner({ text: 'Preparing export...', spinner: 'dots' });
         spinner.start();
@@ -167,7 +167,7 @@ export const exportCommand = {
             const fs = await import('fs');
             const path = await import('path');
             const crypto = await import('crypto');
-            spinner.setText('Collecting trained patterns...');
+            spinner.setText('Collecting stored patterns...');
             const { getIntelligenceStats, flushPatterns } = await import('../memory/intelligence.js');
             await flushPatterns();
             const stats = await getIntelligenceStats();

package/packages/@monomind/cli/dist/src/commands/neural-registry.d.ts

@@ -1,5 +1,5 @@
 /**
- * Neural registry commands — list and import models from IPFS
+ * Neural registry commands — list and import pattern sets from IPFS
  */
 import type { Command } from '../types.js';
 export declare const listCommand: Command;

package/packages/@monomind/cli/dist/src/commands/neural-registry.js

@@ -1,11 +1,11 @@
 /**
- * Neural registry commands — list and import models from IPFS
+ * Neural registry commands — list and import pattern sets from IPFS
  */
 import { output } from '../output.js';
 // ─── list subcommand ─────────────────────────────────────────────────────────
 export const listCommand = {
     name: 'list',
-    description: 'List available pre-trained models from the official registry',
+    description: 'List available pattern sets from the official registry',
     options: [
         { name: 'category', type: 'string', description: 'Filter by category (security, quality, performance, etc.)' },
         { name: 'format', short: 'f', type: 'string', description: 'Output format: table, json, simple', default: 'table' },
@@ -115,7 +115,7 @@ export const listCommand = {
 // ─── import subcommand ───────────────────────────────────────────────────────
 export const importCommand = {
     name: 'import',
-    description: 'Import trained models from IPFS with signature verification',
+    description: 'Import pattern sets from IPFS with signature verification',
     options: [
         { name: 'cid', short: 'c', type: 'string', description: 'IPFS CID to import from' },
         { name: 'file', short: 'f', type: 'string', description: 'Local file to import' },
@@ -139,7 +139,7 @@ export const importCommand = {
             return { success: false, exitCode: 1 };
         }
         output.writeln();
-        output.writeln(output.bold('Secure Model Import'));
+        output.writeln(output.bold('Secure Pattern Import'));
         output.writeln(output.dim('─'.repeat(50)));
         const spinner = output.createSpinner({ text: 'Fetching model...', spinner: 'dots' });
         spinner.start();

package/packages/@monomind/cli/dist/src/commands/neural.d.ts

@@ -1,6 +1,6 @@
 /**
  * CLI Neural Command
- * Pattern learning, search, and prediction backed by the pure-JS intelligence layer
+ * Pattern storage and similarity search for routing optimization
  *
  * github.com/monoes/monomind
  */

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

@@ -1,17 +1,17 @@
 /**
  * CLI Neural Command
- * Pattern learning, search, and prediction backed by the pure-JS intelligence layer
+ * Pattern storage and similarity search for routing optimization
  *
  * github.com/monoes/monomind
  */
 import { output } from '../output.js';
-import { statusCommand, patternsCommand, predictCommand } from './neural-core.js';
+import { statusCommand, patternsCommand, trainCommand, predictCommand } from './neural-core.js';
 import { optimizeCommand, exportCommand } from './neural-optimize.js';
 import { listCommand, importCommand } from './neural-registry.js';
 export const neuralCommand = {
     name: 'neural',
-    description: 'Pattern learning, search, and prediction (pure-JS intelligence layer)',
-    subcommands: [statusCommand, patternsCommand, predictCommand, optimizeCommand, listCommand, exportCommand, importCommand],
+    description: 'Store and query edit patterns for routing optimization',
+    subcommands: [trainCommand, statusCommand, patternsCommand, predictCommand, optimizeCommand, listCommand, exportCommand, importCommand],
     examples: [
         { command: 'monomind neural status', description: 'Check pattern-learning system status' },
         { command: 'monomind neural patterns --action list', description: 'List learned patterns' },
@@ -19,8 +19,8 @@ export const neuralCommand = {
     ],
     action: async () => {
         output.writeln();
-        output.writeln(output.bold('MonoMind Pattern Learning'));
-        output.writeln(output.dim('Pattern learning, search, and prediction (pure-JS)'));
+        output.writeln(output.bold('MonoMind Pattern Storage'));
+        output.writeln(output.dim('Store and query edit patterns for routing optimization'));
         output.writeln();
         output.writeln('Use --help with subcommands for more info');
         output.writeln();