monomind 1.17.0 → 1.17.1

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

@@ -5,980 +5,9 @@
  * github.com/monoes/monomind
  */
 import { output } from '../output.js';
-// Status subcommand - reports only the surviving pure-JS pattern-learning layer
-const statusCommand = {
-    name: 'status',
-    description: 'Check pattern-learning status (JS intelligence layer)',
-    options: [
-        { name: 'verbose', short: 'v', type: 'boolean', description: 'Show detailed metrics' },
-    ],
-    examples: [
-        { command: 'monomind neural status', description: 'Show pattern-learning status' },
-        { command: 'monomind neural status -v', description: 'Show detailed metrics' },
-    ],
-    action: async (ctx) => {
-        const verbose = ctx.flags.verbose === true;
-        output.writeln();
-        output.writeln(output.bold('Pattern Learning Status'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Checking pattern-learning systems...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const { getIntelligenceStats, initializeIntelligence, getPersistenceStatus } = await import('../memory/intelligence.js');
-            const { getHNSWStatus, loadEmbeddingModel } = await import('../memory/memory-initializer.js');
-            // Initialize if needed and get real stats
-            await initializeIntelligence();
-            const stats = getIntelligenceStats();
-            const hnswStatus = getHNSWStatus();
-            const persistence = getPersistenceStatus();
-            // Check embedding model
-            const modelInfo = await loadEmbeddingModel({ verbose: false });
-            spinner.succeed('Pattern-learning systems checked');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'component', header: 'Component', width: 22 },
-                    { key: 'status', header: 'Status', width: 12 },
-                    { key: 'details', header: 'Details', width: 34 },
-                ],
-                data: [
-                    {
-                        component: 'Pattern Learning',
-                        status: stats.sonaEnabled ? output.success('Active') : output.warning('Inactive'),
-                        details: stats.sonaEnabled ? 'JS pattern-learning layer initialized' : 'Not initialized',
-                    },
-                    {
-                        component: 'ReasoningBank',
-                        status: stats.reasoningBankSize > 0 ? output.success('Active') : output.dim('Empty'),
-                        details: `${stats.patternsLearned} patterns stored`,
-                    },
-                    {
-                        component: 'Pattern Index',
-                        status: hnswStatus.available ? output.success('Ready') : output.dim('Empty'),
-                        details: hnswStatus.available
-                            ? `${hnswStatus.entryCount} vectors, ${hnswStatus.dimensions}-dim (ANN via LanceDB)`
-                            : 'No vectors indexed yet',
-                    },
-                    {
-                        component: 'Embedding Model',
-                        status: modelInfo.success ? output.success('Loaded') : output.warning('Fallback'),
-                        details: `${modelInfo.modelName} (${modelInfo.dimensions}-dim)`,
-                    },
-                    {
-                        component: 'Persistence',
-                        status: persistence.patternsExist ? output.success('Saved') : output.dim('None'),
-                        details: persistence.patternsExist ? output.dim(persistence.dataDir) : 'No persisted patterns',
-                    },
-                ],
-            });
-            if (verbose) {
-                output.writeln();
-                output.writeln(output.bold('Detailed Metrics'));
-                const detailedData = [
-                    { metric: 'Trajectories Recorded', value: String(stats.trajectoriesRecorded) },
-                    { metric: 'Patterns Learned', value: String(stats.patternsLearned) },
-                    { metric: 'ReasoningBank Size', value: String(stats.reasoningBankSize) },
-                    { metric: 'Index Dimensions', value: String(hnswStatus.dimensions) },
-                    { metric: 'Avg Adaptation Time', value: `${stats.avgAdaptationTime.toFixed(3)}ms` },
-                    {
-                        metric: 'Last Adaptation',
-                        value: stats.lastAdaptation
-                            ? new Date(stats.lastAdaptation).toLocaleTimeString()
-                            : 'Never',
-                    },
-                ];
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 28 },
-                        { key: 'value', header: 'Value', width: 20 },
-                    ],
-                    data: detailedData,
-                });
-            }
-            return { success: true, data: { stats, hnswStatus, modelInfo, persistence } };
-        }
-        catch (error) {
-            spinner.fail('Failed to check pattern-learning systems');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Patterns subcommand
-const patternsCommand = {
-    name: 'patterns',
-    description: 'Analyze and manage cognitive 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' },
-        { name: 'limit', short: 'l', type: 'number', description: 'Max patterns to return', default: '10' },
-    ],
-    examples: [
-        { command: 'monomind neural patterns --action list', description: 'List all patterns' },
-        { command: 'monomind neural patterns -a analyze -q "error handling"', description: 'Analyze patterns' },
-    ],
-    action: async (ctx) => {
-        const action = ctx.flags.action || 'list';
-        const query = ctx.flags.query;
-        const limit = parseInt(ctx.flags.limit, 10) || 10;
-        output.writeln();
-        output.writeln(output.bold(`Neural Patterns - ${action}`));
-        output.writeln(output.dim('─'.repeat(40)));
-        try {
-            const { initializeIntelligence, getIntelligenceStats, findSimilarPatterns, getAllPatterns, getPersistenceStatus, } = await import('../memory/intelligence.js');
-            await initializeIntelligence();
-            const stats = getIntelligenceStats();
-            const persistence = getPersistenceStatus();
-            if (action === 'list') {
-                // Get ALL patterns from ReasoningBank (loaded from disk)
-                const allPatterns = await getAllPatterns();
-                const patterns = query
-                    ? await findSimilarPatterns(query, { k: limit })
-                    : allPatterns.slice(0, limit);
-                if (patterns.length === 0) {
-                    output.writeln(output.dim('No patterns found. Train some patterns first with: neural train'));
-                    output.writeln();
-                    output.printBox([
-                        `Total Patterns: ${stats.patternsLearned}`,
-                        `Trajectories: ${stats.trajectoriesRecorded}`,
-                        `ReasoningBank Size: ${stats.reasoningBankSize}`,
-                        `Persistence: ${persistence.patternsExist ? 'Loaded from disk' : 'Not persisted'}`,
-                        `Data Dir: ${persistence.dataDir}`,
-                    ].join('\n'), 'Pattern Statistics');
-                }
-                else {
-                    output.printTable({
-                        columns: [
-                            { key: 'id', header: 'ID', width: 20 },
-                            { key: 'type', header: 'Type', width: 18 },
-                            { key: 'confidence', header: 'Confidence', width: 12 },
-                            { key: 'usage', header: 'Usage', width: 10 },
-                        ],
-                        data: patterns.map((p, i) => ({
-                            id: (p.id || `P${String(i + 1).padStart(3, '0')}`).substring(0, 18),
-                            type: output.highlight(p.type || 'unknown'),
-                            confidence: `${((p.confidence || 0.5) * 100).toFixed(1)}%`,
-                            usage: String(p.usageCount || 0),
-                        })),
-                    });
-                }
-                output.writeln();
-                output.writeln(output.dim(`Total: ${allPatterns.length} patterns (persisted) | Trajectories: ${stats.trajectoriesRecorded}`));
-                if (persistence.patternsExist) {
-                    output.writeln(output.success(`✓ Loaded from: ${persistence.patternsFile}`));
-                }
-            }
-            else if (action === 'analyze' && !query) {
-                output.printError('--query is required when --action analyze is used.');
-                return { success: false, exitCode: 1 };
-            }
-            else if (action === 'analyze' && query) {
-                // Analyze patterns related to query
-                const related = await findSimilarPatterns(query, { k: limit });
-                output.writeln(`Analyzing patterns related to: "${query}"`);
-                output.writeln();
-                if (related.length > 0) {
-                    output.printTable({
-                        columns: [
-                            { key: 'content', header: 'Pattern', width: 40 },
-                            { key: 'confidence', header: 'Confidence', width: 12 },
-                            { key: 'type', header: 'Type', width: 15 },
-                        ],
-                        data: related.slice(0, 5).map(p => ({
-                            content: (p.content || '').substring(0, 38) + (p.content?.length > 38 ? '...' : ''),
-                            confidence: `${((p.confidence || 0) * 100).toFixed(0)}%`,
-                            type: p.type || 'general',
-                        })),
-                    });
-                }
-                else {
-                    output.writeln(output.dim('No related patterns found.'));
-                }
-            }
-            return { success: true };
-        }
-        catch (error) {
-            // Fallback if intelligence not initialized
-            output.writeln(output.dim('Intelligence system not initialized.'));
-            output.writeln(output.dim('Run: monomind neural train --pattern-type general'));
-            return { success: false };
-        }
-    },
-};
-// Predict subcommand
-const predictCommand = {
-    name: 'predict',
-    description: 'Make AI predictions using trained models',
-    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' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: json, table', default: 'table' },
-    ],
-    examples: [
-        { command: 'monomind neural predict -i "implement authentication"', description: 'Predict routing for task' },
-        { command: 'monomind neural predict -i "fix bug in login" -k 3', description: 'Get top 3 predictions' },
-    ],
-    action: async (ctx) => {
-        const input = ctx.flags.input;
-        const k = parseInt(ctx.flags.k || '5', 10);
-        const format = ctx.flags.format || 'table';
-        if (!input) {
-            output.printError('--input is required');
-            return { success: false, exitCode: 1 };
-        }
-        output.writeln();
-        output.writeln(output.bold('Neural Prediction (Real)'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Running inference...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const { initializeIntelligence, findSimilarPatterns } = await import('../memory/intelligence.js');
-            // Initialize intelligence system
-            await initializeIntelligence();
-            // Find similar patterns (embedding is done internally)
-            const startSearch = performance.now();
-            const matches = await findSimilarPatterns(input, { k });
-            const searchTime = performance.now() - startSearch;
-            spinner.succeed(`Prediction complete (search: ${searchTime.toFixed(1)}ms)`);
-            output.writeln();
-            if (matches.length === 0) {
-                output.writeln(output.warning('No similar patterns found. Try training first: monomind neural train'));
-                return { success: true, data: { matches: [] } };
-            }
-            if (format === 'json') {
-                output.writeln(JSON.stringify(matches, null, 2));
-            }
-            else {
-                // Determine best prediction based on patterns
-                const patternTypes = {};
-                for (const match of matches) {
-                    const type = match.type || 'unknown';
-                    patternTypes[type] = (patternTypes[type] || 0) + match.similarity;
-                }
-                const sorted = Object.entries(patternTypes).sort((a, b) => b[1] - a[1]);
-                const topType = sorted[0]?.[0] || 'unknown';
-                const confidence = matches[0]?.similarity || 0;
-                output.printBox([
-                    `Input: ${input.substring(0, 60)}${input.length > 60 ? '...' : ''}`,
-                    ``,
-                    `Predicted Type: ${topType}`,
-                    `Confidence: ${(confidence * 100).toFixed(1)}%`,
-                    `Latency: ${searchTime.toFixed(1)}ms`,
-                    ``,
-                    `Top ${matches.length} Similar Patterns:`,
-                ].join('\n'), 'Result');
-                output.printTable({
-                    columns: [
-                        { key: 'rank', header: '#', width: 3 },
-                        { key: 'id', header: 'Pattern ID', width: 20 },
-                        { key: 'type', header: 'Type', width: 15 },
-                        { key: 'similarity', header: 'Similarity', width: 12 },
-                    ],
-                    data: matches.slice(0, k).map((m, i) => ({
-                        rank: String(i + 1),
-                        id: m.id?.substring(0, 20) || 'unknown',
-                        type: m.type || 'action',
-                        similarity: `${(m.similarity * 100).toFixed(1)}%`,
-                    })),
-                });
-            }
-            return { success: true, data: { matches, searchTime } };
-        }
-        catch (error) {
-            spinner.fail('Prediction failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Optimize subcommand - Real Int8 quantization and pattern optimization
-const optimizeCommand = {
-    name: 'optimize',
-    description: 'Optimize neural patterns (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' },
-    ],
-    examples: [
-        { command: 'monomind neural optimize --method quantize', description: 'Quantize patterns to Int8' },
-        { command: 'monomind neural optimize --method analyze -v', description: 'Analyze memory usage' },
-    ],
-    action: async (ctx) => {
-        const method = ctx.flags.method || 'quantize';
-        const verbose = ctx.flags.verbose === true;
-        output.writeln();
-        output.writeln(output.bold('Pattern Optimization (Real)'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: `Running ${method} optimization...`, spinner: 'dots' });
-        spinner.start();
-        try {
-            const { initializeIntelligence, getIntelligenceStats, getAllPatterns, flushPatterns, compactPatterns } = await import('../memory/intelligence.js');
-            const fs = await import('fs');
-            const path = await import('path');
-            await initializeIntelligence();
-            const patterns = await getAllPatterns();
-            const stats = getIntelligenceStats();
-            // Get actual pattern storage size
-            const patternDir = path.join(process.cwd(), '.monomind', 'neural');
-            let beforeSize = 0;
-            try {
-                const patternFile = path.join(patternDir, 'patterns.json');
-                if (fs.existsSync(patternFile)) {
-                    beforeSize = fs.statSync(patternFile).size;
-                }
-            }
-            catch { /* ignore */ }
-            if (method === 'quantize') {
-                spinner.setText('Applying Int8 quantization to pattern embeddings...');
-                let quantized = 0;
-                let savedBytes = 0;
-                // Int8 quantization: compress Float32 embeddings to Int8 by scaling to [-127, 127]
-                // Reduces embedding storage by ~4x with minimal retrieval quality loss.
-                const quantizedPatterns = patterns.map(p => {
-                    if (!p.embedding || p.embedding.length === 0)
-                        return p;
-                    // Compute scale factor from max absolute value
-                    const maxAbs = p.embedding.reduce((m, v) => Math.max(m, Math.abs(v)), 1e-8);
-                    const scale = 127 / maxAbs;
-                    // Quantize to Int8 range and store as regular number array (portable JSON)
-                    const int8Embedding = Array.from(p.embedding).map(v => Math.round(v * scale) / scale);
-                    savedBytes += (p.embedding.length * 4) - (p.embedding.length * 1); // float32→int8
-                    quantized++;
-                    return { ...p, embedding: int8Embedding, _quantized: true, _scale: scale };
-                });
-                // Write quantized patterns back to disk
-                const patternFile = path.join(patternDir, 'patterns.json');
-                const tmpFile = `${patternFile}.${process.pid}.tmp`;
-                fs.writeFileSync(tmpFile, JSON.stringify(quantizedPatterns, null, 2), 'utf-8');
-                fs.renameSync(tmpFile, patternFile);
-                spinner.succeed(`Quantized ${quantized} patterns`);
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 25 },
-                        { key: 'value', header: 'Value', width: 20 },
-                    ],
-                    data: [
-                        { metric: 'Patterns Quantized', value: String(quantized) },
-                        { metric: 'Memory Saved', value: `~${(savedBytes / 1024).toFixed(1)} KB` },
-                        { metric: 'Compression', value: '~4x (Float32 → Int8)' },
-                        { metric: 'Quality Impact', value: 'Minimal (<1% cosine error)' },
-                    ],
-                });
-                return { success: true, data: { quantized, savedBytes } };
-            }
-            else if (method === 'analyze') {
-                spinner.succeed('Analysis complete');
-                output.writeln();
-                output.writeln(output.bold('Pattern Memory Analysis'));
-                const embeddingBytes = patterns.reduce((sum, p) => sum + (p.embedding?.length || 0) * 4, 0);
-                const metadataEstimate = patterns.length * 100; // ~100 bytes per pattern metadata
-                output.printTable({
-                    columns: [
-                        { key: 'component', header: 'Component', width: 25 },
-                        { key: 'size', header: 'Size', width: 18 },
-                        { key: 'count', header: 'Count', width: 12 },
-                    ],
-                    data: [
-                        { component: 'Pattern Embeddings (F32)', size: `${(embeddingBytes / 1024).toFixed(1)} KB`, count: String(patterns.length) },
-                        { component: 'Pattern Metadata', size: `${(metadataEstimate / 1024).toFixed(1)} KB`, count: '-' },
-                        { component: 'Total In-Memory', size: `${((embeddingBytes + metadataEstimate) / 1024).toFixed(1)} KB`, count: '-' },
-                        { component: 'Storage (patterns.json)', size: `${(beforeSize / 1024).toFixed(1)} KB`, count: '-' },
-                        { component: 'Trajectories', size: '-', count: String(stats.trajectoriesRecorded) },
-                    ],
-                });
-                if (verbose) {
-                    output.writeln();
-                    output.writeln(output.bold('Optimization Recommendations'));
-                    const recommendations = [];
-                    if (patterns.length > 1000) {
-                        recommendations.push('- Consider pruning low-usage patterns');
-                    }
-                    if (embeddingBytes > 1024 * 1024) {
-                        recommendations.push('- Int8 quantization would reduce memory by ~75%');
-                    }
-                    if (stats.trajectoriesRecorded > 100) {
-                        recommendations.push('- Trajectory consolidation available');
-                    }
-                    if (recommendations.length === 0) {
-                        recommendations.push('- Patterns are already well optimized');
-                    }
-                    recommendations.forEach(r => output.writeln(r));
-                }
-            }
-            else if (method === 'compact') {
-                spinner.setText('Compacting pattern storage...');
-                // Remove duplicate or very similar patterns
-                const compacted = await compactPatterns(0.95); // Remove patterns with >95% similarity
-                spinner.succeed(`Compacted ${compacted.removed} patterns`);
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'metric', header: 'Metric', width: 20 },
-                        { key: 'value', header: 'Value', width: 15 },
-                    ],
-                    data: [
-                        { metric: 'Patterns Before', value: String(compacted.before) },
-                        { metric: 'Patterns After', value: String(compacted.after) },
-                        { metric: 'Removed', value: String(compacted.removed) },
-                        { metric: 'Similarity Threshold', value: '95%' },
-                    ],
-                });
-            }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail('Optimization failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Export subcommand - Securely export trained models to IPFS
-const exportCommand = {
-    name: 'export',
-    description: 'Export trained models 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)' },
-        { name: 'ipfs', short: 'i', type: 'boolean', description: 'Pin to IPFS (requires Pinata credentials)' },
-        { name: 'sign', short: 's', type: 'boolean', description: 'Sign with Ed25519 key', default: 'true' },
-        { name: 'strip-pii', type: 'boolean', description: 'Strip potential PII from export', default: 'true' },
-        { name: 'name', short: 'n', type: 'string', description: 'Custom name for exported model' },
-    ],
-    examples: [
-        { command: 'monomind neural export -m security-patterns --ipfs', description: 'Export and pin to IPFS' },
-        { command: 'monomind neural export -m code-review -o ./export.json', description: 'Export to file' },
-    ],
-    action: async (ctx) => {
-        const modelId = ctx.flags.model || 'all';
-        const outputFile = ctx.flags.output;
-        const pinToIpfs = ctx.flags.ipfs;
-        const signExport = ctx.flags.sign !== false;
-        const stripPii = ctx.flags['strip-pii'] !== false;
-        const customName = ctx.flags.name;
-        output.writeln();
-        output.writeln(output.bold('Secure Model Export'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Preparing export...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const crypto = await import('crypto');
-            // Collect trained patterns from memory
-            spinner.setText('Collecting trained patterns...');
-            const { getIntelligenceStats, flushPatterns } = await import('../memory/intelligence.js');
-            await flushPatterns(); // Ensure all patterns are persisted
-            const stats = await getIntelligenceStats();
-            // SECURITY: Build export data - NEVER include secrets
-            // - API keys read from env but NEVER included in export
-            // - Uses ephemeral signing keys (generated per-export, not stored)
-            // - PII stripping enabled by default
-            // - Suspicious pattern content blocked
-            const exportData = {
-                type: 'learning-pattern',
-                version: '1.0.0',
-                name: customName || `monomind-model-${Date.now()}`,
-                exportedAt: new Date().toISOString(),
-                modelId,
-                patterns: [],
-                metadata: {
-                    sourceVersion: '3.0.0-alpha',
-                    piiStripped: stripPii,
-                    signed: signExport,
-                    accuracy: 0,
-                    totalUsage: 0,
-                },
-            };
-            // Load patterns from local storage
-            const memoryDir = path.join(process.cwd(), '.monomind', 'neural');
-            const patternsFile = path.join(memoryDir, 'patterns.json');
-            if (fs.existsSync(patternsFile)) {
-                const MAX_PATTERNS_BYTES = 100 * 1024 * 1024;
-                const patStat = fs.statSync(patternsFile);
-                if (patStat.size > MAX_PATTERNS_BYTES) {
-                    spinner.fail(`patterns.json too large to export safely (${patStat.size} bytes)`);
-                    return { success: false, exitCode: 1 };
-                }
-                const patternsRaw = fs.readFileSync(patternsFile, 'utf8');
-                const patternsJson = JSON.parse(patternsRaw);
-                if (patternsJson && typeof patternsJson === 'object' && ('__proto__' in patternsJson || 'constructor' in patternsJson)) {
-                    spinner.fail('Prototype pollution attempt detected in patterns.json');
-                    return { success: false, exitCode: 1 };
-                }
-                const patterns = patternsJson;
-                for (const pattern of patterns) {
-                    // Security: Strip potential PII
-                    if (stripPii) {
-                        // Remove any paths, usernames, or sensitive data
-                        if (pattern.content) {
-                            pattern.content = pattern.content
-                                .replace(/\/Users\/[^\/]+/g, '/Users/[REDACTED]')
-                                .replace(/\/home\/[^\/]+/g, '/home/[REDACTED]')
-                                .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g, '[EMAIL_REDACTED]')
-                                .replace(/\b(?:\d{1,3}\.){3}\d{1,3}\b/g, '[IP_REDACTED]');
-                        }
-                    }
-                    exportData.patterns.push({
-                        id: pattern.id || crypto.randomBytes(8).toString('hex'),
-                        trigger: pattern.trigger || pattern.type || 'general',
-                        action: pattern.action || pattern.recommendation || 'apply-pattern',
-                        confidence: pattern.confidence || 0.85,
-                        usageCount: pattern.usageCount || 1,
-                    });
-                }
-            }
-            // Add stats metadata
-            exportData.metadata.accuracy = stats.retrievalPrecision || 0.85;
-            exportData.metadata.totalUsage = exportData.patterns.reduce((sum, p) => sum + p.usageCount, 0);
-            spinner.setText('Generating secure signature...');
-            // Sign with Ed25519 if requested
-            let signature = null;
-            let publicKey = null;
-            if (signExport) {
-                // Generate ephemeral key pair for signing
-                // Use Node.js webcrypto for Ed25519 signing
-                const { webcrypto } = crypto;
-                const keyPair = await webcrypto.subtle.generateKey({ name: 'Ed25519' }, true, ['sign', 'verify']
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                );
-                const exportBytes = new TextEncoder().encode(JSON.stringify(exportData));
-                const signatureBytes = await webcrypto.subtle.sign('Ed25519', keyPair.privateKey, exportBytes);
-                signature = Buffer.from(signatureBytes).toString('hex');
-                const publicKeyBytes = await webcrypto.subtle.exportKey('raw', keyPair.publicKey);
-                publicKey = Buffer.from(publicKeyBytes).toString('hex');
-            }
-            // SECURITY: Final export package - verify no secrets leaked
-            const exportPackage = {
-                pinataContent: exportData,
-                pinataMetadata: {
-                    name: exportData.name,
-                    keyvalues: {
-                        type: 'learning-pattern',
-                        version: '1.0.0',
-                        signed: signExport ? 'true' : 'false',
-                    },
-                },
-                signature,
-                publicKey: publicKey ? `ed25519:${publicKey}` : null,
-                // Note: Private key is ephemeral and NEVER stored or exported
-            };
-            // SECURITY AUDIT: Ensure no secrets in export
-            const exportStr = JSON.stringify(exportPackage);
-            const secretPatterns = [
-                /sk-ant-[a-zA-Z0-9-]+/, // Anthropic keys
-                /sk-[a-zA-Z0-9]{48}/, // OpenAI keys
-                /AIza[a-zA-Z0-9-_]{35}/, // Google keys
-                /pinata_[a-zA-Z0-9]{20,}/, // Pinata JWT (min 20 chars to avoid false positives on short names)
-                /-----BEGIN.*KEY-----/, // PEM keys
-            ];
-            for (const pattern of secretPatterns) {
-                if (pattern.test(exportStr)) {
-                    spinner.fail('SECURITY: Export contains potential API keys - aborting');
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            // Output handling
-            if (outputFile) {
-                const resolvedOut = path.resolve(outputFile);
-                const cwd = process.cwd();
-                if (!resolvedOut.startsWith(cwd + path.sep) && resolvedOut !== cwd) {
-                    spinner.fail(`--output path escapes project directory: ${outputFile}`);
-                    return { success: false, exitCode: 1 };
-                }
-                const tmpOutput = outputFile + '.tmp';
-                fs.writeFileSync(tmpOutput, JSON.stringify(exportPackage, null, 2));
-                fs.renameSync(tmpOutput, outputFile);
-                spinner.succeed(`Exported to: ${outputFile}`);
-            }
-            if (pinToIpfs) {
-                spinner.setText('Pinning to IPFS...');
-                // Check for Pinata credentials
-                const pinataKey = process.env.PINATA_API_KEY;
-                const pinataSecret = process.env.PINATA_API_SECRET;
-                if (!pinataKey || !pinataSecret) {
-                    spinner.fail('PINATA_API_KEY and PINATA_API_SECRET required for IPFS export');
-                    output.writeln(output.dim('Set these in your environment or .env file'));
-                    return { success: false, exitCode: 1 };
-                }
-                const response = await fetch('https://api.pinata.cloud/pinning/pinJSONToIPFS', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'pinata_api_key': pinataKey,
-                        'pinata_secret_api_key': pinataSecret,
-                    },
-                    body: JSON.stringify(exportPackage),
-                });
-                if (!response.ok) {
-                    const error = await response.text();
-                    spinner.fail(`IPFS pin failed: ${error}`);
-                    return { success: false, exitCode: 1 };
-                }
-                const result = await response.json();
-                spinner.succeed('Successfully exported to IPFS');
-                output.writeln();
-                output.printTable({
-                    columns: [
-                        { key: 'property', header: 'Property', width: 20 },
-                        { key: 'value', header: 'Value', width: 50 },
-                    ],
-                    data: [
-                        { property: 'CID', value: result.IpfsHash },
-                        { property: 'Size', value: `${result.PinSize} bytes` },
-                        { property: 'Gateway URL', value: `https://gateway.pinata.cloud/ipfs/${result.IpfsHash}` },
-                        { property: 'Patterns', value: String(exportData.patterns.length) },
-                        { property: 'Signed', value: signExport ? 'Yes (Ed25519)' : 'No' },
-                        { property: 'PII Stripped', value: stripPii ? 'Yes' : 'No' },
-                    ],
-                });
-                output.writeln();
-                output.writeln(output.success('Share this CID for others to import your trained patterns'));
-                output.writeln(output.dim(`Import command: monomind neural import --cid ${result.IpfsHash}`));
-            }
-            if (!outputFile && !pinToIpfs) {
-                // Just display the export
-                spinner.succeed('Export prepared');
-                output.writeln();
-                output.writeln(JSON.stringify(exportPackage, null, 2));
-            }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail(`Export failed: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// List subcommand - List available pre-trained models
-const listCommand = {
-    name: 'list',
-    description: 'List available pre-trained models 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' },
-        { name: 'cid', type: 'string', description: 'Custom registry CID (default: official registry)' },
-    ],
-    examples: [
-        { command: 'monomind neural list', description: 'List all available models' },
-        { command: 'monomind neural list --category security', description: 'List only security models' },
-        { command: 'monomind neural list -f json', description: 'Output as JSON' },
-    ],
-    action: async (ctx) => {
-        const category = ctx.flags.category;
-        const format = ctx.flags.format || 'table';
-        const customCid = ctx.flags.cid;
-        // Official model registry CID
-        const registryCid = customCid || 'QmNr1yYMKi7YBaL8JSztQyuB5ZUaTdRMLxJC1pBpGbjsTc';
-        output.writeln();
-        output.writeln(output.bold('Pre-trained Model Registry'));
-        output.writeln(output.dim('─'.repeat(60)));
-        const spinner = output.createSpinner({ text: 'Fetching model registry...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const gateways = [
-                'https://gateway.pinata.cloud',
-                'https://ipfs.io',
-                'https://dweb.link',
-            ];
-            let registry = null;
-            for (const gateway of gateways) {
-                try {
-                    const response = await fetch(`${gateway}/ipfs/${registryCid}`, {
-                        signal: AbortSignal.timeout(15000),
-                        headers: { 'Accept': 'application/json' },
-                    });
-                    if (response.ok) {
-                        const MAX_REGISTRY_BYTES = 50 * 1024 * 1024;
-                        const buf = await response.arrayBuffer();
-                        if (buf.byteLength > MAX_REGISTRY_BYTES)
-                            throw new Error(`Registry response too large: ${buf.byteLength} bytes`);
-                        registry = JSON.parse(new TextDecoder().decode(buf));
-                        break;
-                    }
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (!registry || !registry.models) {
-                spinner.fail('Could not fetch model registry');
-                return { success: false, exitCode: 1 };
-            }
-            const registryData = registry;
-            // Filter by category if specified
-            let models = registryData.models;
-            if (category) {
-                models = models.filter(m => m.category === category ||
-                    m.id.includes(category) ||
-                    m.name.toLowerCase().includes(category.toLowerCase()));
-                spinner.succeed(`Found ${models.length} models matching "${category}"`);
-            }
-            else {
-                spinner.succeed(`Found ${registryData.models.length} models`);
-            }
-            if (models.length === 0) {
-                output.writeln(output.warning(`No models found for category: ${category}`));
-                output.writeln(output.dim('Available categories: security, quality, performance, testing, api, debugging, refactoring, documentation'));
-                return { success: false, exitCode: 1 };
-            }
-            output.writeln();
-            if (format === 'json') {
-                output.writeln(JSON.stringify(models, null, 2));
-            }
-            else if (format === 'simple') {
-                for (const model of models) {
-                    output.writeln(`${model.id} (${model.category}) - ${model.patterns.length} patterns, ${(model.metadata.accuracy * 100).toFixed(0)}% accuracy`);
-                }
-            }
-            else {
-                // Table format
-                output.printTable({
-                    columns: [
-                        { key: 'id', header: 'Model ID', width: 35 },
-                        { key: 'category', header: 'Category', width: 14 },
-                        { key: 'patterns', header: 'Patterns', width: 10 },
-                        { key: 'accuracy', header: 'Accuracy', width: 10 },
-                        { key: 'usage', header: 'Usage', width: 10 },
-                    ],
-                    data: models.map(m => ({
-                        id: m.id,
-                        category: m.category,
-                        patterns: String(m.patterns.length),
-                        accuracy: `${(m.metadata.accuracy * 100).toFixed(0)}%`,
-                        usage: m.metadata.totalUsage.toLocaleString(),
-                    })),
-                });
-                output.writeln();
-                output.writeln(output.dim('Registry CID: ' + registryCid));
-                output.writeln();
-                output.writeln(output.bold('Import Commands:'));
-                output.writeln(output.dim('  All models:      ') + `monomind neural import --cid ${registryCid}`);
-                if (category) {
-                    output.writeln(output.dim(`  ${category} only: `) + `monomind neural import --cid ${registryCid} --category ${category}`);
-                }
-                else {
-                    output.writeln(output.dim('  By category:     ') + `monomind neural import --cid ${registryCid} --category <category>`);
-                }
-            }
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail(`Failed to list models: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Import subcommand - Securely import models from IPFS
-const importCommand = {
-    name: 'import',
-    description: 'Import trained models 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' },
-        { name: 'verify', short: 'v', type: 'boolean', description: 'Verify Ed25519 signature', default: 'true' },
-        { name: 'merge', type: 'boolean', description: 'Merge with existing patterns (vs replace)', default: 'true' },
-        { name: 'category', type: 'string', description: 'Only import patterns from specific category' },
-    ],
-    examples: [
-        { command: 'monomind neural import --cid QmXxx...', description: 'Import from IPFS' },
-        { command: 'monomind neural import -f ./patterns.json --verify', description: 'Import from file' },
-        { command: 'monomind neural import --cid QmNr1yYMK... --category security', description: 'Import only security patterns' },
-    ],
-    action: async (ctx) => {
-        const cid = ctx.flags.cid;
-        const file = ctx.flags.file;
-        const verifySignature = ctx.flags.verify !== false;
-        const merge = ctx.flags.merge !== false;
-        const categoryFilter = ctx.flags.category;
-        if (!cid && !file) {
-            output.writeln(output.error('Either --cid or --file is required'));
-            return { success: false, exitCode: 1 };
-        }
-        output.writeln();
-        output.writeln(output.bold('Secure Model Import'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Fetching model...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const crypto = await import('crypto');
-            let importData = null;
-            // Fetch from IPFS or file
-            if (cid) {
-                const gateways = [
-                    'https://gateway.pinata.cloud',
-                    'https://ipfs.io',
-                    'https://dweb.link',
-                ];
-                for (const gateway of gateways) {
-                    try {
-                        spinner.setText(`Fetching from ${gateway}...`);
-                        const response = await fetch(`${gateway}/ipfs/${cid}`, {
-                            signal: AbortSignal.timeout(30000),
-                            headers: { 'Accept': 'application/json' },
-                        });
-                        if (response.ok) {
-                            const MAX_IMPORT_BYTES = 50 * 1024 * 1024;
-                            const importBuf = await response.arrayBuffer();
-                            if (importBuf.byteLength > MAX_IMPORT_BYTES)
-                                throw new Error(`Import response too large: ${importBuf.byteLength} bytes`);
-                            importData = JSON.parse(new TextDecoder().decode(importBuf));
-                            break;
-                        }
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-                if (!importData) {
-                    spinner.fail('Could not fetch from any IPFS gateway');
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            else {
-                if (!fs.existsSync(file)) {
-                    spinner.fail(`File not found: ${file}`);
-                    return { success: false, exitCode: 1 };
-                }
-                // Cap import file size to prevent OOM on attacker-controlled content.
-                const stat = fs.statSync(file);
-                const MAX_IMPORT_BYTES = 50 * 1024 * 1024; // 50 MB
-                if (stat.size > MAX_IMPORT_BYTES) {
-                    spinner.fail(`Import file too large: ${stat.size} bytes (max ${MAX_IMPORT_BYTES})`);
-                    return { success: false, exitCode: 1 };
-                }
-                importData = JSON.parse(fs.readFileSync(file, 'utf8'));
-            }
-            if (!importData) {
-                spinner.fail('No import data available');
-                return { success: false, exitCode: 1 };
-            }
-            // SECURITY: Verify signature when --verify is set (default true).
-            // Previously two bypasses existed:
-            //   (a) catch-fall-through made any malformed signature/key skip verification
-            //       and proceed to import — fail-OPEN.
-            //   (b) the entire block was guarded on `signature && publicKey`, so an
-            //       attacker who simply omitted those fields skipped verification
-            //       regardless of --verify. Both now fail-CLOSED.
-            if (verifySignature) {
-                if (!importData.signature || !importData.publicKey) {
-                    spinner.fail('SECURITY: --verify requested but payload is unsigned. Aborting (use --no-verify to override).');
-                    return { success: false, exitCode: 1 };
-                }
-                spinner.setText('Verifying Ed25519 signature...');
-                try {
-                    const { webcrypto } = crypto;
-                    const publicKeyHex = importData.publicKey.replace('ed25519:', '');
-                    const publicKeyBytes = Buffer.from(publicKeyHex, 'hex');
-                    const signatureBytes = Buffer.from(importData.signature, 'hex');
-                    const publicKey = await webcrypto.subtle.importKey('raw', publicKeyBytes, { name: 'Ed25519' }, false, ['verify']);
-                    const dataBytes = new TextEncoder().encode(JSON.stringify(importData.pinataContent));
-                    const valid = await webcrypto.subtle.verify('Ed25519', publicKey, signatureBytes, dataBytes);
-                    if (!valid) {
-                        spinner.fail('Signature verification FAILED - data may be tampered');
-                        return { success: false, exitCode: 1 };
-                    }
-                    output.writeln(output.success('Signature verified'));
-                }
-                catch (err) {
-                    // FAIL-CLOSED: any error during verification (malformed key, wrong
-                    // algorithm, runtime not supporting Ed25519, etc.) must reject the
-                    // import, NOT fall through with a warning.
-                    spinner.fail(`SECURITY: Signature verification error: ${err instanceof Error ? err.message : String(err)}. Aborting.`);
-                    return { success: false, exitCode: 1 };
-                }
-            }
-            // Extract patterns - handle both single model and model registry formats
-            spinner.setText('Importing patterns...');
-            const content = importData.pinataContent || importData;
-            let patterns = [];
-            // Check if this is a model registry (has models array)
-            const registry = content;
-            if (registry.models && Array.isArray(registry.models)) {
-                // Model registry format - extract patterns from each model
-                for (const model of registry.models) {
-                    if (!categoryFilter || model.category === categoryFilter || model.id.includes(categoryFilter)) {
-                        for (const pattern of model.patterns || []) {
-                            patterns.push({
-                                ...pattern,
-                                category: model.category, // Tag with model category
-                            });
-                        }
-                    }
-                }
-            }
-            else {
-                // Single model format - patterns at top level
-                patterns = content.patterns || [];
-            }
-            // Filter by category if specified (additional filtering)
-            if (categoryFilter && patterns.length > 0) {
-                patterns = patterns.filter(p => p.category === categoryFilter ||
-                    p.trigger.includes(categoryFilter));
-            }
-            // Validate patterns (security check)
-            const validPatterns = patterns.filter(p => {
-                // Security: Reject patterns with suspicious content
-                const suspicious = [
-                    'eval(', 'Function(', 'exec(', 'spawn(',
-                    'child_process', 'rm -rf', 'sudo',
-                    '<script>', 'javascript:', 'data:',
-                ];
-                const content = JSON.stringify(p);
-                return !suspicious.some(s => content.includes(s));
-            });
-            if (validPatterns.length < patterns.length) {
-                output.writeln(output.warning(`Filtered ${patterns.length - validPatterns.length} suspicious patterns`));
-            }
-            // Save to neural store (same location intelligence.ts writes to)
-            const memoryDir = path.join(process.cwd(), '.monomind', 'neural');
-            if (!fs.existsSync(memoryDir)) {
-                fs.mkdirSync(memoryDir, { recursive: true });
-            }
-            const patternsFile = path.join(memoryDir, 'patterns.json');
-            let existingPatterns = [];
-            if (merge && fs.existsSync(patternsFile) && fs.statSync(patternsFile).size <= 50 * 1024 * 1024) {
-                existingPatterns = JSON.parse(fs.readFileSync(patternsFile, 'utf8'));
-            }
-            // Merge or replace
-            const existingIds = new Set(existingPatterns.map(p => p.id));
-            const newPatterns = validPatterns.filter(p => !existingIds.has(p.id));
-            const finalPatterns = merge ? [...existingPatterns, ...newPatterns] : validPatterns;
-            // Unique tmp filename so concurrent invocations don't clobber each other's
-            // .tmp files mid-write (which would produce a corrupt patterns.json on rename).
-            const tmpPatterns = `${patternsFile}.${process.pid}.${Date.now()}.tmp`;
-            fs.writeFileSync(tmpPatterns, JSON.stringify(finalPatterns, null, 2), { flag: 'wx' });
-            fs.renameSync(tmpPatterns, patternsFile);
-            spinner.succeed('Import complete');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 20 },
-                ],
-                data: [
-                    { metric: 'Patterns Imported', value: String(validPatterns.length) },
-                    { metric: 'New Patterns', value: String(newPatterns.length) },
-                    { metric: 'Total Patterns', value: String(finalPatterns.length) },
-                    { metric: 'Signature Verified', value: importData.signature ? 'Yes' : 'N/A' },
-                    { metric: 'Merge Mode', value: merge ? 'Yes' : 'Replace' },
-                ],
-            });
-            output.writeln();
-            output.writeln(output.success('Patterns imported and ready to use'));
-            output.writeln(output.dim('Run "monomind neural patterns --action list" to see imported patterns'));
-            return { success: true };
-        }
-        catch (error) {
-            spinner.fail(`Import failed: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
-};
-// Main neural command
+import { statusCommand, patternsCommand, 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)',