kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/performance.js

@@ -4,467 +4,595 @@
  *
  * Created with ❤️ by ruv.io
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { output } from '../output.js';
 // Benchmark subcommand - REAL measurements
-const benchmarkCommand = {
+var 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' },
+        { 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: 'claude-flow performance benchmark -s neural', description: 'Benchmark neural operations' },
         { command: 'claude-flow performance benchmark -i 1000', description: 'Run with 1000 iterations' },
     ],
-    action: async (ctx) => {
-        const suite = ctx.flags.suite || 'all';
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
-        const warmup = parseInt(ctx.flags.warmup || '10', 10);
-        const outputFormat = ctx.flags.output || '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;
-            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: mean < 10 ? output.success('Target met') : output.warning('Below target'),
-            });
-        }
-        // 2. Flash Attention-style Batch Operations
-        if (suite === 'all' || suite === 'wasm') {
-            spinner.setText('Benchmarking Flash Attention batch 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;
-            results.push({
-                operation: 'Flash Attention',
-                mean: `${mean.toFixed(3)}ms`,
-                p95: `${percentile(flashTimes, 95).toFixed(3)}ms`,
-                p99: `${percentile(flashTimes, 99).toFixed(3)}ms`,
-                improvement: speedup > 1 ? output.success(`${speedup.toFixed(2)}x`) : output.dim(`${speedup.toFixed(2)}x`),
-            });
-        }
-        // 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 });
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var suite, iterations, warmup, outputFormat, spinner, _a, generateEmbedding, batchCosineSim, flashAttentionSearch, getHNSWStatus, storeEntry, searchEntries, _b, benchmarkAdaptation, initializeIntelligence, results, startTotal, percentile, embedTimes, i, i, start, mean, flashTimes, testVectors, queryVector, i, i, start, mean, baselineMs, speedup, hnswStatus, searchTimes, testQueries, _i, _c, q, i, query, start, mean, baselineBruteForce, speedup, sonaResult, storeTimes, i, start, mean, totalTime, allTargetsMet;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    suite = ctx.flags.suite || 'all';
+                    iterations = parseInt(ctx.flags.iterations || '100', 10);
+                    warmup = parseInt(ctx.flags.warmup || '10', 10);
+                    outputFormat = ctx.flags.output || 'text';
+                    output.writeln();
+                    output.writeln(output.bold('Performance Benchmark (Real Measurements)'));
+                    output.writeln(output.dim('─'.repeat(60)));
+                    spinner = output.createSpinner({ text: "Running " + suite + " benchmarks...", spinner: 'dots' });
+                    spinner.start();
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 1:
+                    _a = _d.sent(), generateEmbedding = _a.generateEmbedding, batchCosineSim = _a.batchCosineSim, flashAttentionSearch = _a.flashAttentionSearch, getHNSWStatus = _a.getHNSWStatus, storeEntry = _a.storeEntry, searchEntries = _a.searchEntries;
+                    return [4 /*yield*/, import('../memory/intelligence.js')];
+                case 2:
+                    _b = _d.sent(), benchmarkAdaptation = _b.benchmarkAdaptation, initializeIntelligence = _b.initializeIntelligence;
+                    results = [];
+                    startTotal = Date.now();
+                    percentile = function (arr, p) {
+                        var sorted = __spreadArray([], arr, true).sort(function (a, b) { return a - b; });
+                        var idx = Math.ceil((p / 100) * sorted.length) - 1;
+                        return sorted[Math.max(0, idx)];
+                    };
+                    if (!(suite === 'all' || suite === 'neural' || suite === 'memory')) return [3 /*break*/, 11];
+                    spinner.setText('Benchmarking embedding generation...');
+                    embedTimes = [];
+                    i = 0;
+                    _d.label = 3;
+                case 3:
+                    if (!(i < warmup)) return [3 /*break*/, 6];
+                    return [4 /*yield*/, generateEmbedding("warmup text " + i)];
+                case 4:
+                    _d.sent();
+                    _d.label = 5;
+                case 5:
+                    i++;
+                    return [3 /*break*/, 3];
+                case 6:
+                    i = 0;
+                    _d.label = 7;
+                case 7:
+                    if (!(i < iterations)) return [3 /*break*/, 10];
+                    start = performance.now();
+                    return [4 /*yield*/, generateEmbedding("benchmark text number " + i + " with some varied content")];
+                case 8:
+                    _d.sent();
+                    embedTimes.push(performance.now() - start);
+                    _d.label = 9;
+                case 9:
+                    i++;
+                    return [3 /*break*/, 7];
+                case 10:
+                    mean = embedTimes.reduce(function (a, b) { return a + b; }, 0) / embedTimes.length;
+                    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: mean < 10 ? output.success('Target met') : output.warning('Below target')
+                    });
+                    _d.label = 11;
+                case 11:
+                    // 2. Flash Attention-style Batch Operations
+                    if (suite === 'all' || suite === 'wasm') {
+                        spinner.setText('Benchmarking Flash Attention batch ops...');
+                        flashTimes = [];
+                        testVectors = Array.from({ length: 100 }, function () {
+                            return new Float32Array(Array.from({ length: 384 }, function () { return Math.random(); }));
+                        });
+                        queryVector = new Float32Array(Array.from({ length: 384 }, function () { return Math.random(); }));
+                        // Warmup
+                        for (i = 0; i < warmup; i++) {
+                            batchCosineSim(queryVector, testVectors);
+                        }
+                        // Actual measurement
+                        for (i = 0; i < iterations; i++) {
+                            start = performance.now();
+                            flashAttentionSearch(queryVector, testVectors, { k: 10 });
+                            flashTimes.push(performance.now() - start);
+                        }
+                        mean = flashTimes.reduce(function (a, b) { return a + b; }, 0) / flashTimes.length;
+                        baselineMs = 0.05;
+                        speedup = baselineMs / mean;
+                        results.push({
+                            operation: 'Flash Attention',
+                            mean: mean.toFixed(3) + "ms",
+                            p95: percentile(flashTimes, 95).toFixed(3) + "ms",
+                            p99: percentile(flashTimes, 99).toFixed(3) + "ms",
+                            improvement: speedup > 1 ? output.success(speedup.toFixed(2) + "x") : output.dim(speedup.toFixed(2) + "x")
+                        });
+                    }
+                    if (!(suite === 'all' || suite === 'search')) return [3 /*break*/, 21];
+                    spinner.setText('Benchmarking HNSW search...');
+                    hnswStatus = getHNSWStatus();
+                    if (!(hnswStatus.available && hnswStatus.entryCount > 0)) return [3 /*break*/, 20];
+                    searchTimes = [];
+                    testQueries = [
+                        'error handling patterns',
+                        'authentication flow',
+                        'database optimization',
+                        'API design patterns',
+                        'test coverage strategies',
+                    ];
+                    _i = 0, _c = testQueries.slice(0, 2);
+                    _d.label = 12;
+                case 12:
+                    if (!(_i < _c.length)) return [3 /*break*/, 15];
+                    q = _c[_i];
+                    return [4 /*yield*/, searchEntries({ query: q, limit: 10 })];
+                case 13:
+                    _d.sent();
+                    _d.label = 14;
+                case 14:
+                    _i++;
+                    return [3 /*break*/, 12];
+                case 15:
+                    i = 0;
+                    _d.label = 16;
+                case 16:
+                    if (!(i < Math.min(iterations, 50))) return [3 /*break*/, 19];
+                    query = testQueries[i % testQueries.length];
+                    start = performance.now();
+                    return [4 /*yield*/, searchEntries({ query: query, limit: 10 })];
+                case 17:
+                    _d.sent();
                     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);
-                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: speedup > 10 ? output.success(`~${Math.round(speedup)}x`) : output.dim(`${speedup.toFixed(1)}x`),
-                });
-            }
-            else {
-                results.push({
-                    operation: 'HNSW Search',
-                    mean: 'N/A',
-                    p95: 'N/A',
-                    p99: 'N/A',
-                    improvement: output.warning('No index'),
-                });
+                    _d.label = 18;
+                case 18:
+                    i++;
+                    return [3 /*break*/, 16];
+                case 19:
+                    mean = searchTimes.reduce(function (a, b) { return a + b; }, 0) / searchTimes.length;
+                    baselineBruteForce = hnswStatus.entryCount * 0.0005;
+                    speedup = baselineBruteForce / (mean / 1000);
+                    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: speedup > 10 ? output.success("~" + Math.round(speedup) + "x") : output.dim(speedup.toFixed(1) + "x")
+                    });
+                    return [3 /*break*/, 21];
+                case 20:
+                    results.push({
+                        operation: 'HNSW Search',
+                        mean: 'N/A',
+                        p95: 'N/A',
+                        p99: 'N/A',
+                        improvement: output.warning('No index')
+                    });
+                    _d.label = 21;
+                case 21:
+                    if (!(suite === 'all' || suite === 'neural')) return [3 /*break*/, 23];
+                    spinner.setText('Benchmarking SONA adaptation...');
+                    return [4 /*yield*/, initializeIntelligence()];
+                case 22:
+                    _d.sent();
+                    sonaResult = benchmarkAdaptation(iterations);
+                    results.push({
+                        operation: 'SONA Adaptation',
+                        mean: (sonaResult.avgMs * 1000).toFixed(2) + "\u03BCs",
+                        p95: (sonaResult.maxMs * 1000).toFixed(2) + "\u03BCs",
+                        p99: (sonaResult.maxMs * 1000).toFixed(2) + "\u03BCs",
+                        improvement: sonaResult.targetMet ? output.success('<0.05ms ✓') : output.warning('Above target')
+                    });
+                    _d.label = 23;
+                case 23:
+                    if (!(suite === 'all' || suite === 'memory')) return [3 /*break*/, 28];
+                    spinner.setText('Benchmarking memory operations...');
+                    storeTimes = [];
+                    i = 0;
+                    _d.label = 24;
+                case 24:
+                    if (!(i < Math.min(iterations, 20))) return [3 /*break*/, 27];
+                    start = performance.now();
+                    return [4 /*yield*/, storeEntry({
+                            key: "bench_" + Date.now() + "_" + i,
+                            value: "Benchmark test entry " + i + " with some content for testing storage performance",
+                            namespace: 'benchmark',
+                            generateEmbeddingFlag: true
+                        })];
+                case 25:
+                    _d.sent();
+                    storeTimes.push(performance.now() - start);
+                    _d.label = 26;
+                case 26:
+                    i++;
+                    return [3 /*break*/, 24];
+                case 27:
+                    mean = storeTimes.reduce(function (a, b) { return a + b; }, 0) / storeTimes.length;
+                    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: mean < 50 ? output.success('Target met') : output.warning('Slow')
+                    });
+                    _d.label = 28;
+                case 28:
+                    totalTime = ((Date.now() - startTotal) / 1000).toFixed(2);
+                    spinner.succeed("Completed " + iterations + " iterations in " + totalTime + "s");
+                    // Output results
+                    if (outputFormat === 'json') {
+                        output.printJson({ suite: suite, iterations: iterations, totalTime: totalTime + "s", results: 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();
+                        allTargetsMet = results.every(function (r) { return !r.improvement.includes('warning') && !r.improvement.includes('Slow'); });
+                        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 [2 /*return*/, { success: true, data: { results: results, totalTime: totalTime } }];
             }
-        }
-        // 4. SONA Adaptation Benchmark
-        if (suite === 'all' || suite === 'neural') {
-            spinner.setText('Benchmarking SONA adaptation...');
-            await initializeIntelligence();
-            const sonaResult = benchmarkAdaptation(iterations);
-            results.push({
-                operation: 'SONA 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'),
-            });
-        }
-        // 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;
-            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: mean < 50 ? output.success('Target met') : output.warning('Slow'),
-            });
-        }
-        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.improvement.includes('warning') && !r.improvement.includes('Slow'));
-            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 = {
+var 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: [
         { command: 'claude-flow performance profile -t cpu', description: 'Profile CPU usage' },
         { command: 'claude-flow performance profile -d 60', description: 'Profile for 60 seconds' },
     ],
-    action: async (ctx) => {
-        const type = ctx.flags.type || 'all';
-        const duration = parseInt(ctx.flags.duration || '30', 10);
-        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 * 100, 2000)));
-        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') },
-            ],
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var type, duration, spinner, startCpu, startMem, startTime, endCpu, endMem, endTime, elapsedMs, cpuPercent, heapUsedMB, heapTotalMB, rssMB, externalMB, lagStart, eventLoopLag, heapStatus, lagStatus;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    type = ctx.flags.type || 'all';
+                    duration = parseInt(ctx.flags.duration || '30', 10);
+                    output.writeln();
+                    output.writeln(output.bold('Performance Profiler'));
+                    output.writeln(output.dim('─'.repeat(50)));
+                    spinner = output.createSpinner({ text: 'Collecting profile data...', spinner: 'dots' });
+                    spinner.start();
+                    startCpu = process.cpuUsage();
+                    startMem = process.memoryUsage();
+                    startTime = process.hrtime.bigint();
+                    // Sample for a brief period
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, Math.min(duration * 100, 2000)); })];
+                case 1:
+                    // Sample for a brief period
+                    _a.sent();
+                    endCpu = process.cpuUsage(startCpu);
+                    endMem = process.memoryUsage();
+                    endTime = process.hrtime.bigint();
+                    spinner.succeed('Profile complete');
+                    elapsedMs = Number(endTime - startTime) / 1000000;
+                    cpuPercent = ((endCpu.user + endCpu.system) / 1000 / elapsedMs * 100).toFixed(1);
+                    heapUsedMB = (endMem.heapUsed / 1024 / 1024).toFixed(1);
+                    heapTotalMB = (endMem.heapTotal / 1024 / 1024).toFixed(1);
+                    rssMB = (endMem.rss / 1024 / 1024).toFixed(1);
+                    externalMB = (endMem.external / 1024 / 1024).toFixed(1);
+                    lagStart = Date.now();
+                    return [4 /*yield*/, new Promise(function (r) { return setImmediate(r); })];
+                case 2:
+                    _a.sent();
+                    eventLoopLag = (Date.now() - lagStart).toFixed(1);
+                    heapStatus = endMem.heapUsed / endMem.heapTotal > 0.9 ? output.error('High') :
+                        endMem.heapUsed / endMem.heapTotal > 0.7 ? output.warning('Elevated') : output.success('Normal');
+                    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"));
+                    return [2 /*return*/, { success: true }];
+            }
         });
-        output.writeln();
-        output.writeln(output.dim(`Profile duration: ${elapsedMs.toFixed(0)}ms`));
-        return { success: true };
-    },
+    }); }
 };
 // Metrics subcommand
-const metricsCommand = {
+var 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: 'claude-flow performance metrics -t 7d', description: 'Show 7-day metrics' },
         { command: 'claude-flow performance metrics -f prometheus', description: 'Export as Prometheus format' },
     ],
-    action: async (ctx) => {
-        const timeframe = ctx.flags.timeframe || '24h';
-        const format = ctx.flags.format || '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
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var timeframe, format, os, fs, path, memUsage, cpuUsage, uptime, loadAvg, freeMem, totalMem, heapUsedMB, heapTotalMB, rssMB, memPercent, cpuUserMs, cpuSystemMs, cacheHitRate, hnswEntries, getHNSWStatus, status, _a, cacheEntries, cachePath, stats, avgLatencyMs, times, i, start, _b, metrics;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    timeframe = ctx.flags.timeframe || '24h';
+                    format = ctx.flags.format || 'text';
+                    output.writeln();
+                    output.writeln(output.bold("Performance Metrics (" + timeframe + ")"));
+                    output.writeln(output.dim('─'.repeat(50)));
+                    return [4 /*yield*/, import('os')];
+                case 1:
+                    os = _c.sent();
+                    return [4 /*yield*/, import('fs')];
+                case 2:
+                    fs = _c.sent();
+                    return [4 /*yield*/, import('path')];
+                case 3:
+                    path = _c.sent();
+                    memUsage = process.memoryUsage();
+                    cpuUsage = process.cpuUsage();
+                    uptime = process.uptime();
+                    loadAvg = os.loadavg();
+                    freeMem = os.freemem();
+                    totalMem = os.totalmem();
+                    heapUsedMB = (memUsage.heapUsed / 1024 / 1024).toFixed(1);
+                    heapTotalMB = (memUsage.heapTotal / 1024 / 1024).toFixed(1);
+                    rssMB = (memUsage.rss / 1024 / 1024).toFixed(1);
+                    memPercent = ((1 - freeMem / totalMem) * 100).toFixed(1);
+                    cpuUserMs = (cpuUsage.user / 1000).toFixed(0);
+                    cpuSystemMs = (cpuUsage.system / 1000).toFixed(0);
+                    cacheHitRate = 'N/A';
+                    hnswEntries = 0;
+                    _c.label = 4;
+                case 4:
+                    _c.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 5:
+                    getHNSWStatus = (_c.sent()).getHNSWStatus;
+                    status = getHNSWStatus();
+                    hnswEntries = (status === null || status === void 0 ? void 0 : status.entryCount) || 0;
+                    return [3 /*break*/, 7];
+                case 6:
+                    _a = _c.sent();
+                    return [3 /*break*/, 7];
+                case 7:
+                    cacheEntries = 0;
+                    try {
+                        cachePath = path.resolve('.cache/embeddings.db');
+                        if (fs.existsSync(cachePath)) {
+                            stats = fs.statSync(cachePath);
+                            cacheEntries = Math.floor(stats.size / 1600); // Approximate entries
+                        }
+                    }
+                    catch ( /* no cache */_d) { /* no cache */ }
+                    avgLatencyMs = 0;
+                    _c.label = 8;
+                case 8:
+                    _c.trys.push([8, 13, , 14]);
+                    times = [];
+                    i = 0;
+                    _c.label = 9;
+                case 9:
+                    if (!(i < 10)) return [3 /*break*/, 12];
+                    start = performance.now();
+                    return [4 /*yield*/, new Promise(function (r) { return setImmediate(r); })];
+                case 10:
+                    _c.sent(); // Event loop turn
+                    times.push(performance.now() - start);
+                    _c.label = 11;
+                case 11:
+                    i++;
+                    return [3 /*break*/, 9];
+                case 12:
+                    avgLatencyMs = times.reduce(function (a, b) { return a + b; }, 0) / times.length;
+                    return [3 /*break*/, 14];
+                case 13:
+                    _b = _c.sent();
+                    return [3 /*break*/, 14];
+                case 14:
+                    // JSON/Prometheus output
+                    if (format === 'json') {
+                        metrics = {
+                            timestamp: new Date().toISOString(),
+                            timeframe: 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: uptime,
+                                pid: process.pid
+                            },
+                            cache: {
+                                entries: cacheEntries,
+                                hnswEntries: hnswEntries
+                            },
+                            latency: {
+                                avgMs: avgLatencyMs
+                            }
+                        };
+                        output.writeln(JSON.stringify(metrics, null, 2));
+                        return [2 /*return*/, { success: true }];
+                    }
+                    if (format === 'prometheus') {
+                        output.writeln("# HELP claude_flow_heap_used_bytes Heap memory used");
+                        output.writeln("claude_flow_heap_used_bytes " + memUsage.heapUsed);
+                        output.writeln("# HELP claude_flow_heap_total_bytes Total heap memory");
+                        output.writeln("claude_flow_heap_total_bytes " + memUsage.heapTotal);
+                        output.writeln("# HELP claude_flow_rss_bytes Resident set size");
+                        output.writeln("claude_flow_rss_bytes " + memUsage.rss);
+                        output.writeln("# HELP claude_flow_cpu_user_microseconds CPU user time");
+                        output.writeln("claude_flow_cpu_user_microseconds " + cpuUsage.user);
+                        output.writeln("# HELP claude_flow_cpu_system_microseconds CPU system time");
+                        output.writeln("claude_flow_cpu_system_microseconds " + cpuUsage.system);
+                        output.writeln("# HELP claude_flow_cache_entries Embedding cache entries");
+                        output.writeln("claude_flow_cache_entries " + cacheEntries);
+                        output.writeln("# HELP claude_flow_hnsw_entries HNSW index entries");
+                        output.writeln("claude_flow_hnsw_entries " + hnswEntries);
+                        output.writeln("# HELP claude_flow_uptime_seconds Process uptime");
+                        output.writeln("claude_flow_uptime_seconds " + uptime);
+                        return [2 /*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(function (l) { return l.toFixed(2); }).join(', ')));
+                    output.writeln(output.dim("CPUs: " + os.cpus().length + " | Platform: " + os.platform() + " " + os.release()));
+                    return [2 /*return*/, { success: true }];
             }
-        }
-        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 claude_flow_heap_used_bytes Heap memory used`);
-            output.writeln(`claude_flow_heap_used_bytes ${memUsage.heapUsed}`);
-            output.writeln(`# HELP claude_flow_heap_total_bytes Total heap memory`);
-            output.writeln(`claude_flow_heap_total_bytes ${memUsage.heapTotal}`);
-            output.writeln(`# HELP claude_flow_rss_bytes Resident set size`);
-            output.writeln(`claude_flow_rss_bytes ${memUsage.rss}`);
-            output.writeln(`# HELP claude_flow_cpu_user_microseconds CPU user time`);
-            output.writeln(`claude_flow_cpu_user_microseconds ${cpuUsage.user}`);
-            output.writeln(`# HELP claude_flow_cpu_system_microseconds CPU system time`);
-            output.writeln(`claude_flow_cpu_system_microseconds ${cpuUsage.system}`);
-            output.writeln(`# HELP claude_flow_cache_entries Embedding cache entries`);
-            output.writeln(`claude_flow_cache_entries ${cacheEntries}`);
-            output.writeln(`# HELP claude_flow_hnsw_entries HNSW index entries`);
-            output.writeln(`claude_flow_hnsw_entries ${hnswEntries}`);
-            output.writeln(`# HELP claude_flow_uptime_seconds Process uptime`);
-            output.writeln(`claude_flow_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 };
-    },
+    }); }
 };
 // Optimize subcommand
-const optimizeCommand = {
+var optimizeCommand = {
     name: 'optimize',
     description: 'Run performance optimization recommendations',
     options: [
-        { name: 'target', short: 't', type: 'string', description: 'Target: memory, cpu, latency, all', default: 'all' },
+        { name: 'target', short: 't', type: 'string', description: 'Target: memory, cpu, latency, all', "default": 'all' },
         { name: 'apply', short: 'a', type: 'boolean', description: 'Apply recommended optimizations' },
         { name: 'dry-run', short: 'd', type: 'boolean', description: 'Show changes without applying' },
     ],
@@ -472,75 +600,91 @@ const optimizeCommand = {
         { command: 'claude-flow performance optimize -t memory', description: 'Optimize memory usage' },
         { command: 'claude-flow performance optimize --apply', description: 'Apply all optimizations' },
     ],
-    action: async (ctx) => {
-        const target = ctx.flags.target || 'all';
-        output.writeln();
-        output.writeln(output.bold('Performance Optimization'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Analyzing performance...', spinner: 'dots' });
-        spinner.start();
-        await new Promise(r => setTimeout(r, 800));
-        spinner.succeed('Analysis complete');
-        output.writeln();
-        output.writeln(output.bold('Recommendations:'));
-        output.writeln();
-        output.printTable({
-            columns: [
-                { key: 'priority', header: 'Priority', width: 10 },
-                { key: 'area', header: 'Area', width: 15 },
-                { key: 'recommendation', header: 'Recommendation', width: 40 },
-                { key: 'impact', header: 'Impact', width: 15 },
-            ],
-            data: [
-                { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: '+50% reduction' },
-                { priority: output.warning('P1'), area: 'CPU', recommendation: 'Enable WASM SIMD acceleration', impact: '+4x speedup' },
-                { priority: output.warning('P1'), area: 'Latency', recommendation: 'Enable Flash Attention', impact: '+2.49x speedup' },
-                { priority: output.info('P2'), area: 'Cache', recommendation: 'Increase pattern cache size', impact: '+15% hit rate' },
-                { priority: output.info('P2'), area: 'Network', recommendation: 'Enable request batching', impact: '-30% latency' },
-            ],
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var target, spinner;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    target = ctx.flags.target || 'all';
+                    output.writeln();
+                    output.writeln(output.bold('Performance Optimization'));
+                    output.writeln(output.dim('─'.repeat(50)));
+                    spinner = output.createSpinner({ text: 'Analyzing performance...', spinner: 'dots' });
+                    spinner.start();
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 800); })];
+                case 1:
+                    _a.sent();
+                    spinner.succeed('Analysis complete');
+                    output.writeln();
+                    output.writeln(output.bold('Recommendations:'));
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'priority', header: 'Priority', width: 10 },
+                            { key: 'area', header: 'Area', width: 15 },
+                            { key: 'recommendation', header: 'Recommendation', width: 40 },
+                            { key: 'impact', header: 'Impact', width: 15 },
+                        ],
+                        data: [
+                            { priority: output.error('P0'), area: 'Memory', recommendation: 'Enable HNSW index quantization', impact: '+50% reduction' },
+                            { priority: output.warning('P1'), area: 'CPU', recommendation: 'Enable WASM SIMD acceleration', impact: '+4x speedup' },
+                            { priority: output.warning('P1'), area: 'Latency', recommendation: 'Enable Flash Attention', impact: '+2.49x speedup' },
+                            { priority: output.info('P2'), area: 'Cache', recommendation: 'Increase pattern cache size', impact: '+15% hit rate' },
+                            { priority: output.info('P2'), area: 'Network', recommendation: 'Enable request batching', impact: '-30% latency' },
+                        ]
+                    });
+                    return [2 /*return*/, { success: true }];
+            }
         });
-        return { success: true };
-    },
+    }); }
 };
 // Bottleneck subcommand
-const bottleneckCommand = {
+var 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' },
+        { name: 'depth', short: 'd', type: 'string', description: 'Analysis depth: quick, full', "default": 'quick' },
     ],
     examples: [
         { command: 'claude-flow performance bottleneck', description: 'Find bottlenecks' },
         { command: 'claude-flow performance bottleneck -d full', description: 'Full analysis' },
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Bottleneck Analysis'));
-        output.writeln(output.dim('─'.repeat(50)));
-        const spinner = output.createSpinner({ text: 'Analyzing system...', spinner: 'dots' });
-        spinner.start();
-        await new Promise(r => setTimeout(r, 600));
-        spinner.succeed('Analysis complete');
-        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: 30 },
-            ],
-            data: [
-                { component: 'Vector Search', bottleneck: 'Linear scan O(n)', severity: output.error('High'), solution: 'Enable HNSW indexing' },
-                { component: 'Neural Inference', bottleneck: 'Sequential attention', severity: output.warning('Medium'), solution: 'Enable Flash Attention' },
-                { component: 'Memory Store', bottleneck: 'Lock contention', severity: output.info('Low'), solution: 'Use sharded storage' },
-            ],
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var spinner;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    output.writeln();
+                    output.writeln(output.bold('Bottleneck Analysis'));
+                    output.writeln(output.dim('─'.repeat(50)));
+                    spinner = output.createSpinner({ text: 'Analyzing system...', spinner: 'dots' });
+                    spinner.start();
+                    return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 600); })];
+                case 1:
+                    _a.sent();
+                    spinner.succeed('Analysis complete');
+                    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: 30 },
+                        ],
+                        data: [
+                            { component: 'Vector Search', bottleneck: 'Linear scan O(n)', severity: output.error('High'), solution: 'Enable HNSW indexing' },
+                            { component: 'Neural Inference', bottleneck: 'Sequential attention', severity: output.warning('Medium'), solution: 'Enable Flash Attention' },
+                            { component: 'Memory Store', bottleneck: 'Lock contention', severity: output.info('Low'), solution: 'Use sharded storage' },
+                        ]
+                    });
+                    return [2 /*return*/, { success: true }];
+            }
         });
-        return { success: true };
-    },
+    }); }
 };
 // Main performance command
-export const performanceCommand = {
+export var performanceCommand = {
     name: 'performance',
     description: 'Performance profiling, benchmarking, optimization, metrics',
     aliases: ['perf'],
@@ -550,30 +694,32 @@ export const performanceCommand = {
         { command: 'claude-flow performance profile', description: 'Profile application' },
         { command: 'claude-flow perf metrics', description: 'View metrics (alias)' },
     ],
-    action: async () => {
-        output.writeln();
-        output.writeln(output.bold('KynjalFlow 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',
-            'optimize   - Get optimization recommendations',
-            'bottleneck - Identify performance bottlenecks',
-        ]);
-        output.writeln();
-        output.writeln('Performance Targets:');
-        output.printList([
-            'HNSW Search: 150x-12,500x faster than brute force',
-            'Flash Attention: 2.49x-7.47x speedup',
-            'Memory: 50-75% reduction with quantization',
-        ]);
-        output.writeln();
-        output.writeln(output.dim('Created with ❤️ by ruv.io'));
-        return { success: true };
-    },
+    action: function () { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('RuFlo 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',
+                'optimize   - Get optimization recommendations',
+                'bottleneck - Identify performance bottlenecks',
+            ]);
+            output.writeln();
+            output.writeln('Performance Targets:');
+            output.printList([
+                'HNSW Search: 150x-12,500x faster than brute force',
+                'Flash Attention: 2.49x-7.47x speedup',
+                'Memory: 50-75% reduction with quantization',
+            ]);
+            output.writeln();
+            output.writeln(output.dim('Created with ❤️ by ruv.io'));
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default performanceCommand;
 //# sourceMappingURL=performance.js.map