kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/benchmark.js

@@ -4,574 +4,425 @@
  *
  * @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
 // ============================================================================
-var pretrainCommand = {
+const 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: 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*/];
+    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}`));
             }
-        });
-    }); }
+            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
 // ============================================================================
-var neuralCommand = {
+const 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: 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);
+    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)));
                     }
-                    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);
+                    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];
                         }
+                        res[i] = dot / (Math.sqrt(nQ) * Math.sqrt(nV));
                     }
-                    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
-                        });
-                    }
-                    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));
+                    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);
                     }
-                    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*/];
+                }
+            }
+            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));
+            }
+            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
 // ============================================================================
-var memoryCommand = {
+const 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: 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*/];
+    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));
+            }
+            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
 // ============================================================================
-var allCommand = {
+const 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: 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' }];
+    action: async (ctx) => {
+        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))));
+        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 });
             }
-        });
-    }); }
+            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 var benchmarkCommand = {
+export const benchmarkCommand = {
     name: 'benchmark',
     description: 'Performance benchmarking for self-learning and neural systems',
     subcommands: [
@@ -586,25 +437,23 @@ export var benchmarkCommand = {
         { command: 'claude-flow benchmark memory', description: 'Benchmark memory operations' },
         { command: 'claude-flow benchmark all', description: 'Run all 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' }];
-        });
-    }); }
+    action: async (_ctx) => {
+        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 { success: true, message: 'Use a subcommand to run benchmarks' };
+    },
 };
 export default benchmarkCommand;
 //# sourceMappingURL=benchmark.js.map