@monoes/monomindcli 2.9.22 → 2.9.24

package/dist/src/commands/performance.js

@@ -10,13 +10,34 @@ 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: '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' },
+        {
+            name: 'output',
+            short: 'o',
+            type: 'string',
+            description: 'Output format: text, json',
+            default: 'text',
+        },
     ],
     examples: [
-        { command: 'monomind performance benchmark -s neural', description: 'Benchmark neural operations' },
+        {
+            command: 'monomind performance benchmark -s neural',
+            description: 'Benchmark neural operations',
+        },
         { command: 'monomind performance benchmark -i 1000', description: 'Run with 1000 iterations' },
     ],
     action: async (ctx) => {
@@ -34,19 +55,31 @@ const benchmarkCommand = {
         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 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 VALID_OUTPUT_FORMATS = new Set(['text', 'json']);
         const outputFormat = VALID_OUTPUT_FORMATS.has(outputFormatRaw) ? outputFormatRaw : 'text';
+        if (outputFormatRaw === 'csv') {
+            output.writeln(output.warning('csv output is not implemented — printing 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' });
+        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');
+        // `hasTarget: false` marks entries that only report a measured latency,
+        // with no baseline to compare against — they're excluded from the
+        // "all targets met" rollup instead of being scored against an invented
+        // baseline constant.
         const results = [];
         const startTotal = Date.now();
         // Helper to compute percentiles
@@ -98,24 +131,25 @@ const benchmarkCommand = {
                 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;
+            // No independent baseline implementation exists to compare against —
+            // flashAttentionSearch is a thin wrapper around batchCosineSim, so
+            // there's nothing slower to measure a real speedup off of. Report the
+            // measured latency only, without a fabricated speedup ratio.
             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,
+                improvement: output.dim('measured (no baseline)'),
+                targetMet: true,
+                hasTarget: false,
             });
         }
         // 3. HNSW Search Benchmark
         if (suite === 'all' || suite === 'search') {
             spinner.setText('Benchmarking HNSW search...');
-            const hnswStatus = getHNSWStatus();
-            if (hnswStatus.available && hnswStatus.entryCount > 0) {
+            const hnswStatus = await getHNSWStatus();
+            if (hnswStatus?.available && hnswStatus.entryCount > 0) {
                 const searchTimes = [];
                 const testQueries = [
                     'error handling patterns',
@@ -136,18 +170,17 @@ const benchmarkCommand = {
                     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) faster
-                const baselineBruteForce = hnswStatus.entryCount * 0.0005;
-                const speedup = baselineBruteForce / (mean / 1000);
-                const hnswTargetMet = speedup > 10;
+                // No brute-force baseline is measured over the actual stored entries
+                // here, so we report the measured latency only rather than a
+                // speedup ratio computed against an invented per-comparison cost.
                 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,
+                    improvement: output.dim('measured (no baseline)'),
+                    targetMet: true,
+                    hasTarget: false,
                 });
             }
             else {
@@ -171,7 +204,9 @@ const benchmarkCommand = {
                 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'),
+                improvement: sonaResult.targetMet
+                    ? output.success('<0.05ms ✓')
+                    : output.warning('Above target'),
                 targetMet: sonaResult.targetMet,
             });
         }
@@ -220,7 +255,7 @@ const benchmarkCommand = {
                 data: results,
             });
             output.writeln();
-            const allTargetsMet = results.every(r => r.targetMet);
+            const allTargetsMet = results.filter((r) => r.hasTarget !== false).every((r) => r.targetMet);
             output.printBox([
                 `Suite: ${suite}`,
                 `Iterations: ${iterations}`,
@@ -237,8 +272,20 @@ 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: '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: [
@@ -248,7 +295,7 @@ const profileCommand = {
     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 _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();
@@ -258,30 +305,36 @@ const profileCommand = {
         spinner.start();
         // Collect real metrics
         const startCpu = process.cpuUsage();
-        const startMem = process.memoryUsage();
+        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)));
+        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 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));
+        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');
+        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: [
@@ -291,12 +344,37 @@ const profileCommand = {
                 { 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: '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') },
+                {
+                    metric: 'Node.js Uptime',
+                    current: `${process.uptime().toFixed(1)}s`,
+                    peak: '-',
+                    status: output.success('Running'),
+                },
             ],
         });
         output.writeln();
@@ -315,10 +393,10 @@ const profileCommand = {
                 },
                 event_loop_lag_ms: parseFloat(eventLoopLag),
             };
-            const fs = await import('fs');
-            const path = await import('path');
+            const fs = await import('node:fs');
+            const path = await import('node:path');
             const resolved = path.resolve(outputFile);
-            fs.writeFileSync(resolved, JSON.stringify(profileData, null, 2) + '\n');
+            fs.writeFileSync(resolved, `${JSON.stringify(profileData, null, 2)}\n`);
             output.writeln(output.success(`Profile data saved to ${resolved}`));
         }
         return { success: true };
@@ -329,13 +407,28 @@ 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: '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' },
+        {
+            command: 'monomind performance metrics -f prometheus',
+            description: 'Export as Prometheus format',
+        },
     ],
     action: async (ctx) => {
         const timeframeRaw = ctx.flags.timeframe || '24h';
@@ -345,11 +438,12 @@ const metricsCommand = {
         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.bold(`Performance Metrics (snapshot)`));
         output.writeln(output.dim('─'.repeat(50)));
-        const os = await import('os');
-        const fs = await import('fs');
-        const path = await import('path');
+        if (ctx.flags.timeframe) {
+            output.writeln(output.warning('--timeframe is not used for filtering: time history not recorded yet. Showing a live snapshot instead.'));
+        }
+        const os = await import('node:os');
         // Real system metrics
         const memUsage = process.memoryUsage();
         const cpuUsage = process.cpuUsage();
@@ -363,38 +457,43 @@ const metricsCommand = {
         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);
+        const _cpuSystemMs = (cpuUsage.system / 1000).toFixed(0);
         // Try to get HNSW/cache stats from real data
-        let cacheHitRate = 'N/A';
+        const _cacheHitRate = 'N/A';
         let hnswEntries = 0;
         try {
             const { getHNSWStatus } = await import('../memory/memory-initializer.js');
-            const status = getHNSWStatus();
+            const status = await getHNSWStatus();
             hnswEntries = status?.entryCount || 0;
         }
-        catch { /* HNSW not initialized */ }
-        // Try to get real cache stats
+        catch {
+            /* HNSW not initialized */
+        }
+        // Try to get real cache stats — a real SELECT COUNT(*) via the memory
+        // backend, not a file-size approximation.
         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
-            }
+            const { bridgeGetBackendStats } = await import('../memory/memory-bridge.js');
+            const stats = await bridgeGetBackendStats();
+            cacheEntries = stats?.totalEntries ?? 0;
+        }
+        catch {
+            /* no cache */
         }
-        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
+                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 */ }
+        catch {
+            /* timing failed */
+        }
         // JSON/Prometheus output
         if (format === 'json') {
             const metrics = {
@@ -459,7 +558,9 @@ const metricsCommand = {
                     metric: 'Heap Memory',
                     current: `${heapUsedMB} MB`,
                     limit: `${heapTotalMB} MB`,
-                    status: parseFloat(heapUsedMB) < parseFloat(heapTotalMB) * 0.8 ? output.success('OK') : output.warning('High'),
+                    status: parseFloat(heapUsedMB) < parseFloat(heapTotalMB) * 0.8
+                        ? output.success('OK')
+                        : output.warning('High'),
                 },
                 {
                     metric: 'RSS Memory',
@@ -506,7 +607,7 @@ const metricsCommand = {
             ],
         });
         output.writeln();
-        output.writeln(output.dim(`Load Average: ${loadAvg.map(l => l.toFixed(2)).join(', ')}`));
+        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 };
     },
@@ -517,11 +618,20 @@ const bottleneckCommand = {
     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' },
+        {
+            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' },
+        {
+            command: 'monomind performance bottleneck -c network',
+            description: 'Only the Network component',
+        },
     ],
     action: async (ctx) => {
         output.writeln();
@@ -547,7 +657,12 @@ const bottleneckCommand = {
         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' });
+            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 = {};
@@ -561,17 +676,29 @@ const bottleneckCommand = {
         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' });
+            findings.push({
+                component: 'Vector Search',
+                bottleneck: 'No HNSW quantization',
+                severity: output.error('High'),
+                solution: 'Run: monomind hooks intelligence optimize --method quantize',
+            });
         }
         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' });
+                    findings.push({
+                        component: 'Traces',
+                        bottleneck: `${traceFiles.length} trace files`,
+                        severity: output.warning('Medium'),
+                        solution: 'Prune old traces: rm .monomind/traces/*.jsonl',
+                    });
                 }
             }
-            catch { /* ok */ }
+            catch {
+                /* ok */
+            }
         }
         try {
             const { bridgeGetDbPath } = await import('../memory/memory-bridge.js');
@@ -579,30 +706,56 @@ const bottleneckCommand = {
             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' });
+                findings.push({
+                    component: 'Memory DB',
+                    bottleneck: `SQLite ${sizeMB.toFixed(0)}MB`,
+                    severity: output.warning('Medium'),
+                    solution: 'No automated SQLite compaction exists yet — prune stale entries with: monomind memory delete --key <key> --namespace <ns>',
+                });
             }
         }
-        catch { /* no memory.db yet */ }
+        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' });
+            findings.push({
+                component: 'Network',
+                bottleneck: 'No request batching',
+                severity: output.info('Low'),
+                solution: 'No automated fix available — request batching requires a manual code change, not exposed via any CLI command yet',
+            });
         }
         let results = findings;
         if (componentFilter) {
-            const known = ANALYZED_COMPONENTS.find(c => c.toLowerCase() === componentFilter.toLowerCase())
-                ?? ANALYZED_COMPONENTS.find(c => c.toLowerCase().includes(componentFilter.toLowerCase()));
+            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);
+            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` }];
+                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' }];
+            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();