kynjal-cli 3.1.3 → 4.0.0

package/dist/src/benchmarks/pretrain/index.js

@@ -11,393 +11,604 @@
  *
  * @module v3/cli/benchmarks/pretrain
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 { performance } from 'node:perf_hooks';
 // ============================================================================
 // Utility Functions
 // ============================================================================
 function percentile(sorted, p) {
-    const idx = Math.ceil((p / 100) * sorted.length) - 1;
+    var idx = Math.ceil((p / 100) * sorted.length) - 1;
     return sorted[Math.max(0, idx)];
 }
 function mean(arr) {
-    return arr.reduce((a, b) => a + b, 0) / arr.length;
+    return arr.reduce(function (a, b) { return a + b; }, 0) / arr.length;
 }
 function stdDev(arr, avg) {
-    const squaredDiffs = arr.map(x => Math.pow(x - avg, 2));
+    var squaredDiffs = arr.map(function (x) { return Math.pow(x - avg, 2); });
     return Math.sqrt(mean(squaredDiffs));
 }
 export function formatBenchmarkResult(result) {
-    const status = result.targetMet ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
-    const target = result.targetMs ? ` (target: ${result.targetMs}ms)` : '';
+    var status = result.targetMet ? '\x1b[32m✓\x1b[0m' : '\x1b[31m✗\x1b[0m';
+    var target = result.targetMs ? " (target: " + result.targetMs + "ms)" : '';
     return [
-        `${status} ${result.name}${target}`,
-        `   Mean: ${result.meanMs.toFixed(4)}ms | Median: ${result.medianMs.toFixed(4)}ms`,
-        `   p95: ${result.p95Ms.toFixed(4)}ms | p99: ${result.p99Ms.toFixed(4)}ms`,
-        `   Min: ${result.minMs.toFixed(4)}ms | Max: ${result.maxMs.toFixed(4)}ms`,
-        `   StdDev: ${result.stdDev.toFixed(4)}ms | Ops/s: ${result.opsPerSecond.toFixed(0)}`,
+        status + " " + result.name + target,
+        "   Mean: " + result.meanMs.toFixed(4) + "ms | Median: " + result.medianMs.toFixed(4) + "ms",
+        "   p95: " + result.p95Ms.toFixed(4) + "ms | p99: " + result.p99Ms.toFixed(4) + "ms",
+        "   Min: " + result.minMs.toFixed(4) + "ms | Max: " + result.maxMs.toFixed(4) + "ms",
+        "   StdDev: " + result.stdDev.toFixed(4) + "ms | Ops/s: " + result.opsPerSecond.toFixed(0),
     ].join('\n');
 }
 // ============================================================================
 // Core Benchmark Runner
 // ============================================================================
-export async function runBenchmark(name, fn, config) {
-    const { iterations, warmupIterations, targetMs, verbose } = config;
-    const times = [];
-    // Warmup phase
-    if (verbose)
-        console.log(`  Warming up ${name} (${warmupIterations} iterations)...`);
-    for (let i = 0; i < warmupIterations; i++) {
-        await fn();
-    }
-    // Measurement phase
-    if (verbose)
-        console.log(`  Running ${name} (${iterations} iterations)...`);
-    for (let i = 0; i < iterations; i++) {
-        const start = performance.now();
-        await fn();
-        times.push(performance.now() - start);
-    }
-    // Calculate statistics
-    const sorted = [...times].sort((a, b) => a - b);
-    const avg = mean(times);
-    const std = stdDev(times, avg);
-    return {
-        name,
-        iterations,
-        meanMs: avg,
-        medianMs: percentile(sorted, 50),
-        p95Ms: percentile(sorted, 95),
-        p99Ms: percentile(sorted, 99),
-        minMs: sorted[0],
-        maxMs: sorted[sorted.length - 1],
-        stdDev: std,
-        opsPerSecond: 1000 / avg,
-        targetMet: targetMs ? avg <= targetMs : true,
-        targetMs,
-    };
+export function runBenchmark(name, fn, config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var iterations, warmupIterations, targetMs, verbose, times, i, i, start, sorted, avg, std;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    iterations = config.iterations, warmupIterations = config.warmupIterations, targetMs = config.targetMs, verbose = config.verbose;
+                    times = [];
+                    // Warmup phase
+                    if (verbose)
+                        console.log("  Warming up " + name + " (" + warmupIterations + " iterations)...");
+                    i = 0;
+                    _a.label = 1;
+                case 1:
+                    if (!(i < warmupIterations)) return [3 /*break*/, 4];
+                    return [4 /*yield*/, fn()];
+                case 2:
+                    _a.sent();
+                    _a.label = 3;
+                case 3:
+                    i++;
+                    return [3 /*break*/, 1];
+                case 4:
+                    // Measurement phase
+                    if (verbose)
+                        console.log("  Running " + name + " (" + iterations + " iterations)...");
+                    i = 0;
+                    _a.label = 5;
+                case 5:
+                    if (!(i < iterations)) return [3 /*break*/, 8];
+                    start = performance.now();
+                    return [4 /*yield*/, fn()];
+                case 6:
+                    _a.sent();
+                    times.push(performance.now() - start);
+                    _a.label = 7;
+                case 7:
+                    i++;
+                    return [3 /*break*/, 5];
+                case 8:
+                    sorted = __spreadArray([], times, true).sort(function (a, b) { return a - b; });
+                    avg = mean(times);
+                    std = stdDev(times, avg);
+                    return [2 /*return*/, {
+                            name: name,
+                            iterations: iterations,
+                            meanMs: avg,
+                            medianMs: percentile(sorted, 50),
+                            p95Ms: percentile(sorted, 95),
+                            p99Ms: percentile(sorted, 99),
+                            minMs: sorted[0],
+                            maxMs: sorted[sorted.length - 1],
+                            stdDev: std,
+                            opsPerSecond: 1000 / avg,
+                            targetMet: targetMs ? avg <= targetMs : true,
+                            targetMs: targetMs
+                        }];
+            }
+        });
+    });
 }
 // ============================================================================
 // SONA Adaptation Benchmarks
 // ============================================================================
-export async function benchmarkSONAAdaptation(config) {
-    // Fallback implementation for SONA adaptation
-    const sonaAdapt = async (_signal) => {
-        // Simulate SONA adaptation with minimal computation
-        const start = performance.now();
-        // Simple computation to simulate adaptation
-        let sum = 0;
-        for (let i = 0; i < 100; i++) {
-            sum += Math.sin(i) * Math.cos(i);
-        }
-        const latency = performance.now() - start;
-        return { adapted: sum > -1000, latencyMs: latency };
-    };
-    const testSignals = [
-        { type: 'observation', content: 'User requested feature implementation' },
-        { type: 'action', content: 'Created new component file' },
-        { type: 'result', content: 'Component successfully rendered' },
-        { type: 'thought', content: 'Should add error handling' },
-    ];
-    let signalIdx = 0;
-    return runBenchmark('SONA Adaptation', async () => {
-        await sonaAdapt(testSignals[signalIdx % testSignals.length]);
-        signalIdx++;
-    }, { ...config, targetMs: config.targetMs || 0.05 });
+export function benchmarkSONAAdaptation(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var sonaAdapt, testSignals, signalIdx;
+        var _this = this;
+        return __generator(this, function (_a) {
+            sonaAdapt = function (_signal) { return __awaiter(_this, void 0, void 0, function () {
+                var start, sum, i, latency;
+                return __generator(this, function (_a) {
+                    start = performance.now();
+                    sum = 0;
+                    for (i = 0; i < 100; i++) {
+                        sum += Math.sin(i) * Math.cos(i);
+                    }
+                    latency = performance.now() - start;
+                    return [2 /*return*/, { adapted: sum > -1000, latencyMs: latency }];
+                });
+            }); };
+            testSignals = [
+                { type: 'observation', content: 'User requested feature implementation' },
+                { type: 'action', content: 'Created new component file' },
+                { type: 'result', content: 'Component successfully rendered' },
+                { type: 'thought', content: 'Should add error handling' },
+            ];
+            signalIdx = 0;
+            return [2 /*return*/, runBenchmark('SONA Adaptation', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, sonaAdapt(testSignals[signalIdx % testSignals.length])];
+                            case 1:
+                                _a.sent();
+                                signalIdx++;
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 0.05 }))];
+        });
+    });
 }
 // ============================================================================
 // Pattern Learning Benchmarks
 // ============================================================================
-export async function benchmarkPatternLearning(config) {
-    // Simulate pattern learning step recording
-    const recordStep = async (_step) => {
-        // Simulate recording - just a hash computation
-        let hash = 0;
-        const str = _step.content;
-        for (let i = 0; i < str.length; i++) {
-            hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0;
-        }
-        return hash;
-    };
-    const testSteps = [
-        { type: 'observation', content: 'Analyzing codebase structure' },
-        { type: 'thought', content: 'Identified potential optimization' },
-        { type: 'action', content: 'Refactored module imports' },
-        { type: 'result', content: 'Build time reduced by 15%' },
-    ];
-    let stepIdx = 0;
-    return runBenchmark('Pattern Learning (Record Step)', async () => {
-        await recordStep(testSteps[stepIdx % testSteps.length]);
-        stepIdx++;
-    }, { ...config, targetMs: config.targetMs || 0.1 });
+export function benchmarkPatternLearning(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var recordStep, testSteps, stepIdx;
+        var _this = this;
+        return __generator(this, function (_a) {
+            recordStep = function (_step) { return __awaiter(_this, void 0, void 0, function () {
+                var hash, str, i;
+                return __generator(this, function (_a) {
+                    hash = 0;
+                    str = _step.content;
+                    for (i = 0; i < str.length; i++) {
+                        hash = ((hash << 5) - hash + str.charCodeAt(i)) | 0;
+                    }
+                    return [2 /*return*/, hash];
+                });
+            }); };
+            testSteps = [
+                { type: 'observation', content: 'Analyzing codebase structure' },
+                { type: 'thought', content: 'Identified potential optimization' },
+                { type: 'action', content: 'Refactored module imports' },
+                { type: 'result', content: 'Build time reduced by 15%' },
+            ];
+            stepIdx = 0;
+            return [2 /*return*/, runBenchmark('Pattern Learning (Record Step)', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, recordStep(testSteps[stepIdx % testSteps.length])];
+                            case 1:
+                                _a.sent();
+                                stepIdx++;
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 0.1 }))];
+        });
+    });
 }
 // ============================================================================
 // EWC++ Consolidation Benchmarks
 // ============================================================================
-export async function benchmarkEWCConsolidation(config) {
-    // Simulate EWC++ consolidation
-    const consolidate = async () => {
-        // Simulate consolidation computation
-        const patterns = 100;
-        let consolidated = 0;
-        for (let i = 0; i < patterns; i++) {
-            // Simulate Fisher information computation
-            const importance = Math.random();
-            if (importance > 0.3) {
-                consolidated++;
-            }
-        }
-        return { consolidated, preserved: patterns - consolidated };
-    };
-    return runBenchmark('EWC++ Consolidation', async () => {
-        await consolidate();
-    }, { ...config, targetMs: config.targetMs || 5.0 });
+export function benchmarkEWCConsolidation(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var consolidate;
+        var _this = this;
+        return __generator(this, function (_a) {
+            consolidate = function () { return __awaiter(_this, void 0, void 0, function () {
+                var patterns, consolidated, i, importance;
+                return __generator(this, function (_a) {
+                    patterns = 100;
+                    consolidated = 0;
+                    for (i = 0; i < patterns; i++) {
+                        importance = Math.random();
+                        if (importance > 0.3) {
+                            consolidated++;
+                        }
+                    }
+                    return [2 /*return*/, { consolidated: consolidated, preserved: patterns - consolidated }];
+                });
+            }); };
+            return [2 /*return*/, runBenchmark('EWC++ Consolidation', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, consolidate()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 5.0 }))];
+        });
+    });
 }
 // ============================================================================
 // Memory Retrieval Benchmarks
 // ============================================================================
-export async function benchmarkMemoryRetrieval(config) {
-    // Simulate memory search
-    const searchEntries = async (_options) => {
-        // Simulate vector search with cosine similarity
-        const numVectors = 1000;
-        const dim = 384;
-        const queryVec = new Float32Array(dim).map(() => Math.random());
-        const results = [];
-        for (let i = 0; i < Math.min(numVectors, 100); i++) {
-            const vec = new Float32Array(dim).map(() => Math.random());
-            let dot = 0, normQ = 0, normV = 0;
-            for (let j = 0; j < dim; j++) {
-                dot += queryVec[j] * vec[j];
-                normQ += queryVec[j] * queryVec[j];
-                normV += vec[j] * vec[j];
-            }
-            results.push({ score: dot / (Math.sqrt(normQ) * Math.sqrt(normV)) });
-        }
-        return { results: results.slice(0, _options.limit || 10), searchTime: 1.0 };
-    };
-    const testQueries = [
-        'authentication patterns',
-        'error handling best practices',
-        'performance optimization techniques',
-        'testing strategies',
-        'security vulnerability fixes',
-    ];
-    let queryIdx = 0;
-    return runBenchmark('Memory Retrieval (HNSW Search)', async () => {
-        await searchEntries({
-            query: testQueries[queryIdx % testQueries.length],
-            namespace: 'patterns',
-            limit: 10,
+export function benchmarkMemoryRetrieval(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var searchEntries, testQueries, queryIdx;
+        var _this = this;
+        return __generator(this, function (_a) {
+            searchEntries = function (_options) { return __awaiter(_this, void 0, void 0, function () {
+                var numVectors, dim, queryVec, results, i, vec, dot, normQ, normV, j;
+                return __generator(this, function (_a) {
+                    numVectors = 1000;
+                    dim = 384;
+                    queryVec = new Float32Array(dim).map(function () { return Math.random(); });
+                    results = [];
+                    for (i = 0; i < Math.min(numVectors, 100); i++) {
+                        vec = new Float32Array(dim).map(function () { return Math.random(); });
+                        dot = 0, normQ = 0, normV = 0;
+                        for (j = 0; j < dim; j++) {
+                            dot += queryVec[j] * vec[j];
+                            normQ += queryVec[j] * queryVec[j];
+                            normV += vec[j] * vec[j];
+                        }
+                        results.push({ score: dot / (Math.sqrt(normQ) * Math.sqrt(normV)) });
+                    }
+                    return [2 /*return*/, { results: results.slice(0, _options.limit || 10), searchTime: 1.0 }];
+                });
+            }); };
+            testQueries = [
+                'authentication patterns',
+                'error handling best practices',
+                'performance optimization techniques',
+                'testing strategies',
+                'security vulnerability fixes',
+            ];
+            queryIdx = 0;
+            return [2 /*return*/, runBenchmark('Memory Retrieval (HNSW Search)', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, searchEntries({
+                                    query: testQueries[queryIdx % testQueries.length],
+                                    namespace: 'patterns',
+                                    limit: 10
+                                })];
+                            case 1:
+                                _a.sent();
+                                queryIdx++;
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 10.0 }))];
         });
-        queryIdx++;
-    }, { ...config, targetMs: config.targetMs || 10.0 });
+    });
 }
 // ============================================================================
 // Embedding Generation Benchmarks
 // ============================================================================
-export async function benchmarkEmbeddingGeneration(config) {
-    // Simulate embedding generation
-    const generateEmbedding = async (text) => {
-        const dim = 384;
-        const embedding = new Float32Array(dim);
-        for (let i = 0; i < dim; i++) {
-            let hash = 0;
-            for (let j = 0; j < text.length; j++) {
-                hash = ((hash << 5) - hash + text.charCodeAt(j) * (i + 1)) | 0;
-            }
-            embedding[i] = Math.sin(hash) * 0.5;
-        }
-        // Normalize
-        let norm = 0;
-        for (let i = 0; i < dim; i++) {
-            norm += embedding[i] * embedding[i];
-        }
-        norm = Math.sqrt(norm);
-        for (let i = 0; i < dim; i++) {
-            embedding[i] /= norm;
-        }
-        return embedding;
-    };
-    const testTexts = [
-        'Implement user authentication with JWT tokens',
-        'Fix memory leak in event handler cleanup',
-        'Add unit tests for payment processing module',
-        'Refactor database connection pooling',
-        'Optimize React component rendering performance',
-    ];
-    let textIdx = 0;
-    return runBenchmark('Embedding Generation', async () => {
-        await generateEmbedding(testTexts[textIdx % testTexts.length]);
-        textIdx++;
-    }, { ...config, targetMs: config.targetMs || 5.0 });
+export function benchmarkEmbeddingGeneration(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var generateEmbedding, testTexts, textIdx;
+        var _this = this;
+        return __generator(this, function (_a) {
+            generateEmbedding = function (text) { return __awaiter(_this, void 0, void 0, function () {
+                var dim, embedding, i, hash, j, norm, i, i;
+                return __generator(this, function (_a) {
+                    dim = 384;
+                    embedding = new Float32Array(dim);
+                    for (i = 0; i < dim; i++) {
+                        hash = 0;
+                        for (j = 0; j < text.length; j++) {
+                            hash = ((hash << 5) - hash + text.charCodeAt(j) * (i + 1)) | 0;
+                        }
+                        embedding[i] = Math.sin(hash) * 0.5;
+                    }
+                    norm = 0;
+                    for (i = 0; i < dim; i++) {
+                        norm += embedding[i] * embedding[i];
+                    }
+                    norm = Math.sqrt(norm);
+                    for (i = 0; i < dim; i++) {
+                        embedding[i] /= norm;
+                    }
+                    return [2 /*return*/, embedding];
+                });
+            }); };
+            testTexts = [
+                'Implement user authentication with JWT tokens',
+                'Fix memory leak in event handler cleanup',
+                'Add unit tests for payment processing module',
+                'Refactor database connection pooling',
+                'Optimize React component rendering performance',
+            ];
+            textIdx = 0;
+            return [2 /*return*/, runBenchmark('Embedding Generation', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, generateEmbedding(testTexts[textIdx % testTexts.length])];
+                            case 1:
+                                _a.sent();
+                                textIdx++;
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 5.0 }))];
+        });
+    });
 }
 // ============================================================================
 // MoE Routing Benchmarks
 // ============================================================================
-export async function benchmarkMoERouting(config) {
-    // Simulate MoE routing
-    const experts = ['coder', 'tester', 'reviewer', 'architect', 'security'];
-    const route = async (task) => {
-        // Simple keyword-based routing simulation
-        const keywords = {
-            coder: ['implement', 'fix', 'code', 'function'],
-            tester: ['test', 'spec', 'coverage', 'unit'],
-            reviewer: ['review', 'quality', 'check'],
-            architect: ['design', 'architecture', 'pattern'],
-            security: ['security', 'auth', 'vulnerability'],
-        };
-        let bestExpert = 'coder';
-        let bestScore = 0;
-        for (const [expert, words] of Object.entries(keywords)) {
-            let score = 0;
-            for (const word of words) {
-                if (task.toLowerCase().includes(word)) {
-                    score++;
-                }
-            }
-            if (score > bestScore) {
-                bestScore = score;
-                bestExpert = expert;
-            }
-        }
-        return { expert: bestExpert, confidence: 0.7 + Math.random() * 0.25 };
-    };
-    const testTasks = [
-        'Fix authentication bug in login flow',
-        'Add new REST API endpoint for users',
-        'Write integration tests for checkout',
-        'Optimize database query performance',
-        'Review security of payment processing',
-    ];
-    let taskIdx = 0;
-    return runBenchmark('MoE Expert Routing', async () => {
-        await route(testTasks[taskIdx % testTasks.length]);
-        taskIdx++;
-    }, { ...config, targetMs: config.targetMs || 1.0 });
+export function benchmarkMoERouting(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var experts, route, testTasks, taskIdx;
+        var _this = this;
+        return __generator(this, function (_a) {
+            experts = ['coder', 'tester', 'reviewer', 'architect', 'security'];
+            route = function (task) { return __awaiter(_this, void 0, void 0, function () {
+                var keywords, bestExpert, bestScore, _i, _a, _b, expert, words, score, _c, words_1, word;
+                return __generator(this, function (_d) {
+                    keywords = {
+                        coder: ['implement', 'fix', 'code', 'function'],
+                        tester: ['test', 'spec', 'coverage', 'unit'],
+                        reviewer: ['review', 'quality', 'check'],
+                        architect: ['design', 'architecture', 'pattern'],
+                        security: ['security', 'auth', 'vulnerability']
+                    };
+                    bestExpert = 'coder';
+                    bestScore = 0;
+                    for (_i = 0, _a = Object.entries(keywords); _i < _a.length; _i++) {
+                        _b = _a[_i], expert = _b[0], words = _b[1];
+                        score = 0;
+                        for (_c = 0, words_1 = words; _c < words_1.length; _c++) {
+                            word = words_1[_c];
+                            if (task.toLowerCase().includes(word)) {
+                                score++;
+                            }
+                        }
+                        if (score > bestScore) {
+                            bestScore = score;
+                            bestExpert = expert;
+                        }
+                    }
+                    return [2 /*return*/, { expert: bestExpert, confidence: 0.7 + Math.random() * 0.25 }];
+                });
+            }); };
+            testTasks = [
+                'Fix authentication bug in login flow',
+                'Add new REST API endpoint for users',
+                'Write integration tests for checkout',
+                'Optimize database query performance',
+                'Review security of payment processing',
+            ];
+            taskIdx = 0;
+            return [2 /*return*/, runBenchmark('MoE Expert Routing', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, route(testTasks[taskIdx % testTasks.length])];
+                            case 1:
+                                _a.sent();
+                                taskIdx++;
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 1.0 }))];
+        });
+    });
 }
 // ============================================================================
 // Batch Operations Benchmarks
 // ============================================================================
-export async function benchmarkBatchCosine(config) {
-    // Batch cosine similarity
-    const batchCosineSim = (query, vectors) => {
-        const results = new Float32Array(vectors.length);
-        for (let i = 0; i < vectors.length; i++) {
-            let dot = 0, normQ = 0, normV = 0;
-            for (let j = 0; j < query.length; j++) {
-                dot += query[j] * vectors[i][j];
-                normQ += query[j] * query[j];
-                normV += vectors[i][j] * vectors[i][j];
-            }
-            results[i] = dot / (Math.sqrt(normQ) * Math.sqrt(normV));
-        }
-        return results;
-    };
-    // Generate test vectors
-    const dim = 384;
-    const numVectors = 1000;
-    const query = new Float32Array(dim).map(() => Math.random());
-    const vectors = Array.from({ length: numVectors }, () => new Float32Array(dim).map(() => Math.random()));
-    return runBenchmark(`Batch Cosine Similarity (${numVectors} vectors)`, async () => {
-        batchCosineSim(query, vectors);
-    }, { ...config, targetMs: config.targetMs || 2.0 });
+export function benchmarkBatchCosine(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var batchCosineSim, dim, numVectors, query, vectors;
+        var _this = this;
+        return __generator(this, function (_a) {
+            batchCosineSim = function (query, vectors) {
+                var results = new Float32Array(vectors.length);
+                for (var i = 0; i < vectors.length; i++) {
+                    var dot = 0, normQ = 0, normV = 0;
+                    for (var j = 0; j < query.length; j++) {
+                        dot += query[j] * vectors[i][j];
+                        normQ += query[j] * query[j];
+                        normV += vectors[i][j] * vectors[i][j];
+                    }
+                    results[i] = dot / (Math.sqrt(normQ) * Math.sqrt(normV));
+                }
+                return results;
+            };
+            dim = 384;
+            numVectors = 1000;
+            query = new Float32Array(dim).map(function () { return Math.random(); });
+            vectors = Array.from({ length: numVectors }, function () {
+                return new Float32Array(dim).map(function () { return Math.random(); });
+            });
+            return [2 /*return*/, runBenchmark("Batch Cosine Similarity (" + numVectors + " vectors)", function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        batchCosineSim(query, vectors);
+                        return [2 /*return*/];
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 2.0 }))];
+        });
+    });
 }
 // ============================================================================
 // Full Pre-Training Pipeline Benchmark
 // ============================================================================
-export async function benchmarkPretrainPipeline(config) {
-    // Simulate full pre-training pipeline
-    const pipeline = async () => {
-        // Step 1: Analyze repository structure (simulated)
-        const files = Array.from({ length: 50 }, (_, i) => ({
-            path: `src/module${i}/index.ts`,
-            content: `export function fn${i}() { return ${i}; }`,
-        }));
-        // Step 2: Generate embeddings for each file
-        const embeddings = [];
-        for (const file of files) {
-            const embedding = new Float32Array(384);
-            for (let i = 0; i < 384; i++) {
-                embedding[i] = Math.sin(file.path.charCodeAt(i % file.path.length) * (i + 1));
-            }
-            embeddings.push(embedding);
-        }
-        // Step 3: Build pattern index (simulated HNSW construction)
-        const index = new Map();
-        embeddings.forEach((emb, i) => index.set(i, emb));
-        // Step 4: Extract patterns
-        const patterns = files.slice(0, 10).map((f, i) => ({
-            id: `pattern-${i}`,
-            type: 'code-structure',
-            embedding: embeddings[i],
-            confidence: 0.85 + Math.random() * 0.1,
-        }));
-        return { files: files.length, patterns: patterns.length };
-    };
-    return runBenchmark('Pre-Training Pipeline (50 files)', async () => {
-        await pipeline();
-    }, { ...config, targetMs: config.targetMs || 100.0 });
+export function benchmarkPretrainPipeline(config) {
+    return __awaiter(this, void 0, Promise, function () {
+        var pipeline;
+        var _this = this;
+        return __generator(this, function (_a) {
+            pipeline = function () { return __awaiter(_this, void 0, void 0, function () {
+                var files, embeddings, _i, files_1, file, embedding, i, index, patterns;
+                return __generator(this, function (_a) {
+                    files = Array.from({ length: 50 }, function (_, i) { return ({
+                        path: "src/module" + i + "/index.ts",
+                        content: "export function fn" + i + "() { return " + i + "; }"
+                    }); });
+                    embeddings = [];
+                    for (_i = 0, files_1 = files; _i < files_1.length; _i++) {
+                        file = files_1[_i];
+                        embedding = new Float32Array(384);
+                        for (i = 0; i < 384; i++) {
+                            embedding[i] = Math.sin(file.path.charCodeAt(i % file.path.length) * (i + 1));
+                        }
+                        embeddings.push(embedding);
+                    }
+                    index = new Map();
+                    embeddings.forEach(function (emb, i) { return index.set(i, emb); });
+                    patterns = files.slice(0, 10).map(function (f, i) { return ({
+                        id: "pattern-" + i,
+                        type: 'code-structure',
+                        embedding: embeddings[i],
+                        confidence: 0.85 + Math.random() * 0.1
+                    }); });
+                    return [2 /*return*/, { files: files.length, patterns: patterns.length }];
+                });
+            }); };
+            return [2 /*return*/, runBenchmark('Pre-Training Pipeline (50 files)', function () { return __awaiter(_this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, pipeline()];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/];
+                        }
+                    });
+                }); }, __assign(__assign({}, config), { targetMs: config.targetMs || 100.0 }))];
+        });
+    });
 }
 // ============================================================================
 // Full Benchmark Suite
 // ============================================================================
-export async function runPretrainBenchmarkSuite(config = {}) {
-    const fullConfig = {
-        iterations: config.iterations || 100,
-        warmupIterations: config.warmupIterations || 10,
-        verbose: config.verbose ?? false,
-    };
-    console.log('\n\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m');
-    console.log('\x1b[1m\x1b[36m  Self-Learning Pre-Training Benchmark Suite\x1b[0m');
-    console.log('\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m\n');
-    const startTime = performance.now();
-    const results = [];
-    // Run all benchmarks
-    const benchmarks = [
-        { name: 'SONA', fn: () => benchmarkSONAAdaptation(fullConfig) },
-        { name: 'Pattern Learning', fn: () => benchmarkPatternLearning(fullConfig) },
-        { name: 'EWC++', fn: () => benchmarkEWCConsolidation({ ...fullConfig, iterations: 20 }) },
-        { name: 'Memory Retrieval', fn: () => benchmarkMemoryRetrieval(fullConfig) },
-        { name: 'Embedding Gen', fn: () => benchmarkEmbeddingGeneration(fullConfig) },
-        { name: 'MoE Routing', fn: () => benchmarkMoERouting(fullConfig) },
-        { name: 'Batch Cosine', fn: () => benchmarkBatchCosine(fullConfig) },
-        { name: 'Pretrain Pipeline', fn: () => benchmarkPretrainPipeline({ ...fullConfig, iterations: 10 }) },
-    ];
-    for (const benchmark of benchmarks) {
-        console.log(`\x1b[33m► Running ${benchmark.name} benchmark...\x1b[0m`);
-        try {
-            const result = await benchmark.fn();
-            results.push(result);
-            console.log(formatBenchmarkResult(result));
-            console.log();
-        }
-        catch (error) {
-            console.error(`\x1b[31m✗ ${benchmark.name} failed: ${error}\x1b[0m\n`);
-        }
-    }
-    const totalDuration = performance.now() - startTime;
-    // Summary
-    console.log('\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m');
-    console.log('\x1b[1m  Summary\x1b[0m');
-    console.log('\x1b[36m───────────────────────────────────────────────────────────────\x1b[0m');
-    const passed = results.filter(r => r.targetMet).length;
-    const total = results.length;
-    console.log(`  Total benchmarks: ${total}`);
-    console.log(`  Targets met: \x1b[${passed === total ? '32' : '33'}m${passed}/${total}\x1b[0m`);
-    console.log(`  Total duration: ${(totalDuration / 1000).toFixed(2)}s`);
-    console.log('\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m\n');
-    return {
-        name: 'pretrain-benchmark-suite',
-        results,
-        totalDurationMs: totalDuration,
-        timestamp: new Date().toISOString(),
-        environment: {
-            nodeVersion: process.version,
-            platform: process.platform,
-            arch: process.arch,
-            cpuCount: (await import('node:os')).cpus().length,
-        },
-    };
+export function runPretrainBenchmarkSuite(config) {
+    var _a;
+    if (config === void 0) { config = {}; }
+    return __awaiter(this, void 0, Promise, function () {
+        var fullConfig, startTime, results, benchmarks, _i, benchmarks_1, benchmark, result, error_1, totalDuration, passed, total;
+        var _b, _c;
+        return __generator(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    fullConfig = {
+                        iterations: config.iterations || 100,
+                        warmupIterations: config.warmupIterations || 10,
+                        verbose: (_a = config.verbose) !== null && _a !== void 0 ? _a : false
+                    };
+                    console.log('\n\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m');
+                    console.log('\x1b[1m\x1b[36m  Self-Learning Pre-Training Benchmark Suite\x1b[0m');
+                    console.log('\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m\n');
+                    startTime = performance.now();
+                    results = [];
+                    benchmarks = [
+                        { name: 'SONA', fn: function () { return benchmarkSONAAdaptation(fullConfig); } },
+                        { name: 'Pattern Learning', fn: function () { return benchmarkPatternLearning(fullConfig); } },
+                        { name: 'EWC++', fn: function () { return benchmarkEWCConsolidation(__assign(__assign({}, fullConfig), { iterations: 20 })); } },
+                        { name: 'Memory Retrieval', fn: function () { return benchmarkMemoryRetrieval(fullConfig); } },
+                        { name: 'Embedding Gen', fn: function () { return benchmarkEmbeddingGeneration(fullConfig); } },
+                        { name: 'MoE Routing', fn: function () { return benchmarkMoERouting(fullConfig); } },
+                        { name: 'Batch Cosine', fn: function () { return benchmarkBatchCosine(fullConfig); } },
+                        { name: 'Pretrain Pipeline', fn: function () { return benchmarkPretrainPipeline(__assign(__assign({}, fullConfig), { iterations: 10 })); } },
+                    ];
+                    _i = 0, benchmarks_1 = benchmarks;
+                    _d.label = 1;
+                case 1:
+                    if (!(_i < benchmarks_1.length)) return [3 /*break*/, 6];
+                    benchmark = benchmarks_1[_i];
+                    console.log("\u001B[33m\u25BA Running " + benchmark.name + " benchmark...\u001B[0m");
+                    _d.label = 2;
+                case 2:
+                    _d.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, benchmark.fn()];
+                case 3:
+                    result = _d.sent();
+                    results.push(result);
+                    console.log(formatBenchmarkResult(result));
+                    console.log();
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_1 = _d.sent();
+                    console.error("\u001B[31m\u2717 " + benchmark.name + " failed: " + error_1 + "\u001B[0m\n");
+                    return [3 /*break*/, 5];
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 6:
+                    totalDuration = performance.now() - startTime;
+                    // Summary
+                    console.log('\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m');
+                    console.log('\x1b[1m  Summary\x1b[0m');
+                    console.log('\x1b[36m───────────────────────────────────────────────────────────────\x1b[0m');
+                    passed = results.filter(function (r) { return r.targetMet; }).length;
+                    total = results.length;
+                    console.log("  Total benchmarks: " + total);
+                    console.log("  Targets met: \u001B[" + (passed === total ? '32' : '33') + "m" + passed + "/" + total + "\u001B[0m");
+                    console.log("  Total duration: " + (totalDuration / 1000).toFixed(2) + "s");
+                    console.log('\x1b[1m\x1b[36m═══════════════════════════════════════════════════════════════\x1b[0m\n');
+                    _b = {
+                        name: 'pretrain-benchmark-suite',
+                        results: results,
+                        totalDurationMs: totalDuration,
+                        timestamp: new Date().toISOString()
+                    };
+                    _c = {
+                        nodeVersion: process.version,
+                        platform: process.platform,
+                        arch: process.arch
+                    };
+                    return [4 /*yield*/, import('node:os')];
+                case 7: return [2 /*return*/, (_b.environment = (_c.cpuCount = (_d.sent()).cpus().length,
+                        _c),
+                        _b)];
+            }
+        });
+    });
 }
 // Export for CLI usage
 export default runPretrainBenchmarkSuite;