monomind 2.7.11 → 2.7.13

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

@@ -1,10 +0,0 @@
-/**
- * CLI Performance Command
- * Performance profiling, benchmarking, optimization, metrics
- *
- * github.com/monoes/monomind
- */
-import type { Command } from '../types.js';
-export declare const performanceCommand: Command;
-export default performanceCommand;
-//# sourceMappingURL=performance.d.ts.map

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

@@ -1,656 +0,0 @@
-/**
- * CLI Performance Command
- * Performance profiling, benchmarking, optimization, metrics
- *
- * github.com/monoes/monomind
- */
-import { output } from '../output.js';
-// Benchmark subcommand - REAL measurements
-const benchmarkCommand = {
-    name: 'benchmark',
-    description: 'Run performance benchmarks',
-    options: [
-        { name: 'suite', short: 's', type: 'string', description: 'Benchmark suite: all, wasm, neural, memory, search', default: 'all' },
-        { name: 'iterations', short: 'i', type: 'number', description: 'Number of iterations', default: '100' },
-        { name: 'warmup', short: 'w', type: 'number', description: 'Warmup iterations', default: '10' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json, csv', default: 'text' },
-    ],
-    examples: [
-        { command: 'monomind performance benchmark -s neural', description: 'Benchmark neural operations' },
-        { command: 'monomind performance benchmark -i 1000', description: 'Run with 1000 iterations' },
-    ],
-    action: async (ctx) => {
-        const suiteRaw = ctx.flags.suite || 'all';
-        const VALID_SUITES = new Set(['all', 'wasm', 'neural', 'memory', 'search']);
-        const suite = VALID_SUITES.has(suiteRaw) ? suiteRaw : 'all';
-        // Falling back is fine; doing it silently is not. `--suite quick` used to
-        // print "Running all benchmarks" and produce a full run, so the user's
-        // explicit choice was discarded with no indication it had been ignored.
-        if (suiteRaw !== suite) {
-            output.writeln(output.warning(`Unknown benchmark suite "${suiteRaw}" — running "all" instead. ` +
-                `Valid suites: ${[...VALID_SUITES].join(', ')}.`));
-        }
-        const MAX_ITERATIONS = 10_000;
-        const MAX_WARMUP = 500;
-        const iterationsRaw = parseInt(ctx.flags.iterations || '100', 10);
-        const warmupRaw = parseInt(ctx.flags.warmup || '10', 10);
-        const iterations = Number.isFinite(iterationsRaw) ? Math.min(Math.max(1, iterationsRaw), MAX_ITERATIONS) : 100;
-        const warmup = Number.isFinite(warmupRaw) ? Math.min(Math.max(0, warmupRaw), MAX_WARMUP) : 10;
-        const outputFormatRaw = ctx.flags.output || 'text';
-        const VALID_OUTPUT_FORMATS = new Set(['text', 'json', 'csv']);
-        const outputFormat = VALID_OUTPUT_FORMATS.has(outputFormatRaw) ? outputFormatRaw : 'text';
-        output.writeln();
-        output.writeln(output.bold('Performance Benchmark (Real Measurements)'));
-        output.writeln(output.dim('─'.repeat(60)));
-        const spinner = output.createSpinner({ text: `Running ${suite} benchmarks...`, spinner: 'dots' });
-        spinner.start();
-        // Import real implementations
-        const { generateEmbedding, batchCosineSim, flashAttentionSearch, getHNSWStatus, storeEntry, searchEntries, } = await import('../memory/memory-initializer.js');
-        const { benchmarkAdaptation, initializeIntelligence } = await import('../memory/intelligence.js');
-        const results = [];
-        const startTotal = Date.now();
-        // Helper to compute percentiles
-        const percentile = (arr, p) => {
-            const sorted = [...arr].sort((a, b) => a - b);
-            const idx = Math.ceil((p / 100) * sorted.length) - 1;
-            return sorted[Math.max(0, idx)];
-        };
-        // 1. Embedding Generation Benchmark
-        if (suite === 'all' || suite === 'neural' || suite === 'memory') {
-            spinner.setText('Benchmarking embedding generation...');
-            const embedTimes = [];
-            // Warmup
-            for (let i = 0; i < warmup; i++) {
-                await generateEmbedding(`warmup text ${i}`);
-            }
-            // Actual measurement
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await generateEmbedding(`benchmark text number ${i} with some varied content`);
-                embedTimes.push(performance.now() - start);
-            }
-            const mean = embedTimes.reduce((a, b) => a + b, 0) / embedTimes.length;
-            const embedTargetMet = mean < 10;
-            results.push({
-                operation: 'Embedding Gen',
-                mean: `${mean.toFixed(2)}ms`,
-                p95: `${percentile(embedTimes, 95).toFixed(2)}ms`,
-                p99: `${percentile(embedTimes, 99).toFixed(2)}ms`,
-                improvement: embedTargetMet ? output.success('Target met') : output.warning('Below target'),
-                targetMet: embedTargetMet,
-            });
-        }
-        // 2. Batch Vector Operations
-        if (suite === 'all' || suite === 'wasm') {
-            spinner.setText('Benchmarking batch vector ops...');
-            const flashTimes = [];
-            // Generate test vectors
-            const testVectors = Array.from({ length: 100 }, () => new Float32Array(Array.from({ length: 384 }, () => Math.random())));
-            const queryVector = new Float32Array(Array.from({ length: 384 }, () => Math.random()));
-            // Warmup
-            for (let i = 0; i < warmup; i++) {
-                batchCosineSim(queryVector, testVectors);
-            }
-            // Actual measurement
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                flashAttentionSearch(queryVector, testVectors, { k: 10 });
-                flashTimes.push(performance.now() - start);
-            }
-            const mean = flashTimes.reduce((a, b) => a + b, 0) / flashTimes.length;
-            // Compare to baseline (single-vector comparison takes ~0.5μs, so 100 vectors baseline ~0.05ms)
-            const baselineMs = 0.05;
-            const speedup = baselineMs / mean;
-            const flashTargetMet = speedup > 1;
-            results.push({
-                operation: 'Batch Vector Ops',
-                mean: `${mean.toFixed(3)}ms`,
-                p95: `${percentile(flashTimes, 95).toFixed(3)}ms`,
-                p99: `${percentile(flashTimes, 99).toFixed(3)}ms`,
-                improvement: flashTargetMet ? output.success(`${speedup.toFixed(2)}x`) : output.dim(`${speedup.toFixed(2)}x`),
-                targetMet: flashTargetMet,
-            });
-        }
-        // 3. HNSW Search Benchmark
-        if (suite === 'all' || suite === 'search') {
-            spinner.setText('Benchmarking HNSW search...');
-            const hnswStatus = getHNSWStatus();
-            if (hnswStatus.available && hnswStatus.entryCount > 0) {
-                const searchTimes = [];
-                const testQueries = [
-                    'error handling patterns',
-                    'authentication flow',
-                    'database optimization',
-                    'API design patterns',
-                    'test coverage strategies',
-                ];
-                // Warmup
-                for (const q of testQueries.slice(0, 2)) {
-                    await searchEntries({ query: q, limit: 10 });
-                }
-                // Actual measurement
-                for (let i = 0; i < Math.min(iterations, 50); i++) {
-                    const query = testQueries[i % testQueries.length];
-                    const start = performance.now();
-                    await searchEntries({ query, limit: 10 });
-                    searchTimes.push(performance.now() - start);
-                }
-                const mean = searchTimes.reduce((a, b) => a + b, 0) / searchTimes.length;
-                // Brute force baseline: ~0.5μs per vector comparison, 1000 vectors = 0.5ms
-                // HNSW should be O(log n) ~150x faster
-                const baselineBruteForce = hnswStatus.entryCount * 0.0005;
-                const speedup = baselineBruteForce / (mean / 1000);
-                const hnswTargetMet = speedup > 10;
-                results.push({
-                    operation: `HNSW Search (n=${hnswStatus.entryCount})`,
-                    mean: `${mean.toFixed(2)}ms`,
-                    p95: `${percentile(searchTimes, 95).toFixed(2)}ms`,
-                    p99: `${percentile(searchTimes, 99).toFixed(2)}ms`,
-                    improvement: hnswTargetMet ? output.success(`~${Math.round(speedup)}x`) : output.dim(`${speedup.toFixed(1)}x`),
-                    targetMet: hnswTargetMet,
-                });
-            }
-            else {
-                results.push({
-                    operation: 'HNSW Search',
-                    mean: 'N/A',
-                    p95: 'N/A',
-                    p99: 'N/A',
-                    improvement: output.warning('No index'),
-                    targetMet: false,
-                });
-            }
-        }
-        // 4. Pattern Adaptation Benchmark (JS)
-        if (suite === 'all' || suite === 'neural') {
-            spinner.setText('Benchmarking pattern adaptation...');
-            await initializeIntelligence();
-            const sonaResult = benchmarkAdaptation(iterations);
-            results.push({
-                operation: 'Pattern Adaptation',
-                mean: `${(sonaResult.avgMs * 1000).toFixed(2)}μs`,
-                p95: `${(sonaResult.maxMs * 1000).toFixed(2)}μs`,
-                p99: `${(sonaResult.maxMs * 1000).toFixed(2)}μs`,
-                improvement: sonaResult.targetMet ? output.success('<0.05ms ✓') : output.warning('Above target'),
-                targetMet: sonaResult.targetMet,
-            });
-        }
-        // 5. Memory Store/Retrieve
-        if (suite === 'all' || suite === 'memory') {
-            spinner.setText('Benchmarking memory operations...');
-            const storeTimes = [];
-            // Use in-memory operations for benchmark (don't persist)
-            for (let i = 0; i < Math.min(iterations, 20); i++) {
-                const start = performance.now();
-                await storeEntry({
-                    key: `bench_${Date.now()}_${i}`,
-                    value: `Benchmark test entry ${i} with some content for testing storage performance`,
-                    namespace: 'benchmark',
-                    generateEmbeddingFlag: true,
-                });
-                storeTimes.push(performance.now() - start);
-            }
-            const mean = storeTimes.reduce((a, b) => a + b, 0) / storeTimes.length;
-            const storeTargetMet = mean < 50;
-            results.push({
-                operation: 'Memory Store+Embed',
-                mean: `${mean.toFixed(1)}ms`,
-                p95: `${percentile(storeTimes, 95).toFixed(1)}ms`,
-                p99: `${percentile(storeTimes, 99).toFixed(1)}ms`,
-                improvement: storeTargetMet ? output.success('Target met') : output.warning('Slow'),
-                targetMet: storeTargetMet,
-            });
-        }
-        const totalTime = ((Date.now() - startTotal) / 1000).toFixed(2);
-        spinner.succeed(`Completed ${iterations} iterations in ${totalTime}s`);
-        // Output results
-        if (outputFormat === 'json') {
-            output.printJson({ suite, iterations, totalTime: `${totalTime}s`, results });
-        }
-        else {
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'operation', header: 'Operation', width: 22 },
-                    { key: 'mean', header: 'Mean', width: 12 },
-                    { key: 'p95', header: 'P95', width: 12 },
-                    { key: 'p99', header: 'P99', width: 12 },
-                    { key: 'improvement', header: 'Status', width: 15 },
-                ],
-                data: results,
-            });
-            output.writeln();
-            const allTargetsMet = results.every(r => r.targetMet);
-            output.printBox([
-                `Suite: ${suite}`,
-                `Iterations: ${iterations}`,
-                `Total Time: ${totalTime}s`,
-                ``,
-                `Overall: ${allTargetsMet ? output.success('All targets met') : output.warning('Some targets missed')}`,
-            ].join('\n'), 'Benchmark Summary');
-        }
-        return { success: true, data: { results, totalTime } };
-    },
-};
-// Profile subcommand
-const profileCommand = {
-    name: 'profile',
-    description: 'Profile application performance',
-    options: [
-        { name: 'type', short: 't', type: 'string', description: 'Profile type: cpu, memory, io, all', default: 'all' },
-        { name: 'duration', short: 'd', type: 'number', description: 'Duration in seconds', default: '30' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output file for profile data' },
-    ],
-    examples: [
-        { command: 'monomind performance profile -t cpu', description: 'Profile CPU usage' },
-        { command: 'monomind performance profile -d 60', description: 'Profile for 60 seconds' },
-    ],
-    action: async (ctx) => {
-        const typeRaw = ctx.flags.type || 'all';
-        const VALID_PROFILE_TYPES = new Set(['cpu', 'memory', 'io', 'all']);
-        const type = VALID_PROFILE_TYPES.has(typeRaw) ? typeRaw : 'all';
-        const durationRaw = parseInt(ctx.flags.duration || '30', 10);
-        const duration = Number.isFinite(durationRaw) ? Math.min(Math.max(1, durationRaw), 300) : 30;
-        output.writeln();
-        output.writeln(output.bold('Performance Profiler'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Collecting profile data...', spinner: 'dots' });
-        spinner.start();
-        // Collect real metrics
-        const startCpu = process.cpuUsage();
-        const startMem = process.memoryUsage();
-        const startTime = process.hrtime.bigint();
-        // Sample for a brief period
-        await new Promise(r => setTimeout(r, Math.min(duration * 1000, 30_000)));
-        const endCpu = process.cpuUsage(startCpu);
-        const endMem = process.memoryUsage();
-        const endTime = process.hrtime.bigint();
-        spinner.succeed('Profile complete');
-        // Calculate real values
-        const elapsedMs = Number(endTime - startTime) / 1_000_000;
-        const cpuPercent = ((endCpu.user + endCpu.system) / 1000 / elapsedMs * 100).toFixed(1);
-        const heapUsedMB = (endMem.heapUsed / 1024 / 1024).toFixed(1);
-        const heapTotalMB = (endMem.heapTotal / 1024 / 1024).toFixed(1);
-        const rssMB = (endMem.rss / 1024 / 1024).toFixed(1);
-        const externalMB = (endMem.external / 1024 / 1024).toFixed(1);
-        // Get event loop lag (approximate)
-        const lagStart = Date.now();
-        await new Promise(r => setImmediate(r));
-        const eventLoopLag = (Date.now() - lagStart).toFixed(1);
-        // Determine status based on thresholds
-        const heapStatus = endMem.heapUsed / endMem.heapTotal > 0.9 ? output.error('High') :
-            endMem.heapUsed / endMem.heapTotal > 0.7 ? output.warning('Elevated') : output.success('Normal');
-        const lagStatus = parseFloat(eventLoopLag) > 50 ? output.error('High') :
-            parseFloat(eventLoopLag) > 10 ? output.warning('Elevated') : output.success('Normal');
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'metric', header: 'Metric', width: 25 },
-                { key: 'current', header: 'Current', width: 15 },
-                { key: 'peak', header: 'Peak/Total', width: 15 },
-                { key: 'status', header: 'Status', width: 15 },
-            ],
-            data: [
-                { metric: 'CPU Usage', current: `${cpuPercent}%`, peak: '-', status: output.success('Sampled') },
-                { metric: 'Memory (Heap Used)', current: `${heapUsedMB} MB`, peak: `${heapTotalMB} MB`, status: heapStatus },
-                { metric: 'Memory (RSS)', current: `${rssMB} MB`, peak: '-', status: output.success('Normal') },
-                { metric: 'Memory (External)', current: `${externalMB} MB`, peak: '-', status: output.success('Normal') },
-                { metric: 'Event Loop Lag', current: `${eventLoopLag}ms`, peak: '-', status: lagStatus },
-                { metric: 'Node.js Uptime', current: `${process.uptime().toFixed(1)}s`, peak: '-', status: output.success('Running') },
-            ],
-        });
-        output.writeln();
-        output.writeln(output.dim(`Profile duration: ${elapsedMs.toFixed(0)}ms`));
-        const outputFile = ctx.flags.output;
-        if (outputFile) {
-            const profileData = {
-                timestamp: new Date().toISOString(),
-                duration_ms: Math.round(elapsedMs),
-                cpu: { user_us: endCpu.user, system_us: endCpu.system, percent: parseFloat(cpuPercent) },
-                memory: {
-                    heap_used_mb: parseFloat(heapUsedMB),
-                    heap_total_mb: parseFloat(heapTotalMB),
-                    rss_mb: parseFloat(rssMB),
-                    external_mb: parseFloat(externalMB),
-                },
-                event_loop_lag_ms: parseFloat(eventLoopLag),
-            };
-            const fs = await import('fs');
-            const path = await import('path');
-            const resolved = path.resolve(outputFile);
-            fs.writeFileSync(resolved, JSON.stringify(profileData, null, 2) + '\n');
-            output.writeln(output.success(`Profile data saved to ${resolved}`));
-        }
-        return { success: true };
-    },
-};
-// Metrics subcommand
-const metricsCommand = {
-    name: 'metrics',
-    description: 'View and export performance metrics',
-    options: [
-        { name: 'timeframe', short: 't', type: 'string', description: 'Timeframe: 1h, 24h, 7d, 30d', default: '24h' },
-        { name: 'format', short: 'f', type: 'string', description: 'Output format: text, json, prometheus', default: 'text' },
-        { name: 'component', short: 'c', type: 'string', description: 'Component to filter' },
-    ],
-    examples: [
-        { command: 'monomind performance metrics -t 7d', description: 'Show 7-day metrics' },
-        { command: 'monomind performance metrics -f prometheus', description: 'Export as Prometheus format' },
-    ],
-    action: async (ctx) => {
-        const timeframeRaw = ctx.flags.timeframe || '24h';
-        const VALID_TIMEFRAMES = new Set(['1h', '24h', '7d', '30d']);
-        const timeframe = VALID_TIMEFRAMES.has(timeframeRaw) ? timeframeRaw : '24h';
-        const formatRaw = ctx.flags.format || 'text';
-        const VALID_FORMATS = new Set(['text', 'json', 'prometheus']);
-        const format = VALID_FORMATS.has(formatRaw) ? formatRaw : 'text';
-        output.writeln();
-        output.writeln(output.bold(`Performance Metrics (${timeframe})`));
-        output.writeln(output.dim('─'.repeat(50)));
-        const os = await import('os');
-        const fs = await import('fs');
-        const path = await import('path');
-        // Real system metrics
-        const memUsage = process.memoryUsage();
-        const cpuUsage = process.cpuUsage();
-        const uptime = process.uptime();
-        const loadAvg = os.loadavg();
-        const freeMem = os.freemem();
-        const totalMem = os.totalmem();
-        // Calculate real metrics
-        const heapUsedMB = (memUsage.heapUsed / 1024 / 1024).toFixed(1);
-        const heapTotalMB = (memUsage.heapTotal / 1024 / 1024).toFixed(1);
-        const rssMB = (memUsage.rss / 1024 / 1024).toFixed(1);
-        const memPercent = ((1 - freeMem / totalMem) * 100).toFixed(1);
-        const cpuUserMs = (cpuUsage.user / 1000).toFixed(0);
-        const cpuSystemMs = (cpuUsage.system / 1000).toFixed(0);
-        // Try to get HNSW/cache stats from real data
-        let cacheHitRate = 'N/A';
-        let hnswEntries = 0;
-        try {
-            const { getHNSWStatus } = await import('../memory/memory-initializer.js');
-            const status = getHNSWStatus();
-            hnswEntries = status?.entryCount || 0;
-        }
-        catch { /* HNSW not initialized */ }
-        // Try to get real cache stats
-        let cacheEntries = 0;
-        try {
-            const cachePath = path.resolve('.cache/embeddings.db');
-            if (fs.existsSync(cachePath)) {
-                const stats = fs.statSync(cachePath);
-                cacheEntries = Math.floor(stats.size / 1600); // Approximate entries
-            }
-        }
-        catch { /* no cache */ }
-        // Benchmark a quick operation to get real latency
-        let avgLatencyMs = 0;
-        try {
-            const times = [];
-            for (let i = 0; i < 10; i++) {
-                const start = performance.now();
-                await new Promise(r => setImmediate(r)); // Event loop turn
-                times.push(performance.now() - start);
-            }
-            avgLatencyMs = times.reduce((a, b) => a + b, 0) / times.length;
-        }
-        catch { /* timing failed */ }
-        // JSON/Prometheus output
-        if (format === 'json') {
-            const metrics = {
-                timestamp: new Date().toISOString(),
-                timeframe,
-                memory: {
-                    heapUsed: memUsage.heapUsed,
-                    heapTotal: memUsage.heapTotal,
-                    rss: memUsage.rss,
-                    external: memUsage.external,
-                    systemPercent: parseFloat(memPercent),
-                },
-                cpu: {
-                    user: cpuUsage.user,
-                    system: cpuUsage.system,
-                    loadAverage: loadAvg,
-                },
-                process: {
-                    uptime,
-                    pid: process.pid,
-                },
-                cache: {
-                    entries: cacheEntries,
-                    hnswEntries,
-                },
-                latency: {
-                    avgMs: avgLatencyMs,
-                },
-            };
-            output.writeln(JSON.stringify(metrics, null, 2));
-            return { success: true };
-        }
-        if (format === 'prometheus') {
-            output.writeln(`# HELP monomind_heap_used_bytes Heap memory used`);
-            output.writeln(`monomind_heap_used_bytes ${memUsage.heapUsed}`);
-            output.writeln(`# HELP monomind_heap_total_bytes Total heap memory`);
-            output.writeln(`monomind_heap_total_bytes ${memUsage.heapTotal}`);
-            output.writeln(`# HELP monomind_rss_bytes Resident set size`);
-            output.writeln(`monomind_rss_bytes ${memUsage.rss}`);
-            output.writeln(`# HELP monomind_cpu_user_microseconds CPU user time`);
-            output.writeln(`monomind_cpu_user_microseconds ${cpuUsage.user}`);
-            output.writeln(`# HELP monomind_cpu_system_microseconds CPU system time`);
-            output.writeln(`monomind_cpu_system_microseconds ${cpuUsage.system}`);
-            output.writeln(`# HELP monomind_cache_entries Embedding cache entries`);
-            output.writeln(`monomind_cache_entries ${cacheEntries}`);
-            output.writeln(`# HELP monomind_hnsw_entries HNSW index entries`);
-            output.writeln(`monomind_hnsw_entries ${hnswEntries}`);
-            output.writeln(`# HELP monomind_uptime_seconds Process uptime`);
-            output.writeln(`monomind_uptime_seconds ${uptime}`);
-            return { success: true };
-        }
-        // Text table output with real values
-        output.printTable({
-            columns: [
-                { key: 'metric', header: 'Metric', width: 25 },
-                { key: 'current', header: 'Current', width: 15 },
-                { key: 'limit', header: 'Limit', width: 15 },
-                { key: 'status', header: 'Status', width: 12 },
-            ],
-            data: [
-                {
-                    metric: 'Heap Memory',
-                    current: `${heapUsedMB} MB`,
-                    limit: `${heapTotalMB} MB`,
-                    status: parseFloat(heapUsedMB) < parseFloat(heapTotalMB) * 0.8 ? output.success('OK') : output.warning('High'),
-                },
-                {
-                    metric: 'RSS Memory',
-                    current: `${rssMB} MB`,
-                    limit: '-',
-                    status: parseFloat(rssMB) < 500 ? output.success('OK') : output.warning('High'),
-                },
-                {
-                    metric: 'System Memory',
-                    current: `${memPercent}%`,
-                    limit: '100%',
-                    status: parseFloat(memPercent) < 80 ? output.success('OK') : output.warning('High'),
-                },
-                {
-                    metric: 'CPU User Time',
-                    current: `${cpuUserMs}ms`,
-                    limit: '-',
-                    status: output.success('OK'),
-                },
-                {
-                    metric: 'Event Loop Latency',
-                    current: `${avgLatencyMs.toFixed(2)}ms`,
-                    limit: '10ms',
-                    status: avgLatencyMs < 10 ? output.success('OK') : output.warning('Slow'),
-                },
-                {
-                    metric: 'HNSW Index',
-                    current: `${hnswEntries} entries`,
-                    limit: '-',
-                    status: hnswEntries > 0 ? output.success('Active') : output.dim('Empty'),
-                },
-                {
-                    metric: 'Embedding Cache',
-                    current: `${cacheEntries} entries`,
-                    limit: '-',
-                    status: cacheEntries > 0 ? output.success('Active') : output.dim('Empty'),
-                },
-                {
-                    metric: 'Process Uptime',
-                    current: `${Math.floor(uptime)}s`,
-                    limit: '-',
-                    status: output.success('Running'),
-                },
-            ],
-        });
-        output.writeln();
-        output.writeln(output.dim(`Load Average: ${loadAvg.map(l => l.toFixed(2)).join(', ')}`));
-        output.writeln(output.dim(`CPUs: ${os.cpus().length} | Platform: ${os.platform()} ${os.release()}`));
-        return { success: true };
-    },
-};
-// Bottleneck subcommand
-const bottleneckCommand = {
-    name: 'bottleneck',
-    description: 'Identify performance bottlenecks',
-    options: [
-        { name: 'component', short: 'c', type: 'string', description: 'Component to analyze' },
-        { name: 'depth', short: 'd', type: 'string', description: 'Analysis depth: quick, full', default: 'quick' },
-    ],
-    examples: [
-        { command: 'monomind performance bottleneck', description: 'Find bottlenecks' },
-        { command: 'monomind performance bottleneck -c network', description: 'Only the Network component' },
-    ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Bottleneck Analysis'));
-        output.writeln(output.dim('─'.repeat(50)));
-        // Components this command actually knows how to inspect. Used both to
-        // validate --component and to tell the user what they could have asked for.
-        const ANALYZED_COMPONENTS = ['Runtime', 'Vector Search', 'Traces', 'Memory DB', 'Network'];
-        // Only a single depth of analysis is implemented. Accepting `--depth full`
-        // and quietly running the quick analysis discards the user's request with
-        // no indication it was ignored, so say so instead.
-        const depthRaw = ctx.flags.depth || 'quick';
-        if (depthRaw !== 'quick') {
-            output.writeln(output.warning(`--depth ${depthRaw} is not implemented — running the "quick" analysis. ` +
-                `Only "quick" is supported today.`));
-        }
-        const componentFilter = ctx.flags.component?.trim();
-        const spinner = output.createSpinner({ text: 'Analyzing system...', spinner: 'dots' });
-        spinner.start();
-        const fs = await import('node:fs');
-        const path = await import('node:path');
-        const findings = [];
-        const mem = process.memoryUsage();
-        const heapUsedMB = mem.heapUsed / 1024 / 1024;
-        if (heapUsedMB > 200) {
-            findings.push({ component: 'Runtime', bottleneck: `Heap ${heapUsedMB.toFixed(0)}MB`, severity: output.error('High'), solution: 'Investigate memory leaks or increase --max-old-space-size' });
-        }
-        const configPath = 'monomind.config.json';
-        let config = {};
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        }
-        catch (e) {
-            if (process.env.DEBUG || process.env.MONOMIND_DEBUG)
-                console.error('[performance-bottleneck] failed to parse monomind.config.json:', e);
-        }
-        const perf = (config.performance ?? {});
-        const hnsw = (perf.hnsw ?? {});
-        if (!hnsw.quantization) {
-            findings.push({ component: 'Vector Search', bottleneck: 'No HNSW quantization', severity: output.error('High'), solution: 'Run: monomind performance optimize --apply -t memory' });
-        }
-        const tracesDir = '.monomind/traces';
-        if (fs.existsSync(tracesDir)) {
-            try {
-                const traceFiles = fs.readdirSync(tracesDir);
-                if (traceFiles.length > 500) {
-                    findings.push({ component: 'Traces', bottleneck: `${traceFiles.length} trace files`, severity: output.warning('Medium'), solution: 'Prune old traces: rm .monomind/traces/*.jsonl' });
-                }
-            }
-            catch { /* ok */ }
-        }
-        try {
-            const { bridgeGetDbPath } = await import('../memory/memory-bridge.js');
-            const dbFile = path.join(bridgeGetDbPath(), 'memory.db');
-            const stat = fs.statSync(dbFile).size ?? 0;
-            const sizeMB = stat / 1024 / 1024;
-            if (sizeMB > 100) {
-                findings.push({ component: 'Memory DB', bottleneck: `SQLite ${sizeMB.toFixed(0)}MB`, severity: output.warning('Medium'), solution: 'Run: monomind memory compact' });
-            }
-        }
-        catch { /* no memory.db yet */ }
-        const network = (perf.network ?? {});
-        if (!network.batching) {
-            findings.push({ component: 'Network', bottleneck: 'No request batching', severity: output.info('Low'), solution: 'Run: monomind performance optimize --apply -t latency' });
-        }
-        let results = findings;
-        if (componentFilter) {
-            const known = ANALYZED_COMPONENTS.find(c => c.toLowerCase() === componentFilter.toLowerCase())
-                ?? ANALYZED_COMPONENTS.find(c => c.toLowerCase().includes(componentFilter.toLowerCase()));
-            if (!known) {
-                spinner.fail(`Unknown component "${componentFilter}"`);
-                output.writeln(output.warning(`Analyzed components: ${ANALYZED_COMPONENTS.join(', ')}.`));
-                return { success: false, message: `Unknown component: ${componentFilter}`, exitCode: 1 };
-            }
-            results = findings.filter(f => f.component === known);
-            if (results.length === 0) {
-                results = [{ component: known, bottleneck: 'No bottlenecks detected', severity: output.success('None'), solution: `${known} is performing well` }];
-            }
-        }
-        else if (results.length === 0) {
-            results = [{ component: 'System', bottleneck: 'No bottlenecks detected', severity: output.success('None'), solution: 'System is performing well' }];
-        }
-        spinner.succeed(`Analysis complete — ${results.length} finding(s)`);
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'component', header: 'Component', width: 20 },
-                { key: 'bottleneck', header: 'Bottleneck', width: 25 },
-                { key: 'severity', header: 'Severity', width: 12 },
-                { key: 'solution', header: 'Solution', width: 50 },
-            ],
-            data: results,
-        });
-        return { success: true };
-    },
-};
-// Main performance command
-export const performanceCommand = {
-    name: 'performance',
-    description: 'Performance profiling, benchmarking, optimization, metrics',
-    aliases: ['perf'],
-    subcommands: [benchmarkCommand, profileCommand, metricsCommand, bottleneckCommand],
-    examples: [
-        { command: 'monomind performance benchmark', description: 'Run benchmarks' },
-        { command: 'monomind performance profile', description: 'Profile application' },
-        { command: 'monomind perf metrics', description: 'View metrics (alias)' },
-    ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('MonoMind Performance Suite'));
-        output.writeln(output.dim('Advanced performance profiling and optimization'));
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            'benchmark  - Run performance benchmarks (WASM, neural, search)',
-            'profile    - Profile CPU, memory, I/O usage',
-            'metrics    - View and export performance metrics',
-            'bottleneck - Identify performance bottlenecks',
-        ]);
-        output.writeln();
-        output.writeln('Performance Targets:');
-        output.printList([
-            'HNSW Search: O(log n) vs O(n) brute force (pure-JS)',
-            'Memory: 50-75% reduction with quantization',
-        ]);
-        output.writeln();
-        output.writeln(output.dim('github.com/monoes/monomind'));
-        return { success: true };
-    },
-};
-export default performanceCommand;
-//# sourceMappingURL=performance.js.map