kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/benchmark.js

@@ -4,425 +4,574 @@
  *
  * @module v3/cli/commands/benchmark
  */
+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';
 import { writeFileSync, existsSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // ============================================================================
 // Pretrain Benchmark Subcommand
 // ============================================================================
-const pretrainCommand = {
+var pretrainCommand = {
     name: 'pretrain',
     description: 'Benchmark self-learning pre-training system (SONA, EWC++, MoE)',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark 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', default: 'text' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark 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', "default": 'text' },
         { name: 'save', short: 's', type: 'string', description: 'Save results to file' },
-        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output', default: 'false' },
+        { name: 'verbose', short: 'v', type: 'boolean', description: 'Verbose output', "default": 'false' },
     ],
     examples: [
         { command: 'claude-flow benchmark pretrain', description: 'Run pre-training benchmarks' },
         { command: 'claude-flow benchmark pretrain -i 500 --save results.json', description: 'Extended benchmark with results saved' },
         { command: 'claude-flow benchmark pretrain -o json', description: 'Output results as JSON' },
     ],
-    action: async (ctx) => {
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
-        const warmup = parseInt(ctx.flags.warmup || '10', 10);
-        const outputFormat = ctx.flags.output || 'text';
-        const saveFile = ctx.flags.save;
-        const verbose = ctx.flags.verbose === true;
-        try {
-            // Dynamically import benchmark suite
-            const { runPretrainBenchmarkSuite } = await import('../benchmarks/pretrain/index.js');
-            const results = await runPretrainBenchmarkSuite({
-                iterations,
-                warmupIterations: warmup,
-                verbose,
-            });
-            // Output as JSON if requested
-            if (outputFormat === 'json') {
-                output.writeln(JSON.stringify(results, null, 2));
-            }
-            // Save to file if requested
-            if (saveFile) {
-                const resultsDir = join(process.cwd(), '.claude-flow', 'benchmarks');
-                if (!existsSync(resultsDir)) {
-                    mkdirSync(resultsDir, { recursive: true });
-                }
-                const savePath = saveFile.startsWith('/') ? saveFile : join(resultsDir, saveFile);
-                writeFileSync(savePath, JSON.stringify(results, null, 2));
-                output.writeln(output.success(`Results saved to ${savePath}`));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var iterations, warmup, outputFormat, saveFile, verbose, runPretrainBenchmarkSuite, results, resultsDir, savePath, allPassed, err_1, errorMsg;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    iterations = parseInt(ctx.flags.iterations || '100', 10);
+                    warmup = parseInt(ctx.flags.warmup || '10', 10);
+                    outputFormat = ctx.flags.output || 'text';
+                    saveFile = ctx.flags.save;
+                    verbose = ctx.flags.verbose === true;
+                    _a.label = 1;
+                case 1:
+                    _a.trys.push([1, 4, , 5]);
+                    return [4 /*yield*/, import('../benchmarks/pretrain/index.js')];
+                case 2:
+                    runPretrainBenchmarkSuite = (_a.sent()).runPretrainBenchmarkSuite;
+                    return [4 /*yield*/, runPretrainBenchmarkSuite({
+                            iterations: iterations,
+                            warmupIterations: warmup,
+                            verbose: verbose
+                        })];
+                case 3:
+                    results = _a.sent();
+                    // Output as JSON if requested
+                    if (outputFormat === 'json') {
+                        output.writeln(JSON.stringify(results, null, 2));
+                    }
+                    // Save to file if requested
+                    if (saveFile) {
+                        resultsDir = join(process.cwd(), '.claude-flow', 'benchmarks');
+                        if (!existsSync(resultsDir)) {
+                            mkdirSync(resultsDir, { recursive: true });
+                        }
+                        savePath = saveFile.startsWith('/') ? saveFile : join(resultsDir, saveFile);
+                        writeFileSync(savePath, JSON.stringify(results, null, 2));
+                        output.writeln(output.success("Results saved to " + savePath));
+                    }
+                    allPassed = results.results.every(function (r) { return r.targetMet; });
+                    return [2 /*return*/, {
+                            success: true,
+                            message: allPassed
+                                ? 'All benchmark targets met!'
+                                : results.results.filter(function (r) { return r.targetMet; }).length + "/" + results.results.length + " targets met"
+                        }];
+                case 4:
+                    err_1 = _a.sent();
+                    errorMsg = err_1 instanceof Error ? err_1.message : String(err_1);
+                    output.writeln(output.error("Benchmark failed: " + errorMsg));
+                    return [2 /*return*/, {
+                            success: false,
+                            message: "Benchmark failed: " + errorMsg
+                        }];
+                case 5: return [2 /*return*/];
             }
-            const allPassed = results.results.every(r => r.targetMet);
-            return {
-                success: true,
-                message: allPassed
-                    ? 'All benchmark targets met!'
-                    : `${results.results.filter(r => r.targetMet).length}/${results.results.length} targets met`,
-            };
-        }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            output.writeln(output.error(`Benchmark failed: ${errorMsg}`));
-            return {
-                success: false,
-                message: `Benchmark failed: ${errorMsg}`,
-            };
-        }
-    },
+        });
+    }); }
 };
 // ============================================================================
 // Neural Benchmark Subcommand
 // ============================================================================
-const neuralCommand = {
+var neuralCommand = {
     name: 'neural',
     description: 'Benchmark neural operations (embeddings, WASM, Flash Attention)',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'dimension', short: 'd', type: 'number', description: 'Embedding dimension', default: '384' },
-        { name: 'vectors', short: 'n', type: 'number', description: 'Number of test vectors', default: '1000' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', "default": '100' },
+        { name: 'dimension', short: 'd', type: 'number', description: 'Embedding dimension', "default": '384' },
+        { name: 'vectors', short: 'n', type: 'number', description: 'Number of test vectors', "default": '1000' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', "default": 'text' },
     ],
     examples: [
         { command: 'claude-flow benchmark neural', description: 'Run neural benchmarks' },
         { command: 'claude-flow benchmark neural -d 768 -n 5000', description: 'Higher dimension, more vectors' },
     ],
-    action: async (ctx) => {
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
-        const dimension = parseInt(ctx.flags.dimension || '384', 10);
-        const numVectors = parseInt(ctx.flags.vectors || '1000', 10);
-        const outputFormat = ctx.flags.output || 'text';
-        output.writeln();
-        output.writeln(output.bold('Neural Operations Benchmark'));
-        output.writeln(output.dim('─'.repeat(60)));
-        output.writeln(`Iterations: ${iterations} | Dimension: ${dimension} | Vectors: ${numVectors}`);
-        output.writeln();
-        const spinner = output.createSpinner({ text: 'Running neural benchmarks...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const { performance } = await import('node:perf_hooks');
-            // Helper functions
-            const percentile = (sorted, p) => {
-                const idx = Math.ceil((p / 100) * sorted.length) - 1;
-                return sorted[Math.max(0, idx)];
-            };
-            const results = [];
-            // 1. Embedding Generation
-            spinner.setText('Benchmarking embedding generation...');
-            let generateEmbedding;
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                generateEmbedding = memory.generateEmbedding;
-            }
-            catch {
-                generateEmbedding = async (text) => {
-                    const emb = [];
-                    for (let i = 0; i < dimension; i++) {
-                        emb.push(Math.sin(text.charCodeAt(i % text.length) * (i + 1)));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var iterations, dimension, numVectors, outputFormat, spinner, performance, percentile, results, generateEmbedding, memory, _a, embedTimes, i, start, embedMean, embedSorted, batchCosineSim, memory, _b, query, vectors, cosineTimes, i, start, cosineMean, cosineSorted, flashTimes, memory, i, start, _c, flashMean, flashSorted, _i, results_1, r, status, allPassed, err_2, errorMsg;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    iterations = parseInt(ctx.flags.iterations || '100', 10);
+                    dimension = parseInt(ctx.flags.dimension || '384', 10);
+                    numVectors = parseInt(ctx.flags.vectors || '1000', 10);
+                    outputFormat = ctx.flags.output || 'text';
+                    output.writeln();
+                    output.writeln(output.bold('Neural Operations Benchmark'));
+                    output.writeln(output.dim('─'.repeat(60)));
+                    output.writeln("Iterations: " + iterations + " | Dimension: " + dimension + " | Vectors: " + numVectors);
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Running neural benchmarks...', spinner: 'dots' });
+                    spinner.start();
+                    _d.label = 1;
+                case 1:
+                    _d.trys.push([1, 19, , 20]);
+                    return [4 /*yield*/, import('node:perf_hooks')];
+                case 2:
+                    performance = (_d.sent()).performance;
+                    percentile = function (sorted, p) {
+                        var idx = Math.ceil((p / 100) * sorted.length) - 1;
+                        return sorted[Math.max(0, idx)];
+                    };
+                    results = [];
+                    // 1. Embedding Generation
+                    spinner.setText('Benchmarking embedding generation...');
+                    generateEmbedding = void 0;
+                    _d.label = 3;
+                case 3:
+                    _d.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 4:
+                    memory = _d.sent();
+                    generateEmbedding = memory.generateEmbedding;
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = _d.sent();
+                    generateEmbedding = function (text) { return __awaiter(void 0, void 0, void 0, function () {
+                        var emb, i;
+                        return __generator(this, function (_a) {
+                            emb = [];
+                            for (i = 0; i < dimension; i++) {
+                                emb.push(Math.sin(text.charCodeAt(i % text.length) * (i + 1)));
+                            }
+                            return [2 /*return*/, { embedding: emb, dimensions: dimension, model: 'fallback' }];
+                        });
+                    }); };
+                    return [3 /*break*/, 6];
+                case 6:
+                    embedTimes = [];
+                    i = 0;
+                    _d.label = 7;
+                case 7:
+                    if (!(i < iterations)) return [3 /*break*/, 10];
+                    start = performance.now();
+                    return [4 /*yield*/, generateEmbedding("benchmark text " + i)];
+                case 8:
+                    _d.sent();
+                    embedTimes.push(performance.now() - start);
+                    _d.label = 9;
+                case 9:
+                    i++;
+                    return [3 /*break*/, 7];
+                case 10:
+                    embedMean = embedTimes.reduce(function (a, b) { return a + b; }, 0) / embedTimes.length;
+                    embedSorted = __spreadArray([], embedTimes, true).sort(function (a, b) { return a - b; });
+                    results.push({
+                        name: 'Embedding Generation',
+                        mean: embedMean,
+                        p95: percentile(embedSorted, 95),
+                        p99: percentile(embedSorted, 99),
+                        target: 5.0,
+                        met: embedMean <= 5.0
+                    });
+                    // 2. Batch Cosine Similarity
+                    spinner.setText('Benchmarking batch cosine similarity...');
+                    batchCosineSim = void 0;
+                    _d.label = 11;
+                case 11:
+                    _d.trys.push([11, 13, , 14]);
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 12:
+                    memory = _d.sent();
+                    batchCosineSim = memory.batchCosineSim;
+                    return [3 /*break*/, 14];
+                case 13:
+                    _b = _d.sent();
+                    batchCosineSim = function (query, vectors) {
+                        var res = new Float32Array(vectors.length);
+                        for (var i = 0; i < vectors.length; i++) {
+                            var dot = 0, nQ = 0, nV = 0;
+                            for (var j = 0; j < query.length; j++) {
+                                dot += query[j] * vectors[i][j];
+                                nQ += query[j] * query[j];
+                                nV += vectors[i][j] * vectors[i][j];
+                            }
+                            res[i] = dot / (Math.sqrt(nQ) * Math.sqrt(nV));
+                        }
+                        return res;
+                    };
+                    return [3 /*break*/, 14];
+                case 14:
+                    query = new Float32Array(dimension).map(function () { return Math.random(); });
+                    vectors = Array.from({ length: numVectors }, function () {
+                        return new Float32Array(dimension).map(function () { return Math.random(); });
+                    });
+                    cosineTimes = [];
+                    for (i = 0; i < Math.min(iterations, 50); i++) {
+                        start = performance.now();
+                        batchCosineSim(query, vectors);
+                        cosineTimes.push(performance.now() - start);
                     }
-                    return { embedding: emb, dimensions: dimension, model: 'fallback' };
-                };
-            }
-            const embedTimes = [];
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await generateEmbedding(`benchmark text ${i}`);
-                embedTimes.push(performance.now() - start);
-            }
-            const embedMean = embedTimes.reduce((a, b) => a + b, 0) / embedTimes.length;
-            const embedSorted = [...embedTimes].sort((a, b) => a - b);
-            results.push({
-                name: 'Embedding Generation',
-                mean: embedMean,
-                p95: percentile(embedSorted, 95),
-                p99: percentile(embedSorted, 99),
-                target: 5.0,
-                met: embedMean <= 5.0,
-            });
-            // 2. Batch Cosine Similarity
-            spinner.setText('Benchmarking batch cosine similarity...');
-            let batchCosineSim;
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                batchCosineSim = memory.batchCosineSim;
-            }
-            catch {
-                batchCosineSim = (query, vectors) => {
-                    const res = new Float32Array(vectors.length);
-                    for (let i = 0; i < vectors.length; i++) {
-                        let dot = 0, nQ = 0, nV = 0;
-                        for (let j = 0; j < query.length; j++) {
-                            dot += query[j] * vectors[i][j];
-                            nQ += query[j] * query[j];
-                            nV += vectors[i][j] * vectors[i][j];
+                    cosineMean = cosineTimes.reduce(function (a, b) { return a + b; }, 0) / cosineTimes.length;
+                    cosineSorted = __spreadArray([], cosineTimes, true).sort(function (a, b) { return a - b; });
+                    results.push({
+                        name: "Batch Cosine (" + numVectors + " vectors)",
+                        mean: cosineMean,
+                        p95: percentile(cosineSorted, 95),
+                        p99: percentile(cosineSorted, 99),
+                        target: 5.0,
+                        met: cosineMean <= 5.0
+                    });
+                    // 3. Flash Attention Search (if available)
+                    spinner.setText('Benchmarking flash attention search...');
+                    flashTimes = [];
+                    _d.label = 15;
+                case 15:
+                    _d.trys.push([15, 17, , 18]);
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 16:
+                    memory = _d.sent();
+                    if (memory.flashAttentionSearch) {
+                        for (i = 0; i < Math.min(iterations, 50); i++) {
+                            start = performance.now();
+                            memory.flashAttentionSearch(query, vectors, { k: 10 });
+                            flashTimes.push(performance.now() - start);
                         }
-                        res[i] = dot / (Math.sqrt(nQ) * Math.sqrt(nV));
                     }
-                    return res;
-                };
-            }
-            const query = new Float32Array(dimension).map(() => Math.random());
-            const vectors = Array.from({ length: numVectors }, () => new Float32Array(dimension).map(() => Math.random()));
-            const cosineTimes = [];
-            for (let i = 0; i < Math.min(iterations, 50); i++) {
-                const start = performance.now();
-                batchCosineSim(query, vectors);
-                cosineTimes.push(performance.now() - start);
-            }
-            const cosineMean = cosineTimes.reduce((a, b) => a + b, 0) / cosineTimes.length;
-            const cosineSorted = [...cosineTimes].sort((a, b) => a - b);
-            results.push({
-                name: `Batch Cosine (${numVectors} vectors)`,
-                mean: cosineMean,
-                p95: percentile(cosineSorted, 95),
-                p99: percentile(cosineSorted, 99),
-                target: 5.0,
-                met: cosineMean <= 5.0,
-            });
-            // 3. Flash Attention Search (if available)
-            spinner.setText('Benchmarking flash attention search...');
-            const flashTimes = [];
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                if (memory.flashAttentionSearch) {
-                    for (let i = 0; i < Math.min(iterations, 50); i++) {
-                        const start = performance.now();
-                        memory.flashAttentionSearch(query, vectors, { k: 10 });
-                        flashTimes.push(performance.now() - start);
+                    return [3 /*break*/, 18];
+                case 17:
+                    _c = _d.sent();
+                    return [3 /*break*/, 18];
+                case 18:
+                    if (flashTimes.length > 0) {
+                        flashMean = flashTimes.reduce(function (a, b) { return a + b; }, 0) / flashTimes.length;
+                        flashSorted = __spreadArray([], flashTimes, true).sort(function (a, b) { return a - b; });
+                        results.push({
+                            name: 'Flash Attention Search',
+                            mean: flashMean,
+                            p95: percentile(flashSorted, 95),
+                            p99: percentile(flashSorted, 99),
+                            target: 2.0,
+                            met: flashMean <= 2.0
+                        });
                     }
-                }
-            }
-            catch {
-                // Flash attention not available
-            }
-            if (flashTimes.length > 0) {
-                const flashMean = flashTimes.reduce((a, b) => a + b, 0) / flashTimes.length;
-                const flashSorted = [...flashTimes].sort((a, b) => a - b);
-                results.push({
-                    name: 'Flash Attention Search',
-                    mean: flashMean,
-                    p95: percentile(flashSorted, 95),
-                    p99: percentile(flashSorted, 99),
-                    target: 2.0,
-                    met: flashMean <= 2.0,
-                });
-            }
-            spinner.stop();
-            // Display results
-            output.writeln();
-            output.writeln(output.bold('Results'));
-            output.writeln(output.dim('─'.repeat(60)));
-            for (const r of results) {
-                const status = r.met ? output.success('✓') : output.error('✗');
-                output.writeln(`${status} ${r.name}`);
-                output.writeln(`   Mean: ${r.mean.toFixed(3)}ms | p95: ${r.p95.toFixed(3)}ms | p99: ${r.p99.toFixed(3)}ms`);
-                output.writeln(`   Target: ${r.target}ms | Status: ${r.met ? 'Met' : 'Not met'}`);
-                output.writeln();
-            }
-            if (outputFormat === 'json') {
-                output.writeln(JSON.stringify(results, null, 2));
+                    spinner.stop();
+                    // Display results
+                    output.writeln();
+                    output.writeln(output.bold('Results'));
+                    output.writeln(output.dim('─'.repeat(60)));
+                    for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
+                        r = results_1[_i];
+                        status = r.met ? output.success('✓') : output.error('✗');
+                        output.writeln(status + " " + r.name);
+                        output.writeln("   Mean: " + r.mean.toFixed(3) + "ms | p95: " + r.p95.toFixed(3) + "ms | p99: " + r.p99.toFixed(3) + "ms");
+                        output.writeln("   Target: " + r.target + "ms | Status: " + (r.met ? 'Met' : 'Not met'));
+                        output.writeln();
+                    }
+                    if (outputFormat === 'json') {
+                        output.writeln(JSON.stringify(results, null, 2));
+                    }
+                    allPassed = results.every(function (r) { return r.met; });
+                    return [2 /*return*/, {
+                            success: true,
+                            message: allPassed ? 'All neural benchmarks passed!' : 'Some benchmarks below target'
+                        }];
+                case 19:
+                    err_2 = _d.sent();
+                    spinner.stop();
+                    errorMsg = err_2 instanceof Error ? err_2.message : String(err_2);
+                    output.writeln(output.error("Neural benchmark failed: " + errorMsg));
+                    return [2 /*return*/, {
+                            success: false,
+                            message: "Neural benchmark failed: " + errorMsg
+                        }];
+                case 20: return [2 /*return*/];
             }
-            const allPassed = results.every(r => r.met);
-            return {
-                success: true,
-                message: allPassed ? 'All neural benchmarks passed!' : 'Some benchmarks below target',
-            };
-        }
-        catch (err) {
-            spinner.stop();
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            output.writeln(output.error(`Neural benchmark failed: ${errorMsg}`));
-            return {
-                success: false,
-                message: `Neural benchmark failed: ${errorMsg}`,
-            };
-        }
-    },
+        });
+    }); }
 };
 // ============================================================================
 // Memory Benchmark Subcommand
 // ============================================================================
-const memoryCommand = {
+var memoryCommand = {
     name: 'memory',
     description: 'Benchmark memory operations (HNSW search, store, retrieve)',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '100' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', "default": '100' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', "default": 'text' },
     ],
     examples: [
         { command: 'claude-flow benchmark memory', description: 'Run memory benchmarks' },
     ],
-    action: async (ctx) => {
-        const iterations = parseInt(ctx.flags.iterations || '100', 10);
-        const outputFormat = ctx.flags.output || 'text';
-        output.writeln();
-        output.writeln(output.bold('Memory Operations Benchmark'));
-        output.writeln(output.dim('─'.repeat(60)));
-        const spinner = output.createSpinner({ text: 'Running memory benchmarks...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const { performance } = await import('node:perf_hooks');
-            const percentile = (sorted, p) => {
-                const idx = Math.ceil((p / 100) * sorted.length) - 1;
-                return sorted[Math.max(0, idx)];
-            };
-            const results = [];
-            // Import memory functions
-            let storeEntry;
-            let searchEntries;
-            try {
-                const memory = await import('../memory/memory-initializer.js');
-                storeEntry = memory.storeEntry;
-                searchEntries = memory.searchEntries;
-            }
-            catch {
-                storeEntry = async () => ({ success: true });
-                searchEntries = async () => ({ results: [], searchTime: 0.5 });
-            }
-            // 1. Store benchmark
-            spinner.setText('Benchmarking memory store...');
-            const storeTimes = [];
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await storeEntry({
-                    key: `bench-key-${i}`,
-                    value: `Benchmark value ${i} with some additional content`,
-                    namespace: 'benchmark',
-                });
-                storeTimes.push(performance.now() - start);
-            }
-            const storeMean = storeTimes.reduce((a, b) => a + b, 0) / storeTimes.length;
-            results.push({
-                name: 'Memory Store',
-                mean: storeMean,
-                p95: percentile([...storeTimes].sort((a, b) => a - b), 95),
-                target: 10.0,
-                met: storeMean <= 10.0,
-            });
-            // 2. Search benchmark
-            spinner.setText('Benchmarking memory search...');
-            const queries = [
-                'authentication patterns',
-                'error handling best practices',
-                'performance optimization',
-                'testing strategies',
-                'security vulnerabilities',
-            ];
-            const searchTimes = [];
-            for (let i = 0; i < iterations; i++) {
-                const start = performance.now();
-                await searchEntries({
-                    query: queries[i % queries.length],
-                    namespace: 'benchmark',
-                    limit: 10,
-                });
-                searchTimes.push(performance.now() - start);
-            }
-            const searchMean = searchTimes.reduce((a, b) => a + b, 0) / searchTimes.length;
-            results.push({
-                name: 'Memory Search (HNSW)',
-                mean: searchMean,
-                p95: percentile([...searchTimes].sort((a, b) => a - b), 95),
-                target: 10.0,
-                met: searchMean <= 10.0,
-            });
-            spinner.stop();
-            // Display results
-            output.writeln();
-            output.writeln(output.bold('Results'));
-            output.writeln(output.dim('─'.repeat(60)));
-            for (const r of results) {
-                const status = r.met ? output.success('✓') : output.error('✗');
-                output.writeln(`${status} ${r.name}`);
-                output.writeln(`   Mean: ${r.mean.toFixed(3)}ms | p95: ${r.p95.toFixed(3)}ms | Target: ${r.target}ms`);
-                output.writeln();
-            }
-            if (outputFormat === 'json') {
-                output.writeln(JSON.stringify(results, null, 2));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var iterations, outputFormat, spinner, performance, percentile, results, storeEntry, searchEntries, memory, _a, storeTimes, i, start, storeMean, queries, searchTimes, i, start, searchMean, _i, results_2, r, status, err_3, errorMsg;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    iterations = parseInt(ctx.flags.iterations || '100', 10);
+                    outputFormat = ctx.flags.output || 'text';
+                    output.writeln();
+                    output.writeln(output.bold('Memory Operations Benchmark'));
+                    output.writeln(output.dim('─'.repeat(60)));
+                    spinner = output.createSpinner({ text: 'Running memory benchmarks...', spinner: 'dots' });
+                    spinner.start();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 15, , 16]);
+                    return [4 /*yield*/, import('node:perf_hooks')];
+                case 2:
+                    performance = (_b.sent()).performance;
+                    percentile = function (sorted, p) {
+                        var idx = Math.ceil((p / 100) * sorted.length) - 1;
+                        return sorted[Math.max(0, idx)];
+                    };
+                    results = [];
+                    storeEntry = void 0;
+                    searchEntries = void 0;
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 4:
+                    memory = _b.sent();
+                    storeEntry = memory.storeEntry;
+                    searchEntries = memory.searchEntries;
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = _b.sent();
+                    storeEntry = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, ({ success: true })];
+                    }); }); };
+                    searchEntries = function () { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+                        return [2 /*return*/, ({ results: [], searchTime: 0.5 })];
+                    }); }); };
+                    return [3 /*break*/, 6];
+                case 6:
+                    // 1. Store benchmark
+                    spinner.setText('Benchmarking memory store...');
+                    storeTimes = [];
+                    i = 0;
+                    _b.label = 7;
+                case 7:
+                    if (!(i < iterations)) return [3 /*break*/, 10];
+                    start = performance.now();
+                    return [4 /*yield*/, storeEntry({
+                            key: "bench-key-" + i,
+                            value: "Benchmark value " + i + " with some additional content",
+                            namespace: 'benchmark'
+                        })];
+                case 8:
+                    _b.sent();
+                    storeTimes.push(performance.now() - start);
+                    _b.label = 9;
+                case 9:
+                    i++;
+                    return [3 /*break*/, 7];
+                case 10:
+                    storeMean = storeTimes.reduce(function (a, b) { return a + b; }, 0) / storeTimes.length;
+                    results.push({
+                        name: 'Memory Store',
+                        mean: storeMean,
+                        p95: percentile(__spreadArray([], storeTimes, true).sort(function (a, b) { return a - b; }), 95),
+                        target: 10.0,
+                        met: storeMean <= 10.0
+                    });
+                    // 2. Search benchmark
+                    spinner.setText('Benchmarking memory search...');
+                    queries = [
+                        'authentication patterns',
+                        'error handling best practices',
+                        'performance optimization',
+                        'testing strategies',
+                        'security vulnerabilities',
+                    ];
+                    searchTimes = [];
+                    i = 0;
+                    _b.label = 11;
+                case 11:
+                    if (!(i < iterations)) return [3 /*break*/, 14];
+                    start = performance.now();
+                    return [4 /*yield*/, searchEntries({
+                            query: queries[i % queries.length],
+                            namespace: 'benchmark',
+                            limit: 10
+                        })];
+                case 12:
+                    _b.sent();
+                    searchTimes.push(performance.now() - start);
+                    _b.label = 13;
+                case 13:
+                    i++;
+                    return [3 /*break*/, 11];
+                case 14:
+                    searchMean = searchTimes.reduce(function (a, b) { return a + b; }, 0) / searchTimes.length;
+                    results.push({
+                        name: 'Memory Search (HNSW)',
+                        mean: searchMean,
+                        p95: percentile(__spreadArray([], searchTimes, true).sort(function (a, b) { return a - b; }), 95),
+                        target: 10.0,
+                        met: searchMean <= 10.0
+                    });
+                    spinner.stop();
+                    // Display results
+                    output.writeln();
+                    output.writeln(output.bold('Results'));
+                    output.writeln(output.dim('─'.repeat(60)));
+                    for (_i = 0, results_2 = results; _i < results_2.length; _i++) {
+                        r = results_2[_i];
+                        status = r.met ? output.success('✓') : output.error('✗');
+                        output.writeln(status + " " + r.name);
+                        output.writeln("   Mean: " + r.mean.toFixed(3) + "ms | p95: " + r.p95.toFixed(3) + "ms | Target: " + r.target + "ms");
+                        output.writeln();
+                    }
+                    if (outputFormat === 'json') {
+                        output.writeln(JSON.stringify(results, null, 2));
+                    }
+                    return [2 /*return*/, { success: true, message: 'Memory benchmarks complete' }];
+                case 15:
+                    err_3 = _b.sent();
+                    spinner.stop();
+                    errorMsg = err_3 instanceof Error ? err_3.message : String(err_3);
+                    output.writeln(output.error("Memory benchmark failed: " + errorMsg));
+                    return [2 /*return*/, {
+                            success: false,
+                            message: "Memory benchmark failed: " + errorMsg
+                        }];
+                case 16: return [2 /*return*/];
             }
-            return { success: true, message: 'Memory benchmarks complete' };
-        }
-        catch (err) {
-            spinner.stop();
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            output.writeln(output.error(`Memory benchmark failed: ${errorMsg}`));
-            return {
-                success: false,
-                message: `Memory benchmark failed: ${errorMsg}`,
-            };
-        }
-    },
+        });
+    }); }
 };
 // ============================================================================
 // Full Suite Benchmark Subcommand
 // ============================================================================
-const allCommand = {
+var allCommand = {
     name: 'all',
     description: 'Run all benchmark suites',
     options: [
-        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', default: '50' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', default: 'text' },
+        { name: 'iterations', short: 'i', type: 'number', description: 'Benchmark iterations', "default": '50' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output format: text, json', "default": 'text' },
         { name: 'save', short: 's', type: 'string', description: 'Save results to file' },
     ],
     examples: [
         { command: 'claude-flow benchmark all', description: 'Run all benchmarks' },
         { command: 'claude-flow benchmark all --save full-results.json', description: 'Run all and save results' },
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        output.writeln(output.bold('  KynjalFlow V3 - Full Benchmark Suite'));
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        const startTime = Date.now();
-        const allResults = {};
-        // Run pretrain benchmarks
-        output.writeln();
-        output.writeln(output.bold('▸ Pre-Training Benchmarks'));
-        if (pretrainCommand.action) {
-            const pretrainResult = await pretrainCommand.action(ctx);
-            allResults.pretrain = pretrainResult;
-        }
-        // Run neural benchmarks
-        output.writeln();
-        output.writeln(output.bold('▸ Neural Benchmarks'));
-        if (neuralCommand.action) {
-            const neuralResult = await neuralCommand.action(ctx);
-            allResults.neural = neuralResult;
-        }
-        // Run memory benchmarks
-        output.writeln();
-        output.writeln(output.bold('▸ Memory Benchmarks'));
-        if (memoryCommand.action) {
-            const memoryResult = await memoryCommand.action(ctx);
-            allResults.memory = memoryResult;
-        }
-        const totalDuration = Date.now() - startTime;
-        output.writeln();
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        output.writeln(`  Total Duration: ${(totalDuration / 1000).toFixed(2)}s`);
-        output.writeln(output.bold(output.highlight('═'.repeat(65))));
-        // Save if requested
-        const saveFile = ctx.flags.save;
-        if (saveFile) {
-            const resultsDir = join(process.cwd(), '.claude-flow', 'benchmarks');
-            if (!existsSync(resultsDir)) {
-                mkdirSync(resultsDir, { recursive: true });
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var startTime, allResults, pretrainResult, neuralResult, memoryResult, totalDuration, saveFile, resultsDir, savePath;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    output.writeln();
+                    output.writeln(output.bold(output.highlight('═'.repeat(65))));
+                    output.writeln(output.bold('  RuFlo V3 - Full Benchmark Suite'));
+                    output.writeln(output.bold(output.highlight('═'.repeat(65))));
+                    startTime = Date.now();
+                    allResults = {};
+                    // Run pretrain benchmarks
+                    output.writeln();
+                    output.writeln(output.bold('▸ Pre-Training Benchmarks'));
+                    if (!pretrainCommand.action) return [3 /*break*/, 2];
+                    return [4 /*yield*/, pretrainCommand.action(ctx)];
+                case 1:
+                    pretrainResult = _a.sent();
+                    allResults.pretrain = pretrainResult;
+                    _a.label = 2;
+                case 2:
+                    // Run neural benchmarks
+                    output.writeln();
+                    output.writeln(output.bold('▸ Neural Benchmarks'));
+                    if (!neuralCommand.action) return [3 /*break*/, 4];
+                    return [4 /*yield*/, neuralCommand.action(ctx)];
+                case 3:
+                    neuralResult = _a.sent();
+                    allResults.neural = neuralResult;
+                    _a.label = 4;
+                case 4:
+                    // Run memory benchmarks
+                    output.writeln();
+                    output.writeln(output.bold('▸ Memory Benchmarks'));
+                    if (!memoryCommand.action) return [3 /*break*/, 6];
+                    return [4 /*yield*/, memoryCommand.action(ctx)];
+                case 5:
+                    memoryResult = _a.sent();
+                    allResults.memory = memoryResult;
+                    _a.label = 6;
+                case 6:
+                    totalDuration = Date.now() - startTime;
+                    output.writeln();
+                    output.writeln(output.bold(output.highlight('═'.repeat(65))));
+                    output.writeln("  Total Duration: " + (totalDuration / 1000).toFixed(2) + "s");
+                    output.writeln(output.bold(output.highlight('═'.repeat(65))));
+                    saveFile = ctx.flags.save;
+                    if (saveFile) {
+                        resultsDir = join(process.cwd(), '.claude-flow', 'benchmarks');
+                        if (!existsSync(resultsDir)) {
+                            mkdirSync(resultsDir, { recursive: true });
+                        }
+                        savePath = saveFile.startsWith('/') ? saveFile : join(resultsDir, saveFile);
+                        writeFileSync(savePath, JSON.stringify({
+                            timestamp: new Date().toISOString(),
+                            duration: totalDuration,
+                            results: allResults
+                        }, null, 2));
+                        output.writeln(output.success("Results saved to " + savePath));
+                    }
+                    return [2 /*return*/, { success: true, message: 'All benchmarks complete' }];
             }
-            const savePath = saveFile.startsWith('/') ? saveFile : join(resultsDir, saveFile);
-            writeFileSync(savePath, JSON.stringify({
-                timestamp: new Date().toISOString(),
-                duration: totalDuration,
-                results: allResults,
-            }, null, 2));
-            output.writeln(output.success(`Results saved to ${savePath}`));
-        }
-        return { success: true, message: 'All benchmarks complete' };
-    },
+        });
+    }); }
 };
 // ============================================================================
 // Main Benchmark Command
 // ============================================================================
-export const benchmarkCommand = {
+export var benchmarkCommand = {
     name: 'benchmark',
     description: 'Performance benchmarking for self-learning and neural systems',
     subcommands: [
@@ -437,23 +586,25 @@ export const benchmarkCommand = {
         { command: 'claude-flow benchmark memory', description: 'Benchmark memory operations' },
         { command: 'claude-flow benchmark all', description: 'Run all benchmarks' },
     ],
-    action: async (_ctx) => {
-        output.writeln();
-        output.writeln(output.bold('KynjalFlow V3 Benchmark Suite'));
-        output.writeln(output.dim('─'.repeat(50)));
-        output.writeln();
-        output.writeln('Available subcommands:');
-        output.writeln(`  ${output.highlight('pretrain')}  - Benchmark self-learning pre-training (SONA, EWC++, MoE)`);
-        output.writeln(`  ${output.highlight('neural')}    - Benchmark neural operations (embeddings, WASM)`);
-        output.writeln(`  ${output.highlight('memory')}    - Benchmark memory operations (HNSW, store, search)`);
-        output.writeln(`  ${output.highlight('all')}       - Run all benchmark suites`);
-        output.writeln();
-        output.writeln('Examples:');
-        output.writeln('  claude-flow benchmark pretrain -i 200');
-        output.writeln('  claude-flow benchmark all --save results.json');
-        output.writeln();
-        return { success: true, message: 'Use a subcommand to run benchmarks' };
-    },
+    action: function (_ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('RuFlo V3 Benchmark Suite'));
+            output.writeln(output.dim('─'.repeat(50)));
+            output.writeln();
+            output.writeln('Available subcommands:');
+            output.writeln("  " + output.highlight('pretrain') + "  - Benchmark self-learning pre-training (SONA, EWC++, MoE)");
+            output.writeln("  " + output.highlight('neural') + "    - Benchmark neural operations (embeddings, WASM)");
+            output.writeln("  " + output.highlight('memory') + "    - Benchmark memory operations (HNSW, store, search)");
+            output.writeln("  " + output.highlight('all') + "       - Run all benchmark suites");
+            output.writeln();
+            output.writeln('Examples:');
+            output.writeln('  claude-flow benchmark pretrain -i 200');
+            output.writeln('  claude-flow benchmark all --save results.json');
+            output.writeln();
+            return [2 /*return*/, { success: true, message: 'Use a subcommand to run benchmarks' }];
+        });
+    }); }
 };
 export default benchmarkCommand;
 //# sourceMappingURL=benchmark.js.map