kynjal-cli 4.0.0 → 4.0.2

package/dist/src/commands/embeddings.js

@@ -12,664 +12,573 @@
  *
  * Created with ❤️ by ruv.io
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { output } from '../output.js';
 // Dynamic imports for embeddings package
-function getEmbeddings() {
-    return __awaiter(this, void 0, void 0, function () {
-        var _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _b.trys.push([0, 2, , 3]);
-                    return [4 /*yield*/, import('@claude-flow/embeddings')];
-                case 1: return [2 /*return*/, _b.sent()];
-                case 2:
-                    _a = _b.sent();
-                    return [2 /*return*/, null];
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function getEmbeddings() {
+    try {
+        return await import('@claude-flow/embeddings');
+    }
+    catch {
+        return null;
+    }
 }
 // Generate subcommand - REAL implementation
-var generateCommand = {
+const generateCommand = {
     name: 'generate',
     description: 'Generate embeddings for text',
     options: [
         { name: 'text', short: 't', type: 'string', description: 'Text to embed', required: true },
-        { name: 'provider', short: 'p', type: 'string', description: 'Provider: openai, transformers, agentic-flow, local', "default": 'local' },
+        { name: 'provider', short: 'p', type: 'string', description: 'Provider: openai, transformers, agentic-flow, local', default: 'local' },
         { name: 'model', short: 'm', type: 'string', description: 'Model to use' },
-        { name: 'output', short: 'o', type: 'string', description: 'Output format: json, array, preview', "default": 'preview' },
+        { name: 'output', short: 'o', type: 'string', description: 'Output format: json, array, preview', default: 'preview' },
     ],
     examples: [
         { command: 'claude-flow embeddings generate -t "Hello world"', description: 'Generate embedding' },
         { command: 'claude-flow embeddings generate -t "Test" -o json', description: 'Output as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var text, provider, outputFormat, spinner, _a, generateEmbedding, loadEmbeddingModel, startTime, modelInfo, result, duration, preview, error_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    text = ctx.flags.text;
-                    provider = ctx.flags.provider || 'local';
-                    outputFormat = ctx.flags.output || 'preview';
-                    if (!text) {
-                        output.printError('Text is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Generate Embedding'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: "Generating with " + provider + "...", spinner: 'dots' });
-                    spinner.start();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 5, , 6]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    _a = _b.sent(), generateEmbedding = _a.generateEmbedding, loadEmbeddingModel = _a.loadEmbeddingModel;
-                    startTime = Date.now();
-                    return [4 /*yield*/, loadEmbeddingModel({ verbose: false })];
-                case 3:
-                    modelInfo = _b.sent();
-                    return [4 /*yield*/, generateEmbedding(text)];
-                case 4:
-                    result = _b.sent();
-                    duration = Date.now() - startTime;
-                    spinner.succeed("Embedding generated in " + duration + "ms");
-                    if (outputFormat === 'json') {
-                        output.printJson({
-                            text: text.substring(0, 100),
-                            embedding: result.embedding,
-                            dimensions: result.dimensions,
-                            model: result.model,
-                            duration: duration
-                        });
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    if (outputFormat === 'array') {
-                        output.writeln(JSON.stringify(result.embedding));
-                        return [2 /*return*/, { success: true, data: result }];
-                    }
-                    preview = result.embedding.slice(0, 8).map(function (v) { return v.toFixed(6); });
-                    output.writeln();
-                    output.printBox([
-                        "Provider: " + provider,
-                        "Model: " + result.model + " (" + modelInfo.modelName + ")",
-                        "Dimensions: " + result.dimensions,
-                        "Text: \"" + text.substring(0, 40) + (text.length > 40 ? '...' : '') + "\"",
-                        "Generation time: " + duration + "ms",
-                        "",
-                        "Vector preview (first 8 of " + result.dimensions + "):",
-                        "[" + preview.join(', ') + ", ...]",
-                    ].join('\n'), 'Result');
-                    return [2 /*return*/, { success: true, data: result }];
-                case 5:
-                    error_1 = _b.sent();
-                    spinner.fail('Embedding generation failed');
-                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 6: return [2 /*return*/];
+    action: async (ctx) => {
+        const text = ctx.flags.text;
+        const provider = ctx.flags.provider || 'local';
+        const outputFormat = ctx.flags.output || 'preview';
+        if (!text) {
+            output.printError('Text is required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Generate Embedding'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: `Generating with ${provider}...`, spinner: 'dots' });
+        spinner.start();
+        try {
+            // Use real embedding generator
+            const { generateEmbedding, loadEmbeddingModel } = await import('../memory/memory-initializer.js');
+            const startTime = Date.now();
+            const modelInfo = await loadEmbeddingModel({ verbose: false });
+            const result = await generateEmbedding(text);
+            const duration = Date.now() - startTime;
+            spinner.succeed(`Embedding generated in ${duration}ms`);
+            if (outputFormat === 'json') {
+                output.printJson({
+                    text: text.substring(0, 100),
+                    embedding: result.embedding,
+                    dimensions: result.dimensions,
+                    model: result.model,
+                    duration
+                });
+                return { success: true, data: result };
             }
-        });
-    }); }
+            if (outputFormat === 'array') {
+                output.writeln(JSON.stringify(result.embedding));
+                return { success: true, data: result };
+            }
+            // Preview format (default)
+            const preview = result.embedding.slice(0, 8).map(v => v.toFixed(6));
+            output.writeln();
+            output.printBox([
+                `Provider: ${provider}`,
+                `Model: ${result.model} (${modelInfo.modelName})`,
+                `Dimensions: ${result.dimensions}`,
+                `Text: "${text.substring(0, 40)}${text.length > 40 ? '...' : ''}"`,
+                `Generation time: ${duration}ms`,
+                ``,
+                `Vector preview (first 8 of ${result.dimensions}):`,
+                `[${preview.join(', ')}, ...]`,
+            ].join('\n'), 'Result');
+            return { success: true, data: result };
+        }
+        catch (error) {
+            spinner.fail('Embedding generation failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Search subcommand - REAL implementation using sql.js
-var searchCommand = {
+const searchCommand = {
     name: 'search',
     description: 'Semantic similarity search',
     options: [
         { name: 'query', short: 'q', type: 'string', description: 'Search query', required: true },
-        { name: 'collection', short: 'c', type: 'string', description: 'Namespace to search', "default": 'default' },
-        { name: 'limit', short: 'l', type: 'number', description: 'Max results', "default": '10' },
-        { name: 'threshold', short: 't', type: 'number', description: 'Similarity threshold (0-1)', "default": '0.5' },
-        { name: 'db-path', type: 'string', description: 'Database path', "default": '.swarm/memory.db' },
+        { name: 'collection', short: 'c', type: 'string', description: 'Namespace to search', default: 'default' },
+        { name: 'limit', short: 'l', type: 'number', description: 'Max results', default: '10' },
+        { name: 'threshold', short: 't', type: 'number', description: 'Similarity threshold (0-1)', default: '0.5' },
+        { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
     ],
     examples: [
         { command: 'claude-flow embeddings search -q "error handling"', description: 'Search for similar' },
         { command: 'claude-flow embeddings search -q "test" -l 5', description: 'Limit results' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var query, namespace, limit, threshold, dbPath, spinner, fs, path, fullDbPath, initSqlJs, SQL, fileBuffer, db, startTime, generateEmbedding, queryResult, queryEmbedding, entries, results, _i, _a, row, _b, id, key, ns, content, embeddingJson, embedding, similarity, keywordEntries, _loop_1, _c, _d, row, topResults, searchTime, error_2;
-        var _e, _f;
-        return __generator(this, function (_g) {
-            switch (_g.label) {
-                case 0:
-                    query = ctx.flags.query;
-                    namespace = ctx.flags.collection || 'default';
-                    limit = parseInt(ctx.flags.limit || '10', 10);
-                    threshold = parseFloat(ctx.flags.threshold || '0.5');
-                    dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
-                    if (!query) {
-                        output.printError('Query is required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    output.writeln();
-                    output.writeln(output.bold('Semantic Search'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    spinner = output.createSpinner({ text: 'Searching...', spinner: 'dots' });
-                    spinner.start();
-                    _g.label = 1;
-                case 1:
-                    _g.trys.push([1, 8, , 9]);
-                    return [4 /*yield*/, import('fs')];
-                case 2:
-                    fs = _g.sent();
-                    return [4 /*yield*/, import('path')];
-                case 3:
-                    path = _g.sent();
-                    fullDbPath = path.resolve(process.cwd(), dbPath);
-                    // Check if database exists
-                    if (!fs.existsSync(fullDbPath)) {
-                        spinner.fail('Database not found');
-                        output.printWarning("No database at " + fullDbPath);
-                        output.printInfo('Run: claude-flow memory init');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    return [4 /*yield*/, import('sql.js')];
-                case 4:
-                    initSqlJs = (_g.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 5:
-                    SQL = _g.sent();
-                    fileBuffer = fs.readFileSync(fullDbPath);
-                    db = new SQL.Database(fileBuffer);
-                    startTime = Date.now();
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 6:
-                    generateEmbedding = (_g.sent()).generateEmbedding;
-                    return [4 /*yield*/, generateEmbedding(query)];
-                case 7:
-                    queryResult = _g.sent();
-                    queryEmbedding = queryResult.embedding;
-                    entries = db.exec("\n        SELECT id, key, namespace, content, embedding, embedding_dimensions\n        FROM memory_entries\n        WHERE status = 'active'\n          AND embedding IS NOT NULL\n          " + (namespace !== 'all' ? "AND namespace = '" + namespace + "'" : '') + "\n        LIMIT 1000\n      ");
-                    results = [];
-                    if ((_e = entries[0]) === null || _e === void 0 ? void 0 : _e.values) {
-                        for (_i = 0, _a = entries[0].values; _i < _a.length; _i++) {
-                            row = _a[_i];
-                            _b = row, id = _b[0], key = _b[1], ns = _b[2], content = _b[3], embeddingJson = _b[4];
-                            if (!embeddingJson)
-                                continue;
-                            try {
-                                embedding = JSON.parse(embeddingJson);
-                                similarity = cosineSimilarity(queryEmbedding, embedding);
-                                if (similarity >= threshold) {
-                                    results.push({
-                                        score: similarity,
-                                        id: id.substring(0, 10),
-                                        key: key || id.substring(0, 15),
-                                        content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
-                                        namespace: ns || 'default'
-                                    });
-                                }
-                            }
-                            catch (_h) {
-                                // Skip entries with invalid embeddings
-                            }
+    action: async (ctx) => {
+        const query = ctx.flags.query;
+        const namespace = ctx.flags.collection || 'default';
+        const limit = parseInt(ctx.flags.limit || '10', 10);
+        const threshold = parseFloat(ctx.flags.threshold || '0.5');
+        const dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
+        if (!query) {
+            output.printError('Query is required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Semantic Search'));
+        output.writeln(output.dim('─'.repeat(60)));
+        const spinner = output.createSpinner({ text: 'Searching...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const fullDbPath = path.resolve(process.cwd(), dbPath);
+            // Check if database exists
+            if (!fs.existsSync(fullDbPath)) {
+                spinner.fail('Database not found');
+                output.printWarning(`No database at ${fullDbPath}`);
+                output.printInfo('Run: claude-flow memory init');
+                return { success: false, exitCode: 1 };
+            }
+            // Load sql.js
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            const fileBuffer = fs.readFileSync(fullDbPath);
+            const db = new SQL.Database(fileBuffer);
+            const startTime = Date.now();
+            // Generate embedding for query
+            const { generateEmbedding } = await import('../memory/memory-initializer.js');
+            const queryResult = await generateEmbedding(query);
+            const queryEmbedding = queryResult.embedding;
+            // Get all entries with embeddings from database
+            const entries = db.exec(`
+        SELECT id, key, namespace, content, embedding, embedding_dimensions
+        FROM memory_entries
+        WHERE status = 'active'
+          AND embedding IS NOT NULL
+          ${namespace !== 'all' ? `AND namespace = '${namespace}'` : ''}
+        LIMIT 1000
+      `);
+            const results = [];
+            if (entries[0]?.values) {
+                for (const row of entries[0].values) {
+                    const [id, key, ns, content, embeddingJson] = row;
+                    if (!embeddingJson)
+                        continue;
+                    try {
+                        const embedding = JSON.parse(embeddingJson);
+                        // Calculate cosine similarity
+                        const similarity = cosineSimilarity(queryEmbedding, embedding);
+                        if (similarity >= threshold) {
+                            results.push({
+                                score: similarity,
+                                id: id.substring(0, 10),
+                                key: key || id.substring(0, 15),
+                                content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
+                                namespace: ns || 'default'
+                            });
                         }
                     }
-                    // Also search entries without embeddings using keyword match
-                    if (results.length < limit) {
-                        keywordEntries = db.exec("\n          SELECT id, key, namespace, content\n          FROM memory_entries\n          WHERE status = 'active'\n            AND (content LIKE '%" + query.replace(/'/g, "''") + "%' OR key LIKE '%" + query.replace(/'/g, "''") + "%')\n            " + (namespace !== 'all' ? "AND namespace = '" + namespace + "'" : '') + "\n          LIMIT " + (limit - results.length) + "\n        ");
-                        if ((_f = keywordEntries[0]) === null || _f === void 0 ? void 0 : _f.values) {
-                            _loop_1 = function (row) {
-                                var _j = row, id = _j[0], key = _j[1], ns = _j[2], content = _j[3];
-                                // Avoid duplicates
-                                if (!results.some(function (r) { return r.id === id.substring(0, 10); })) {
-                                    results.push({
-                                        score: 0.5,
-                                        id: id.substring(0, 10),
-                                        key: key || id.substring(0, 15),
-                                        content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
-                                        namespace: ns || 'default'
-                                    });
-                                }
-                            };
-                            for (_c = 0, _d = keywordEntries[0].values; _c < _d.length; _c++) {
-                                row = _d[_c];
-                                _loop_1(row);
-                            }
-                        }
+                    catch {
+                        // Skip entries with invalid embeddings
                     }
-                    // Sort by score descending
-                    results.sort(function (a, b) { return b.score - a.score; });
-                    topResults = results.slice(0, limit);
-                    searchTime = Date.now() - startTime;
-                    db.close();
-                    spinner.succeed("Found " + topResults.length + " matches (" + searchTime + "ms)");
-                    if (topResults.length === 0) {
-                        output.writeln();
-                        output.printWarning('No matches found');
-                        output.printInfo("Try: claude-flow memory store -k \"key\" --value \"your data\"");
-                        return [2 /*return*/, { success: true, data: [] }];
+                }
+            }
+            // Also search entries without embeddings using keyword match
+            if (results.length < limit) {
+                const keywordEntries = db.exec(`
+          SELECT id, key, namespace, content
+          FROM memory_entries
+          WHERE status = 'active'
+            AND (content LIKE '%${query.replace(/'/g, "''")}%' OR key LIKE '%${query.replace(/'/g, "''")}%')
+            ${namespace !== 'all' ? `AND namespace = '${namespace}'` : ''}
+          LIMIT ${limit - results.length}
+        `);
+                if (keywordEntries[0]?.values) {
+                    for (const row of keywordEntries[0].values) {
+                        const [id, key, ns, content] = row;
+                        // Avoid duplicates
+                        if (!results.some(r => r.id === id.substring(0, 10))) {
+                            results.push({
+                                score: 0.5, // Keyword match base score
+                                id: id.substring(0, 10),
+                                key: key || id.substring(0, 15),
+                                content: (content || '').substring(0, 45) + ((content || '').length > 45 ? '...' : ''),
+                                namespace: ns || 'default'
+                            });
+                        }
                     }
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'score', header: 'Score', width: 10 },
-                            { key: 'key', header: 'Key', width: 18 },
-                            { key: 'content', header: 'Content', width: 42 },
-                        ],
-                        data: topResults.map(function (r) { return ({
-                            score: r.score >= 0.8 ? output.success(r.score.toFixed(2)) :
-                                r.score >= 0.6 ? output.warning(r.score.toFixed(2)) :
-                                    output.dim(r.score.toFixed(2)),
-                            key: r.key,
-                            content: r.content
-                        }); })
-                    });
-                    output.writeln();
-                    output.writeln(output.dim("Searched " + namespace + " namespace (" + queryResult.model + ", " + searchTime + "ms)"));
-                    return [2 /*return*/, { success: true, data: topResults }];
-                case 8:
-                    error_2 = _g.sent();
-                    spinner.fail('Search failed');
-                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 9: return [2 /*return*/];
+                }
             }
-        });
-    }); }
+            // Sort by score descending
+            results.sort((a, b) => b.score - a.score);
+            const topResults = results.slice(0, limit);
+            const searchTime = Date.now() - startTime;
+            db.close();
+            spinner.succeed(`Found ${topResults.length} matches (${searchTime}ms)`);
+            if (topResults.length === 0) {
+                output.writeln();
+                output.printWarning('No matches found');
+                output.printInfo(`Try: claude-flow memory store -k "key" --value "your data"`);
+                return { success: true, data: [] };
+            }
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'score', header: 'Score', width: 10 },
+                    { key: 'key', header: 'Key', width: 18 },
+                    { key: 'content', header: 'Content', width: 42 },
+                ],
+                data: topResults.map(r => ({
+                    score: r.score >= 0.8 ? output.success(r.score.toFixed(2)) :
+                        r.score >= 0.6 ? output.warning(r.score.toFixed(2)) :
+                            output.dim(r.score.toFixed(2)),
+                    key: r.key,
+                    content: r.content
+                })),
+            });
+            output.writeln();
+            output.writeln(output.dim(`Searched ${namespace} namespace (${queryResult.model}, ${searchTime}ms)`));
+            return { success: true, data: topResults };
+        }
+        catch (error) {
+            spinner.fail('Search failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 /**
  * Optimized cosine similarity
  * V8 JIT-friendly - ~0.5μs per 384-dim vector comparison
  */
 function cosineSimilarity(a, b) {
-    var len = Math.min(a.length, b.length);
+    const len = Math.min(a.length, b.length);
     if (len === 0)
         return 0;
-    var dot = 0, normA = 0, normB = 0;
+    let dot = 0, normA = 0, normB = 0;
     // Simple loop - V8 optimizes this well
-    for (var i = 0; i < len; i++) {
-        var ai = a[i], bi = b[i];
+    for (let i = 0; i < len; i++) {
+        const ai = a[i], bi = b[i];
         dot += ai * bi;
         normA += ai * ai;
         normB += bi * bi;
     }
-    var mag = Math.sqrt(normA * normB);
+    const mag = Math.sqrt(normA * normB);
     return mag === 0 ? 0 : dot / mag;
 }
 // Compare subcommand - REAL similarity computation
-var compareCommand = {
+const compareCommand = {
     name: 'compare',
     description: 'Compare similarity between texts',
     options: [
         { name: 'text1', type: 'string', description: 'First text', required: true },
         { name: 'text2', type: 'string', description: 'Second text', required: true },
-        { name: 'metric', short: 'm', type: 'string', description: 'Metric: cosine, euclidean, dot', "default": 'cosine' },
+        { name: 'metric', short: 'm', type: 'string', description: 'Metric: cosine, euclidean, dot', default: 'cosine' },
     ],
     examples: [
         { command: 'claude-flow embeddings compare --text1 "Hello" --text2 "Hi there"', description: 'Compare texts' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var text1, text2, metric, spinner, generateEmbedding, startTime, _a, emb1, emb2, embedTime, similarity, sumSq, i, diff, distance, dot, i, error_3;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    text1 = ctx.flags.text1;
-                    text2 = ctx.flags.text2;
-                    metric = ctx.flags.metric || 'cosine';
-                    if (!text1 || !text2) {
-                        output.printError('Both text1 and text2 are required');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
+    action: async (ctx) => {
+        const text1 = ctx.flags.text1;
+        const text2 = ctx.flags.text2;
+        const metric = ctx.flags.metric || 'cosine';
+        if (!text1 || !text2) {
+            output.printError('Both text1 and text2 are required');
+            return { success: false, exitCode: 1 };
+        }
+        output.writeln();
+        output.writeln(output.bold('Text Similarity (Real)'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Generating embeddings...', spinner: 'dots' });
+        spinner.start();
+        try {
+            const { generateEmbedding } = await import('../memory/memory-initializer.js');
+            // Generate real embeddings for both texts
+            const startTime = Date.now();
+            const [emb1, emb2] = await Promise.all([
+                generateEmbedding(text1),
+                generateEmbedding(text2),
+            ]);
+            const embedTime = Date.now() - startTime;
+            spinner.setText('Computing similarity...');
+            // Compute real similarity based on metric
+            let similarity;
+            switch (metric) {
+                case 'euclidean': {
+                    // Euclidean distance (converted to similarity: 1 / (1 + distance))
+                    let sumSq = 0;
+                    for (let i = 0; i < emb1.embedding.length; i++) {
+                        const diff = emb1.embedding[i] - emb2.embedding[i];
+                        sumSq += diff * diff;
                     }
-                    output.writeln();
-                    output.writeln(output.bold('Text Similarity (Real)'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Generating embeddings...', spinner: 'dots' });
-                    spinner.start();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 4, , 5]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    generateEmbedding = (_b.sent()).generateEmbedding;
-                    startTime = Date.now();
-                    return [4 /*yield*/, Promise.all([
-                            generateEmbedding(text1),
-                            generateEmbedding(text2),
-                        ])];
-                case 3:
-                    _a = _b.sent(), emb1 = _a[0], emb2 = _a[1];
-                    embedTime = Date.now() - startTime;
-                    spinner.setText('Computing similarity...');
-                    similarity = void 0;
-                    switch (metric) {
-                        case 'euclidean': {
-                            sumSq = 0;
-                            for (i = 0; i < emb1.embedding.length; i++) {
-                                diff = emb1.embedding[i] - emb2.embedding[i];
-                                sumSq += diff * diff;
-                            }
-                            distance = Math.sqrt(sumSq);
-                            similarity = 1 / (1 + distance);
-                            break;
-                        }
-                        case 'dot': {
-                            dot = 0;
-                            for (i = 0; i < emb1.embedding.length; i++) {
-                                dot += emb1.embedding[i] * emb2.embedding[i];
-                            }
-                            similarity = dot;
-                            break;
-                        }
-                        case 'cosine':
-                        default: {
-                            // Cosine similarity
-                            similarity = cosineSimilarity(emb1.embedding, emb2.embedding);
-                        }
+                    const distance = Math.sqrt(sumSq);
+                    similarity = 1 / (1 + distance);
+                    break;
+                }
+                case 'dot': {
+                    // Dot product
+                    let dot = 0;
+                    for (let i = 0; i < emb1.embedding.length; i++) {
+                        dot += emb1.embedding[i] * emb2.embedding[i];
                     }
-                    spinner.succeed("Comparison complete (" + embedTime + "ms)");
-                    output.writeln();
-                    output.printBox([
-                        "Text 1: \"" + text1.substring(0, 30) + (text1.length > 30 ? '...' : '') + "\"",
-                        "Text 2: \"" + text2.substring(0, 30) + (text2.length > 30 ? '...' : '') + "\"",
-                        "",
-                        "Model: " + emb1.model + " (" + emb1.dimensions + "-dim)",
-                        "Metric: " + metric,
-                        "Similarity: " + (similarity > 0.8 ? output.success(similarity.toFixed(4)) : similarity > 0.5 ? output.warning(similarity.toFixed(4)) : output.dim(similarity.toFixed(4))),
-                        "",
-                        "Interpretation: " + (similarity > 0.8 ? 'Highly similar' : similarity > 0.5 ? 'Moderately similar' : 'Dissimilar'),
-                    ].join('\n'), 'Result');
-                    return [2 /*return*/, { success: true, data: { similarity: similarity, metric: metric, embedTime: embedTime } }];
-                case 4:
-                    error_3 = _b.sent();
-                    spinner.fail('Comparison failed');
-                    output.printError(error_3 instanceof Error ? error_3.message : String(error_3));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5: return [2 /*return*/];
+                    similarity = dot;
+                    break;
+                }
+                case 'cosine':
+                default: {
+                    // Cosine similarity
+                    similarity = cosineSimilarity(emb1.embedding, emb2.embedding);
+                }
             }
-        });
-    }); }
+            spinner.succeed(`Comparison complete (${embedTime}ms)`);
+            output.writeln();
+            output.printBox([
+                `Text 1: "${text1.substring(0, 30)}${text1.length > 30 ? '...' : ''}"`,
+                `Text 2: "${text2.substring(0, 30)}${text2.length > 30 ? '...' : ''}"`,
+                ``,
+                `Model: ${emb1.model} (${emb1.dimensions}-dim)`,
+                `Metric: ${metric}`,
+                `Similarity: ${similarity > 0.8 ? output.success(similarity.toFixed(4)) : similarity > 0.5 ? output.warning(similarity.toFixed(4)) : output.dim(similarity.toFixed(4))}`,
+                ``,
+                `Interpretation: ${similarity > 0.8 ? 'Highly similar' : similarity > 0.5 ? 'Moderately similar' : 'Dissimilar'}`,
+            ].join('\n'), 'Result');
+            return { success: true, data: { similarity, metric, embedTime } };
+        }
+        catch (error) {
+            spinner.fail('Comparison failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Collections subcommand - REAL implementation using sql.js
-var collectionsCommand = {
+const collectionsCommand = {
     name: 'collections',
     description: 'Manage embedding collections (namespaces)',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: list, stats', "default": 'list' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: list, stats', default: 'list' },
         { name: 'name', short: 'n', type: 'string', description: 'Namespace name' },
-        { name: 'db-path', type: 'string', description: 'Database path', "default": '.swarm/memory.db' },
+        { name: 'db-path', type: 'string', description: 'Database path', default: '.swarm/memory.db' },
     ],
     examples: [
         { command: 'claude-flow embeddings collections', description: 'List collections' },
         { command: 'claude-flow embeddings collections -a stats', description: 'Show detailed stats' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var action, dbPath, fs, path, fullDbPath, initSqlJs, SQL, fileBuffer, db, statsQuery, indexQuery, collections, _i, _a, row, _b, namespace, total, withEmbeddings, avgDims, contentSize, error_4;
-        var _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    action = ctx.flags.action || 'list';
-                    dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
-                    output.writeln();
-                    output.writeln(output.bold('Embedding Collections (Namespaces)'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 6, , 7]);
-                    return [4 /*yield*/, import('fs')];
-                case 2:
-                    fs = _d.sent();
-                    return [4 /*yield*/, import('path')];
-                case 3:
-                    path = _d.sent();
-                    fullDbPath = path.resolve(process.cwd(), dbPath);
-                    // Check if database exists
-                    if (!fs.existsSync(fullDbPath)) {
-                        output.printWarning('No database found');
-                        output.printInfo('Run: claude-flow memory init');
-                        output.writeln();
-                        output.writeln(output.dim('No collections yet - initialize memory first'));
-                        return [2 /*return*/, { success: true, data: [] }];
-                    }
-                    return [4 /*yield*/, import('sql.js')];
-                case 4:
-                    initSqlJs = (_d.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 5:
-                    SQL = _d.sent();
-                    fileBuffer = fs.readFileSync(fullDbPath);
-                    db = new SQL.Database(fileBuffer);
-                    statsQuery = db.exec("\n        SELECT\n          namespace,\n          COUNT(*) as total_entries,\n          SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as with_embeddings,\n          AVG(embedding_dimensions) as avg_dimensions,\n          SUM(LENGTH(content)) as total_content_size\n        FROM memory_entries\n        WHERE status = 'active'\n        GROUP BY namespace\n        ORDER BY total_entries DESC\n      ");
-                    indexQuery = db.exec("SELECT name, dimensions, hnsw_m FROM vector_indexes");
-                    collections = [];
-                    if ((_c = statsQuery[0]) === null || _c === void 0 ? void 0 : _c.values) {
-                        for (_i = 0, _a = statsQuery[0].values; _i < _a.length; _i++) {
-                            row = _a[_i];
-                            _b = row, namespace = _b[0], total = _b[1], withEmbeddings = _b[2], avgDims = _b[3], contentSize = _b[4];
-                            collections.push({
-                                name: namespace || 'default',
-                                vectors: withEmbeddings.toLocaleString(),
-                                total: total.toLocaleString(),
-                                dimensions: avgDims ? Math.round(avgDims).toString() : '-',
-                                index: withEmbeddings > 0 ? 'HNSW' : 'None',
-                                size: formatBytes(contentSize || 0)
-                            });
-                        }
-                    }
-                    db.close();
-                    if (collections.length === 0) {
-                        output.printWarning('No collections found');
-                        output.writeln();
-                        output.writeln(output.dim('Store some data first:'));
-                        output.writeln(output.highlight('  claude-flow memory store -k "key" --value "data"'));
-                        return [2 /*return*/, { success: true, data: [] }];
-                    }
-                    output.printTable({
-                        columns: [
-                            { key: 'name', header: 'Namespace', width: 18 },
-                            { key: 'total', header: 'Entries', width: 10 },
-                            { key: 'vectors', header: 'Vectors', width: 10 },
-                            { key: 'dimensions', header: 'Dims', width: 8 },
-                            { key: 'index', header: 'Index', width: 8 },
-                            { key: 'size', header: 'Size', width: 10 },
-                        ],
-                        data: collections
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'list';
+        const dbPath = ctx.flags['db-path'] || '.swarm/memory.db';
+        output.writeln();
+        output.writeln(output.bold('Embedding Collections (Namespaces)'));
+        output.writeln(output.dim('─'.repeat(60)));
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            const fullDbPath = path.resolve(process.cwd(), dbPath);
+            // Check if database exists
+            if (!fs.existsSync(fullDbPath)) {
+                output.printWarning('No database found');
+                output.printInfo('Run: claude-flow memory init');
+                output.writeln();
+                output.writeln(output.dim('No collections yet - initialize memory first'));
+                return { success: true, data: [] };
+            }
+            // Load sql.js and query real data
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            const fileBuffer = fs.readFileSync(fullDbPath);
+            const db = new SQL.Database(fileBuffer);
+            // Get collection stats from database
+            const statsQuery = db.exec(`
+        SELECT
+          namespace,
+          COUNT(*) as total_entries,
+          SUM(CASE WHEN embedding IS NOT NULL THEN 1 ELSE 0 END) as with_embeddings,
+          AVG(embedding_dimensions) as avg_dimensions,
+          SUM(LENGTH(content)) as total_content_size
+        FROM memory_entries
+        WHERE status = 'active'
+        GROUP BY namespace
+        ORDER BY total_entries DESC
+      `);
+            // Get vector index info
+            const indexQuery = db.exec(`SELECT name, dimensions, hnsw_m FROM vector_indexes`);
+            const collections = [];
+            if (statsQuery[0]?.values) {
+                for (const row of statsQuery[0].values) {
+                    const [namespace, total, withEmbeddings, avgDims, contentSize] = row;
+                    collections.push({
+                        name: namespace || 'default',
+                        vectors: withEmbeddings.toLocaleString(),
+                        total: total.toLocaleString(),
+                        dimensions: avgDims ? Math.round(avgDims).toString() : '-',
+                        index: withEmbeddings > 0 ? 'HNSW' : 'None',
+                        size: formatBytes(contentSize || 0)
                     });
-                    output.writeln();
-                    output.writeln(output.dim("Database: " + fullDbPath));
-                    return [2 /*return*/, { success: true, data: collections }];
-                case 6:
-                    error_4 = _d.sent();
-                    output.printError(error_4 instanceof Error ? error_4.message : String(error_4));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 7: return [2 /*return*/];
+                }
             }
-        });
-    }); }
+            db.close();
+            if (collections.length === 0) {
+                output.printWarning('No collections found');
+                output.writeln();
+                output.writeln(output.dim('Store some data first:'));
+                output.writeln(output.highlight('  claude-flow memory store -k "key" --value "data"'));
+                return { success: true, data: [] };
+            }
+            output.printTable({
+                columns: [
+                    { key: 'name', header: 'Namespace', width: 18 },
+                    { key: 'total', header: 'Entries', width: 10 },
+                    { key: 'vectors', header: 'Vectors', width: 10 },
+                    { key: 'dimensions', header: 'Dims', width: 8 },
+                    { key: 'index', header: 'Index', width: 8 },
+                    { key: 'size', header: 'Size', width: 10 },
+                ],
+                data: collections,
+            });
+            output.writeln();
+            output.writeln(output.dim(`Database: ${fullDbPath}`));
+            return { success: true, data: collections };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Helper: Format bytes to human readable
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    var k = 1024;
-    var sizes = ['B', 'KB', 'MB', 'GB'];
-    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
     return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i];
 }
 // Index subcommand - REAL HNSW stats
-var indexCommand = {
+const indexCommand = {
     name: 'index',
     description: 'Manage HNSW indexes',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: build, rebuild, status, optimize', "default": 'status' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: build, rebuild, status, optimize', default: 'status' },
         { name: 'collection', short: 'c', type: 'string', description: 'Collection/namespace name' },
-        { name: 'ef-construction', type: 'number', description: 'HNSW ef_construction parameter', "default": '200' },
-        { name: 'm', type: 'number', description: 'HNSW M parameter', "default": '16' },
+        { name: 'ef-construction', type: 'number', description: 'HNSW ef_construction parameter', default: '200' },
+        { name: 'm', type: 'number', description: 'HNSW M parameter', default: '16' },
     ],
     examples: [
         { command: 'claude-flow embeddings index', description: 'Show index status' },
         { command: 'claude-flow embeddings index -a build -c documents', description: 'Build index' },
         { command: 'claude-flow embeddings index -a optimize -c patterns', description: 'Optimize index' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var action, collection, efConstruction, m, _a, getHNSWStatus, getHNSWIndex, searchHNSWIndex, generateEmbedding, status, testQuery, start, results, searchTime, bruteForceEstimate, speedup, spinner, index, newStatus, error_5;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    action = ctx.flags.action || 'status';
-                    collection = ctx.flags.collection;
-                    efConstruction = parseInt(ctx.flags['ef-construction'] || '200', 10);
-                    m = parseInt(ctx.flags.m || '16', 10);
-                    output.writeln();
-                    output.writeln(output.bold("HNSW Index: " + action));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 10, , 11]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    _a = _b.sent(), getHNSWStatus = _a.getHNSWStatus, getHNSWIndex = _a.getHNSWIndex, searchHNSWIndex = _a.searchHNSWIndex, generateEmbedding = _a.generateEmbedding;
-                    status = getHNSWStatus();
-                    if (!(action === 'status')) return [3 /*break*/, 7];
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 24 },
-                            { key: 'value', header: 'Value', width: 30 },
-                        ],
-                        data: [
-                            { metric: 'HNSW Available', value: status.available ? output.success('Yes (@ruvector/core)') : output.warning('No') },
-                            { metric: 'Index Initialized', value: status.initialized ? output.success('Yes') : output.dim('No') },
-                            { metric: 'Vector Count', value: status.entryCount.toLocaleString() },
-                            { metric: 'Dimensions', value: String(status.dimensions) },
-                            { metric: 'Distance Metric', value: 'Cosine' },
-                            { metric: 'HNSW M', value: String(m) },
-                            { metric: 'ef_construction', value: String(efConstruction) },
-                        ]
-                    });
-                    if (!(status.available && status.entryCount > 0)) return [3 /*break*/, 5];
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'status';
+        const collection = ctx.flags.collection;
+        const efConstruction = parseInt(ctx.flags['ef-construction'] || '200', 10);
+        const m = parseInt(ctx.flags.m || '16', 10);
+        output.writeln();
+        output.writeln(output.bold(`HNSW Index: ${action}`));
+        output.writeln(output.dim('─'.repeat(50)));
+        try {
+            const { getHNSWStatus, getHNSWIndex, searchHNSWIndex, generateEmbedding } = await import('../memory/memory-initializer.js');
+            // Get real HNSW status
+            const status = getHNSWStatus();
+            if (action === 'status') {
+                output.writeln();
+                output.printTable({
+                    columns: [
+                        { key: 'metric', header: 'Metric', width: 24 },
+                        { key: 'value', header: 'Value', width: 30 },
+                    ],
+                    data: [
+                        { metric: 'HNSW Available', value: status.available ? output.success('Yes (@ruvector/core)') : output.warning('No') },
+                        { metric: 'Index Initialized', value: status.initialized ? output.success('Yes') : output.dim('No') },
+                        { metric: 'Vector Count', value: status.entryCount.toLocaleString() },
+                        { metric: 'Dimensions', value: String(status.dimensions) },
+                        { metric: 'Distance Metric', value: 'Cosine' },
+                        { metric: 'HNSW M', value: String(m) },
+                        { metric: 'ef_construction', value: String(efConstruction) },
+                    ],
+                });
+                if (status.available && status.entryCount > 0) {
                     // Run a quick benchmark to show actual performance
                     output.writeln();
                     output.writeln(output.dim('Running quick performance test...'));
-                    return [4 /*yield*/, generateEmbedding('test performance query')];
-                case 3:
-                    testQuery = _b.sent();
-                    start = performance.now();
-                    return [4 /*yield*/, searchHNSWIndex(testQuery.embedding, { k: 10 })];
-                case 4:
-                    results = _b.sent();
-                    searchTime = performance.now() - start;
-                    bruteForceEstimate = status.entryCount * 0.0005;
-                    speedup = bruteForceEstimate / (searchTime / 1000);
+                    const testQuery = await generateEmbedding('test performance query');
+                    const start = performance.now();
+                    const results = await searchHNSWIndex(testQuery.embedding, { k: 10 });
+                    const searchTime = performance.now() - start;
+                    // Estimate brute force time (0.5μs per comparison)
+                    const bruteForceEstimate = status.entryCount * 0.0005;
+                    const speedup = bruteForceEstimate / (searchTime / 1000);
                     output.writeln();
                     output.printBox([
-                        "Performance (n=" + status.entryCount + "):",
-                        "  HNSW Search: " + searchTime.toFixed(2) + "ms",
-                        "  Brute Force Est: " + (bruteForceEstimate * 1000).toFixed(2) + "ms",
-                        "  Speedup: ~" + Math.round(speedup) + "x",
-                        "  Results: " + ((results === null || results === void 0 ? void 0 : results.length) || 0) + " matches",
+                        `Performance (n=${status.entryCount}):`,
+                        `  HNSW Search: ${searchTime.toFixed(2)}ms`,
+                        `  Brute Force Est: ${(bruteForceEstimate * 1000).toFixed(2)}ms`,
+                        `  Speedup: ~${Math.round(speedup)}x`,
+                        `  Results: ${results?.length || 0} matches`,
                     ].join('\n'), 'Search Performance');
-                    return [3 /*break*/, 6];
-                case 5:
-                    if (!status.available) {
-                        output.writeln();
-                        output.printWarning('@ruvector/core not available');
-                        output.printInfo('Install: npm install @ruvector/core');
-                    }
-                    else {
-                        output.writeln();
-                        output.printInfo('Index is empty. Store some entries to populate it.');
-                        output.printInfo('Run: claude-flow memory store -k "key" --value "text"');
-                    }
-                    _b.label = 6;
-                case 6: return [2 /*return*/, { success: true, data: status }];
-                case 7:
-                    if (!(action === 'build' || action === 'rebuild')) return [3 /*break*/, 9];
-                    if (!collection) {
-                        output.printError('Collection is required for build/rebuild');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    spinner = output.createSpinner({ text: action + "ing index for " + collection + "...", spinner: 'dots' });
-                    spinner.start();
-                    return [4 /*yield*/, getHNSWIndex({ forceRebuild: action === 'rebuild' })];
-                case 8:
-                    index = _b.sent();
-                    if (!index) {
-                        spinner.fail('@ruvector/core not available');
-                        output.printInfo('Install: npm install @ruvector/core');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    spinner.succeed("Index " + action + " complete");
-                    newStatus = getHNSWStatus();
+                }
+                else if (!status.available) {
                     output.writeln();
-                    output.printBox([
-                        "Collection: " + collection,
-                        "Action: " + action,
-                        "Vectors: " + newStatus.entryCount,
-                        "Dimensions: " + newStatus.dimensions,
-                        "M: " + m,
-                        "ef_construction: " + efConstruction,
-                    ].join('\n'), 'Index Built');
-                    return [2 /*return*/, { success: true, data: newStatus }];
-                case 9:
-                    // Optimize action
-                    if (action === 'optimize') {
-                        output.printInfo('HNSW index is optimized automatically during search');
-                        output.printInfo('No manual optimization required');
-                        return [2 /*return*/, { success: true }];
-                    }
-                    output.printError("Unknown action: " + action);
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 10:
-                    error_5 = _b.sent();
-                    output.printError(error_5 instanceof Error ? error_5.message : String(error_5));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 11: return [2 /*return*/];
+                    output.printWarning('@ruvector/core not available');
+                    output.printInfo('Install: npm install @ruvector/core');
+                }
+                else {
+                    output.writeln();
+                    output.printInfo('Index is empty. Store some entries to populate it.');
+                    output.printInfo('Run: claude-flow memory store -k "key" --value "text"');
+                }
+                return { success: true, data: status };
             }
-        });
-    }); }
+            // Build/Rebuild action
+            if (action === 'build' || action === 'rebuild') {
+                if (!collection) {
+                    output.printError('Collection is required for build/rebuild');
+                    return { success: false, exitCode: 1 };
+                }
+                const spinner = output.createSpinner({ text: `${action}ing index for ${collection}...`, spinner: 'dots' });
+                spinner.start();
+                // Force rebuild if requested
+                const index = await getHNSWIndex({ forceRebuild: action === 'rebuild' });
+                if (!index) {
+                    spinner.fail('@ruvector/core not available');
+                    output.printInfo('Install: npm install @ruvector/core');
+                    return { success: false, exitCode: 1 };
+                }
+                spinner.succeed(`Index ${action} complete`);
+                const newStatus = getHNSWStatus();
+                output.writeln();
+                output.printBox([
+                    `Collection: ${collection}`,
+                    `Action: ${action}`,
+                    `Vectors: ${newStatus.entryCount}`,
+                    `Dimensions: ${newStatus.dimensions}`,
+                    `M: ${m}`,
+                    `ef_construction: ${efConstruction}`,
+                ].join('\n'), 'Index Built');
+                return { success: true, data: newStatus };
+            }
+            // Optimize action
+            if (action === 'optimize') {
+                output.printInfo('HNSW index is optimized automatically during search');
+                output.printInfo('No manual optimization required');
+                return { success: true };
+            }
+            output.printError(`Unknown action: ${action}`);
+            return { success: false, exitCode: 1 };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Init subcommand - Initialize ONNX models and hyperbolic config
-var initCommand = {
+const initCommand = {
     name: 'init',
     description: 'Initialize embedding subsystem with ONNX model and hyperbolic config',
     options: [
-        { name: 'model', short: 'm', type: 'string', description: 'ONNX model ID', "default": 'all-MiniLM-L6-v2' },
-        { name: 'hyperbolic', type: 'boolean', description: 'Enable hyperbolic (Poincaré ball) embeddings', "default": 'true' },
-        { name: 'curvature', short: 'c', type: 'string', description: 'Poincaré ball curvature (use --curvature=-1 for negative)', "default": '-1' },
-        { name: 'download', short: 'd', type: 'boolean', description: 'Download model during init', "default": 'true' },
-        { name: 'cache-size', type: 'string', description: 'LRU cache entries', "default": '256' },
-        { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite existing configuration', "default": 'false' },
+        { name: 'model', short: 'm', type: 'string', description: 'ONNX model ID', default: 'all-MiniLM-L6-v2' },
+        { name: 'hyperbolic', type: 'boolean', description: 'Enable hyperbolic (Poincaré ball) embeddings', default: 'true' },
+        { name: 'curvature', short: 'c', type: 'string', description: 'Poincaré ball curvature (use --curvature=-1 for negative)', default: '-1' },
+        { name: 'download', short: 'd', type: 'boolean', description: 'Download model during init', default: 'true' },
+        { name: 'cache-size', type: 'string', description: 'LRU cache entries', default: '256' },
+        { name: 'force', short: 'f', type: 'boolean', description: 'Overwrite existing configuration', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow embeddings init', description: 'Initialize with defaults' },
@@ -678,243 +587,219 @@ var initCommand = {
         { command: 'claude-flow embeddings init --curvature=-0.5', description: 'Custom curvature (use = for negative)' },
         { command: 'claude-flow embeddings init --force', description: 'Overwrite existing config' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var model, hyperbolic, download, force, curvatureRaw, curvature, cacheSizeRaw, cacheSize, fs, path, configDir, modelDir, configPath, spinner_1, embeddings, dimension, config, error_6;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    model = ctx.flags.model || 'all-MiniLM-L6-v2';
-                    hyperbolic = ctx.flags.hyperbolic !== false;
-                    download = ctx.flags.download !== false;
-                    force = ctx.flags.force === true;
-                    curvatureRaw = ctx.flags.curvature || '-1';
-                    curvature = parseFloat(curvatureRaw);
-                    cacheSizeRaw = (ctx.flags['cache-size'] || ctx.flags.cacheSize || '256');
-                    cacheSize = parseInt(cacheSizeRaw, 10);
-                    output.writeln();
-                    output.writeln(output.bold('Initialize Embedding Subsystem'));
-                    output.writeln(output.dim('─'.repeat(55)));
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 9, , 10]);
-                    return [4 /*yield*/, import('fs')];
-                case 2:
-                    fs = _a.sent();
-                    return [4 /*yield*/, import('path')];
-                case 3:
-                    path = _a.sent();
-                    configDir = path.join(process.cwd(), '.claude-flow');
-                    modelDir = path.join(configDir, 'models');
-                    configPath = path.join(configDir, 'embeddings.json');
-                    // Check for existing config
-                    if (fs.existsSync(configPath) && !force) {
-                        output.printWarning('Embeddings already initialized');
-                        output.printInfo("Config exists: " + configPath);
-                        output.writeln();
-                        output.writeln(output.dim('Use --force to overwrite existing configuration'));
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    spinner_1 = output.createSpinner({ text: 'Initializing...', spinner: 'dots' });
-                    spinner_1.start();
-                    if (!fs.existsSync(configDir)) {
-                        fs.mkdirSync(configDir, { recursive: true });
-                    }
-                    if (!fs.existsSync(modelDir)) {
-                        fs.mkdirSync(modelDir, { recursive: true });
-                    }
-                    if (!download) return [3 /*break*/, 8];
-                    spinner_1.setText("Downloading ONNX model: " + model + "...");
-                    return [4 /*yield*/, getEmbeddings()];
-                case 4:
-                    embeddings = _a.sent();
-                    if (!embeddings) return [3 /*break*/, 6];
-                    return [4 /*yield*/, embeddings.downloadEmbeddingModel(model, modelDir, function (p) {
-                            spinner_1.setText("Downloading " + model + "... " + p.percent.toFixed(0) + "%");
-                        })];
-                case 5:
-                    _a.sent();
-                    return [3 /*break*/, 8];
-                case 6: 
-                // Simulate download for when embeddings package not available
-                return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 500); })];
-                case 7:
+    action: async (ctx) => {
+        const model = ctx.flags.model || 'all-MiniLM-L6-v2';
+        const hyperbolic = ctx.flags.hyperbolic !== false;
+        const download = ctx.flags.download !== false;
+        const force = ctx.flags.force === true;
+        // Parse curvature - handle both kebab-case and direct value
+        const curvatureRaw = ctx.flags.curvature || '-1';
+        const curvature = parseFloat(curvatureRaw);
+        // Parse cache-size - check both kebab-case and camelCase
+        const cacheSizeRaw = (ctx.flags['cache-size'] || ctx.flags.cacheSize || '256');
+        const cacheSize = parseInt(cacheSizeRaw, 10);
+        output.writeln();
+        output.writeln(output.bold('Initialize Embedding Subsystem'));
+        output.writeln(output.dim('─'.repeat(55)));
+        try {
+            const fs = await import('fs');
+            const path = await import('path');
+            // Create directories
+            const configDir = path.join(process.cwd(), '.claude-flow');
+            const modelDir = path.join(configDir, 'models');
+            const configPath = path.join(configDir, 'embeddings.json');
+            // Check for existing config
+            if (fs.existsSync(configPath) && !force) {
+                output.printWarning('Embeddings already initialized');
+                output.printInfo(`Config exists: ${configPath}`);
+                output.writeln();
+                output.writeln(output.dim('Use --force to overwrite existing configuration'));
+                return { success: false, exitCode: 1 };
+            }
+            const spinner = output.createSpinner({ text: 'Initializing...', spinner: 'dots' });
+            spinner.start();
+            if (!fs.existsSync(configDir)) {
+                fs.mkdirSync(configDir, { recursive: true });
+            }
+            if (!fs.existsSync(modelDir)) {
+                fs.mkdirSync(modelDir, { recursive: true });
+            }
+            // Download model if requested
+            if (download) {
+                spinner.setText(`Downloading ONNX model: ${model}...`);
+                const embeddings = await getEmbeddings();
+                if (embeddings) {
+                    await embeddings.downloadEmbeddingModel(model, modelDir, (p) => {
+                        spinner.setText(`Downloading ${model}... ${p.percent.toFixed(0)}%`);
+                    });
+                }
+                else {
                     // Simulate download for when embeddings package not available
-                    _a.sent();
+                    await new Promise(r => setTimeout(r, 500));
                     output.writeln(output.dim('  (Simulated - @claude-flow/embeddings not installed)'));
-                    _a.label = 8;
-                case 8:
-                    // Write embeddings config
-                    spinner_1.setText('Writing configuration...');
-                    dimension = model.includes('mpnet') ? 768 : 384;
-                    config = {
-                        model: model,
-                        modelPath: modelDir,
-                        dimension: dimension,
-                        cacheSize: cacheSize,
-                        hyperbolic: {
-                            enabled: hyperbolic,
-                            curvature: curvature,
-                            epsilon: 1e-15,
-                            maxNorm: 1 - 1e-5
-                        },
-                        neural: {
-                            enabled: true,
-                            driftThreshold: 0.3,
-                            decayRate: 0.01
-                        },
-                        initialized: new Date().toISOString()
-                    };
-                    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-                    spinner_1.succeed('Embedding subsystem initialized');
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'setting', header: 'Setting', width: 18 },
-                            { key: 'value', header: 'Value', width: 40 },
-                        ],
-                        data: [
-                            { setting: 'Model', value: model },
-                            { setting: 'Dimension', value: String(dimension) },
-                            { setting: 'Cache Size', value: String(cacheSize) + ' entries' },
-                            { setting: 'Hyperbolic', value: hyperbolic ? output.success('Enabled') + " (c=" + curvature + ")" : output.dim('Disabled') },
-                            { setting: 'Neural Substrate', value: output.success('Enabled') },
-                            { setting: 'Model Path', value: modelDir },
-                            { setting: 'Config', value: configPath },
-                        ]
-                    });
-                    output.writeln();
-                    if (hyperbolic) {
-                        output.printBox([
-                            'Hyperbolic Embeddings (Poincaré Ball):',
-                            '• Better for hierarchical data (trees, taxonomies)',
-                            '• Exponential capacity in low dimensions',
-                            '• Distance preserves hierarchy structure',
-                            '',
-                            'Use: embeddings hyperbolic -a convert',
-                        ].join('\n'), 'Hyperbolic Space');
-                    }
-                    output.writeln();
-                    output.writeln(output.dim('Next steps:'));
-                    output.printList([
-                        'embeddings generate -t "test text"  - Test embedding generation',
-                        'embeddings search -q "query"        - Semantic search',
-                        'memory store -k key --value text    - Store with auto-embedding',
-                    ]);
-                    return [2 /*return*/, { success: true, data: config }];
-                case 9:
-                    error_6 = _a.sent();
-                    output.printError('Initialization failed: ' + (error_6 instanceof Error ? error_6.message : String(error_6)));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 10: return [2 /*return*/];
+                }
             }
-        });
-    }); }
+            // Write embeddings config
+            spinner.setText('Writing configuration...');
+            const dimension = model.includes('mpnet') ? 768 : 384;
+            const config = {
+                model,
+                modelPath: modelDir,
+                dimension,
+                cacheSize,
+                hyperbolic: {
+                    enabled: hyperbolic,
+                    curvature,
+                    epsilon: 1e-15,
+                    maxNorm: 1 - 1e-5,
+                },
+                neural: {
+                    enabled: true,
+                    driftThreshold: 0.3,
+                    decayRate: 0.01,
+                },
+                initialized: new Date().toISOString(),
+            };
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            spinner.succeed('Embedding subsystem initialized');
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'setting', header: 'Setting', width: 18 },
+                    { key: 'value', header: 'Value', width: 40 },
+                ],
+                data: [
+                    { setting: 'Model', value: model },
+                    { setting: 'Dimension', value: String(dimension) },
+                    { setting: 'Cache Size', value: String(cacheSize) + ' entries' },
+                    { setting: 'Hyperbolic', value: hyperbolic ? `${output.success('Enabled')} (c=${curvature})` : output.dim('Disabled') },
+                    { setting: 'Neural Substrate', value: output.success('Enabled') },
+                    { setting: 'Model Path', value: modelDir },
+                    { setting: 'Config', value: configPath },
+                ],
+            });
+            output.writeln();
+            if (hyperbolic) {
+                output.printBox([
+                    'Hyperbolic Embeddings (Poincaré Ball):',
+                    '• Better for hierarchical data (trees, taxonomies)',
+                    '• Exponential capacity in low dimensions',
+                    '• Distance preserves hierarchy structure',
+                    '',
+                    'Use: embeddings hyperbolic -a convert',
+                ].join('\n'), 'Hyperbolic Space');
+            }
+            output.writeln();
+            output.writeln(output.dim('Next steps:'));
+            output.printList([
+                'embeddings generate -t "test text"  - Test embedding generation',
+                'embeddings search -q "query"        - Semantic search',
+                'memory store -k key --value text    - Store with auto-embedding',
+            ]);
+            return { success: true, data: config };
+        }
+        catch (error) {
+            output.printError('Initialization failed: ' + (error instanceof Error ? error.message : String(error)));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Providers subcommand
-var providersCommand = {
+const providersCommand = {
     name: 'providers',
     description: 'List available embedding providers',
     options: [],
     examples: [
         { command: 'claude-flow embeddings providers', description: 'List providers' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('Embedding Providers'));
-            output.writeln(output.dim('─'.repeat(70)));
-            output.printTable({
-                columns: [
-                    { key: 'provider', header: 'Provider', width: 18 },
-                    { key: 'model', header: 'Model', width: 25 },
-                    { key: 'dims', header: 'Dims', width: 8 },
-                    { key: 'type', header: 'Type', width: 10 },
-                    { key: 'status', header: 'Status', width: 12 },
-                ],
-                data: [
-                    { provider: 'OpenAI', model: 'text-embedding-3-small', dims: '1536', type: 'Cloud', status: output.success('Ready') },
-                    { provider: 'OpenAI', model: 'text-embedding-3-large', dims: '3072', type: 'Cloud', status: output.success('Ready') },
-                    { provider: 'Transformers.js', model: 'all-MiniLM-L6-v2', dims: '384', type: 'Local', status: output.success('Ready') },
-                    { provider: 'Agentic Flow', model: 'ONNX optimized', dims: '384', type: 'Local', status: output.success('Ready') },
-                    { provider: 'Mock', model: 'mock-embedding', dims: '384', type: 'Dev', status: output.dim('Dev only') },
-                ]
-            });
-            output.writeln();
-            output.writeln(output.dim('Agentic Flow provider uses WASM SIMD for 75x faster inference'));
-            return [2 /*return*/, { success: true }];
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('Embedding Providers'));
+        output.writeln(output.dim('─'.repeat(70)));
+        output.printTable({
+            columns: [
+                { key: 'provider', header: 'Provider', width: 18 },
+                { key: 'model', header: 'Model', width: 25 },
+                { key: 'dims', header: 'Dims', width: 8 },
+                { key: 'type', header: 'Type', width: 10 },
+                { key: 'status', header: 'Status', width: 12 },
+            ],
+            data: [
+                { provider: 'OpenAI', model: 'text-embedding-3-small', dims: '1536', type: 'Cloud', status: output.success('Ready') },
+                { provider: 'OpenAI', model: 'text-embedding-3-large', dims: '3072', type: 'Cloud', status: output.success('Ready') },
+                { provider: 'Transformers.js', model: 'all-MiniLM-L6-v2', dims: '384', type: 'Local', status: output.success('Ready') },
+                { provider: 'Agentic Flow', model: 'ONNX optimized', dims: '384', type: 'Local', status: output.success('Ready') },
+                { provider: 'Mock', model: 'mock-embedding', dims: '384', type: 'Dev', status: output.dim('Dev only') },
+            ],
         });
-    }); }
+        output.writeln();
+        output.writeln(output.dim('Agentic Flow provider uses WASM SIMD for 75x faster inference'));
+        return { success: true };
+    },
 };
 // Chunk subcommand
-var chunkCommand = {
+const chunkCommand = {
     name: 'chunk',
     description: 'Chunk text for embedding with overlap',
     options: [
         { name: 'text', short: 't', type: 'string', description: 'Text to chunk', required: true },
-        { name: 'max-size', short: 's', type: 'number', description: 'Max chunk size in chars', "default": '512' },
-        { name: 'overlap', short: 'o', type: 'number', description: 'Overlap between chunks', "default": '50' },
-        { name: 'strategy', type: 'string', description: 'Strategy: character, sentence, paragraph, token', "default": 'sentence' },
+        { name: 'max-size', short: 's', type: 'number', description: 'Max chunk size in chars', default: '512' },
+        { name: 'overlap', short: 'o', type: 'number', description: 'Overlap between chunks', default: '50' },
+        { name: 'strategy', type: 'string', description: 'Strategy: character, sentence, paragraph, token', default: 'sentence' },
         { name: 'file', short: 'f', type: 'string', description: 'File to chunk (instead of text)' },
     ],
     examples: [
         { command: 'claude-flow embeddings chunk -t "Long text..." -s 256', description: 'Chunk with 256 char limit' },
         { command: 'claude-flow embeddings chunk -f doc.txt --strategy paragraph', description: 'Chunk file by paragraph' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var embeddings, text, maxSize, overlap, strategy, result;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getEmbeddings()];
-                case 1:
-                    embeddings = _a.sent();
-                    text = ctx.flags.text || '';
-                    maxSize = parseInt(ctx.flags['max-size'] || '512', 10);
-                    overlap = parseInt(ctx.flags.overlap || '50', 10);
-                    strategy = ctx.flags.strategy || 'sentence';
-                    output.writeln();
-                    output.writeln(output.bold('Document Chunking'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    if (!embeddings) {
-                        output.printWarning('@claude-flow/embeddings not installed, showing preview');
-                        output.writeln();
-                        output.printBox([
-                            "Strategy: " + strategy,
-                            "Max Size: " + maxSize + " chars",
-                            "Overlap: " + overlap + " chars",
-                            "",
-                            "Estimated chunks: " + Math.ceil(text.length / (maxSize - overlap)),
-                        ].join('\n'), 'Chunking Preview');
-                        return [2 /*return*/, { success: true }];
-                    }
-                    result = embeddings.chunkText(text, { maxChunkSize: maxSize, overlap: overlap, strategy: strategy });
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'idx', header: '#', width: 5 },
-                            { key: 'length', header: 'Chars', width: 8 },
-                            { key: 'tokens', header: 'Tokens', width: 8 },
-                            { key: 'preview', header: 'Preview', width: 45 },
-                        ],
-                        data: result.chunks.map(function (c, i) { return ({
-                            idx: String(i + 1),
-                            length: String(c.length),
-                            tokens: String(c.tokenCount),
-                            preview: c.text.substring(0, 42) + (c.text.length > 42 ? '...' : '')
-                        }); })
-                    });
-                    output.writeln();
-                    output.writeln(output.dim("Total: " + result.totalChunks + " chunks from " + result.originalLength + " chars"));
-                    return [2 /*return*/, { success: true }];
-            }
+    action: async (ctx) => {
+        const embeddings = await getEmbeddings();
+        const text = ctx.flags.text || '';
+        const maxSize = parseInt(ctx.flags['max-size'] || '512', 10);
+        const overlap = parseInt(ctx.flags.overlap || '50', 10);
+        const strategy = ctx.flags.strategy || 'sentence';
+        output.writeln();
+        output.writeln(output.bold('Document Chunking'));
+        output.writeln(output.dim('─'.repeat(50)));
+        if (!embeddings) {
+            output.printWarning('@claude-flow/embeddings not installed, showing preview');
+            output.writeln();
+            output.printBox([
+                `Strategy: ${strategy}`,
+                `Max Size: ${maxSize} chars`,
+                `Overlap: ${overlap} chars`,
+                ``,
+                `Estimated chunks: ${Math.ceil(text.length / (maxSize - overlap))}`,
+            ].join('\n'), 'Chunking Preview');
+            return { success: true };
+        }
+        const result = embeddings.chunkText(text, { maxChunkSize: maxSize, overlap, strategy: strategy });
+        output.writeln();
+        output.printTable({
+            columns: [
+                { key: 'idx', header: '#', width: 5 },
+                { key: 'length', header: 'Chars', width: 8 },
+                { key: 'tokens', header: 'Tokens', width: 8 },
+                { key: 'preview', header: 'Preview', width: 45 },
+            ],
+            data: result.chunks.map((c, i) => ({
+                idx: String(i + 1),
+                length: String(c.length),
+                tokens: String(c.tokenCount),
+                preview: c.text.substring(0, 42) + (c.text.length > 42 ? '...' : ''),
+            })),
         });
-    }); }
+        output.writeln();
+        output.writeln(output.dim(`Total: ${result.totalChunks} chunks from ${result.originalLength} chars`));
+        return { success: true };
+    },
 };
 // Normalize subcommand
-var normalizeCommand = {
+const normalizeCommand = {
     name: 'normalize',
     description: 'Normalize embedding vectors',
     options: [
-        { name: 'type', short: 't', type: 'string', description: 'Type: l2, l1, minmax, zscore', "default": 'l2' },
+        { name: 'type', short: 't', type: 'string', description: 'Type: l2, l1, minmax, zscore', default: 'l2' },
         { name: 'input', short: 'i', type: 'string', description: 'Input embedding (JSON array)' },
         { name: 'check', short: 'c', type: 'boolean', description: 'Check if already normalized' },
     ],
@@ -922,159 +807,147 @@ var normalizeCommand = {
         { command: 'claude-flow embeddings normalize -i "[0.5, 0.3, 0.8]" -t l2', description: 'L2 normalize' },
         { command: 'claude-flow embeddings normalize --check -i "[...]"', description: 'Check if normalized' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var type, check;
-        return __generator(this, function (_a) {
-            type = ctx.flags.type || 'l2';
-            check = ctx.flags.check;
-            output.writeln();
-            output.writeln(output.bold('Embedding Normalization'));
-            output.writeln(output.dim('─'.repeat(50)));
-            output.printTable({
-                columns: [
-                    { key: 'type', header: 'Type', width: 12 },
-                    { key: 'formula', header: 'Formula', width: 30 },
-                    { key: 'use', header: 'Best For', width: 25 },
-                ],
-                data: [
-                    { type: output.success('L2'), formula: 'v / ||v||₂', use: 'Cosine similarity' },
-                    { type: 'L1', formula: 'v / ||v||₁', use: 'Sparse vectors' },
-                    { type: 'Min-Max', formula: '(v - min) / (max - min)', use: 'Bounded range [0,1]' },
-                    { type: 'Z-Score', formula: '(v - μ) / σ', use: 'Statistical analysis' },
-                ]
-            });
-            output.writeln();
-            output.writeln(output.dim("Selected: " + type.toUpperCase() + " normalization"));
-            output.writeln(output.dim('Most embedding models pre-normalize with L2'));
-            return [2 /*return*/, { success: true }];
+    action: async (ctx) => {
+        const type = ctx.flags.type || 'l2';
+        const check = ctx.flags.check;
+        output.writeln();
+        output.writeln(output.bold('Embedding Normalization'));
+        output.writeln(output.dim('─'.repeat(50)));
+        output.printTable({
+            columns: [
+                { key: 'type', header: 'Type', width: 12 },
+                { key: 'formula', header: 'Formula', width: 30 },
+                { key: 'use', header: 'Best For', width: 25 },
+            ],
+            data: [
+                { type: output.success('L2'), formula: 'v / ||v||₂', use: 'Cosine similarity' },
+                { type: 'L1', formula: 'v / ||v||₁', use: 'Sparse vectors' },
+                { type: 'Min-Max', formula: '(v - min) / (max - min)', use: 'Bounded range [0,1]' },
+                { type: 'Z-Score', formula: '(v - μ) / σ', use: 'Statistical analysis' },
+            ],
         });
-    }); }
+        output.writeln();
+        output.writeln(output.dim(`Selected: ${type.toUpperCase()} normalization`));
+        output.writeln(output.dim('Most embedding models pre-normalize with L2'));
+        return { success: true };
+    },
 };
 // Hyperbolic subcommand
-var hyperbolicCommand = {
+const hyperbolicCommand = {
     name: 'hyperbolic',
     description: 'Hyperbolic embedding operations (Poincaré ball)',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: convert, distance, centroid', "default": 'convert' },
-        { name: 'curvature', short: 'c', type: 'number', description: 'Hyperbolic curvature', "default": '-1' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: convert, distance, centroid', default: 'convert' },
+        { name: 'curvature', short: 'c', type: 'number', description: 'Hyperbolic curvature', default: '-1' },
         { name: 'input', short: 'i', type: 'string', description: 'Input embedding(s) JSON' },
     ],
     examples: [
         { command: 'claude-flow embeddings hyperbolic -a convert -i "[0.5, 0.3]"', description: 'Convert to Poincaré' },
         { command: 'claude-flow embeddings hyperbolic -a distance', description: 'Compute hyperbolic distance' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var action, curvature, inputJson, hyperbolic, input, vec, rawResult, result, _a, v1, v2, dist, vectors, rawCentroid, centroid, error_7;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    action = ctx.flags.action || 'convert';
-                    curvature = parseFloat(ctx.flags.curvature || '-1');
-                    inputJson = ctx.flags.input;
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'convert';
+        const curvature = parseFloat(ctx.flags.curvature || '-1');
+        const inputJson = ctx.flags.input;
+        output.writeln();
+        output.writeln(output.bold('Hyperbolic Embeddings'));
+        output.writeln(output.dim('Poincaré Ball Model'));
+        output.writeln(output.dim('─'.repeat(50)));
+        // Try to import hyperbolic functions from embeddings package
+        try {
+            const hyperbolic = await import('@claude-flow/embeddings').then(m => m).catch(() => null);
+            if (!hyperbolic || !hyperbolic.euclideanToPoincare) {
+                output.printWarning('@claude-flow/embeddings hyperbolic module not available');
+                output.printInfo('Install with: npm install @claude-flow/embeddings');
+                return { success: false, exitCode: 1 };
+            }
+            if (!inputJson) {
+                // Show help if no input
+                output.printBox([
+                    'Hyperbolic embeddings excel at:',
+                    '• Hierarchical data representation',
+                    '• Tree-like structure preservation',
+                    '• Low-dimensional hierarchy encoding',
+                    '',
+                    'Actions: convert, distance, centroid',
+                    '',
+                    'Examples:',
+                    '  -a convert -i "[0.5, 0.3, 0.1]"',
+                    '  -a distance -i "[[0.1,0.2],[0.3,0.4]]"',
+                ].join('\n'), 'Hyperbolic Geometry');
+                return { success: true };
+            }
+            // Parse input vector(s)
+            let input;
+            try {
+                input = JSON.parse(inputJson);
+            }
+            catch {
+                output.printError('Invalid JSON input. Use format: "[0.5, 0.3]" or "[[0.1,0.2],[0.3,0.4]]"');
+                return { success: false, exitCode: 1 };
+            }
+            switch (action) {
+                case 'convert': {
+                    const vec = Array.isArray(input[0]) ? input[0] : input;
+                    const rawResult = hyperbolic.euclideanToPoincare(vec, { curvature });
+                    const result = Array.from(rawResult);
+                    output.writeln(output.success('Euclidean → Poincaré conversion:'));
                     output.writeln();
-                    output.writeln(output.bold('Hyperbolic Embeddings'));
-                    output.writeln(output.dim('Poincaré Ball Model'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, import('@claude-flow/embeddings').then(function (m) { return m; })["catch"](function () { return null; })];
-                case 2:
-                    hyperbolic = _b.sent();
-                    if (!hyperbolic || !hyperbolic.euclideanToPoincare) {
-                        output.printWarning('@claude-flow/embeddings hyperbolic module not available');
-                        output.printInfo('Install with: npm install @claude-flow/embeddings');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    output.writeln(`Input (Euclidean):  [${vec.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${vec.length > 6 ? ', ...' : ''}]`);
+                    output.writeln(`Output (Poincaré):  [${result.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${result.length > 6 ? ', ...' : ''}]`);
+                    output.writeln(`Curvature: ${curvature}`);
+                    output.writeln(`Norm: ${Math.sqrt(result.reduce((s, v) => s + v * v, 0)).toFixed(6)} (must be < 1)`);
+                    return { success: true, data: { result } };
+                }
+                case 'distance': {
+                    if (!Array.isArray(input[0]) || input.length < 2) {
+                        output.printError('Distance requires two vectors: "[[v1],[v2]]"');
+                        return { success: false, exitCode: 1 };
                     }
-                    if (!inputJson) {
-                        // Show help if no input
-                        output.printBox([
-                            'Hyperbolic embeddings excel at:',
-                            '• Hierarchical data representation',
-                            '• Tree-like structure preservation',
-                            '• Low-dimensional hierarchy encoding',
-                            '',
-                            'Actions: convert, distance, centroid',
-                            '',
-                            'Examples:',
-                            '  -a convert -i "[0.5, 0.3, 0.1]"',
-                            '  -a distance -i "[[0.1,0.2],[0.3,0.4]]"',
-                        ].join('\n'), 'Hyperbolic Geometry');
-                        return [2 /*return*/, { success: true }];
-                    }
-                    input = void 0;
-                    try {
-                        input = JSON.parse(inputJson);
-                    }
-                    catch (_c) {
-                        output.printError('Invalid JSON input. Use format: "[0.5, 0.3]" or "[[0.1,0.2],[0.3,0.4]]"');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    switch (action) {
-                        case 'convert': {
-                            vec = Array.isArray(input[0]) ? input[0] : input;
-                            rawResult = hyperbolic.euclideanToPoincare(vec, { curvature: curvature });
-                            result = Array.from(rawResult);
-                            output.writeln(output.success('Euclidean → Poincaré conversion:'));
-                            output.writeln();
-                            output.writeln("Input (Euclidean):  [" + vec.slice(0, 6).map(function (v) { return v.toFixed(4); }).join(', ') + (vec.length > 6 ? ', ...' : '') + "]");
-                            output.writeln("Output (Poincar\u00E9):  [" + result.slice(0, 6).map(function (v) { return v.toFixed(4); }).join(', ') + (result.length > 6 ? ', ...' : '') + "]");
-                            output.writeln("Curvature: " + curvature);
-                            output.writeln("Norm: " + Math.sqrt(result.reduce(function (s, v) { return s + v * v; }, 0)).toFixed(6) + " (must be < 1)");
-                            return [2 /*return*/, { success: true, data: { result: result } }];
-                        }
-                        case 'distance': {
-                            if (!Array.isArray(input[0]) || input.length < 2) {
-                                output.printError('Distance requires two vectors: "[[v1],[v2]]"');
-                                return [2 /*return*/, { success: false, exitCode: 1 }];
-                            }
-                            _a = input, v1 = _a[0], v2 = _a[1];
-                            dist = hyperbolic.hyperbolicDistance(v1, v2, { curvature: curvature });
-                            output.writeln(output.success('Hyperbolic (geodesic) distance:'));
-                            output.writeln();
-                            output.writeln("Vector 1: [" + v1.slice(0, 4).map(function (v) { return v.toFixed(4); }).join(', ') + "...]");
-                            output.writeln("Vector 2: [" + v2.slice(0, 4).map(function (v) { return v.toFixed(4); }).join(', ') + "...]");
-                            output.writeln("Distance: " + dist.toFixed(6));
-                            return [2 /*return*/, { success: true, data: { distance: dist } }];
-                        }
-                        case 'centroid': {
-                            if (!Array.isArray(input[0])) {
-                                output.printError('Centroid requires multiple vectors: "[[v1],[v2],...]"');
-                                return [2 /*return*/, { success: false, exitCode: 1 }];
-                            }
-                            vectors = input;
-                            rawCentroid = hyperbolic.hyperbolicCentroid(vectors, { curvature: curvature });
-                            centroid = Array.from(rawCentroid);
-                            output.writeln(output.success('Hyperbolic centroid (Fréchet mean):'));
-                            output.writeln();
-                            output.writeln("Input vectors: " + vectors.length);
-                            output.writeln("Centroid: [" + centroid.slice(0, 6).map(function (v) { return v.toFixed(4); }).join(', ') + (centroid.length > 6 ? ', ...' : '') + "]");
-                            return [2 /*return*/, { success: true, data: { centroid: centroid } }];
-                        }
-                        default:
-                            output.printError("Unknown action: " + action + ". Use: convert, distance, centroid");
-                            return [2 /*return*/, { success: false, exitCode: 1 }];
+                    const [v1, v2] = input;
+                    const dist = hyperbolic.hyperbolicDistance(v1, v2, { curvature });
+                    output.writeln(output.success('Hyperbolic (geodesic) distance:'));
+                    output.writeln();
+                    output.writeln(`Vector 1: [${v1.slice(0, 4).map(v => v.toFixed(4)).join(', ')}...]`);
+                    output.writeln(`Vector 2: [${v2.slice(0, 4).map(v => v.toFixed(4)).join(', ')}...]`);
+                    output.writeln(`Distance: ${dist.toFixed(6)}`);
+                    return { success: true, data: { distance: dist } };
+                }
+                case 'centroid': {
+                    if (!Array.isArray(input[0])) {
+                        output.printError('Centroid requires multiple vectors: "[[v1],[v2],...]"');
+                        return { success: false, exitCode: 1 };
                     }
-                    return [3 /*break*/, 4];
-                case 3:
-                    error_7 = _b.sent();
-                    output.printError("Hyperbolic operation failed: " + error_7.message);
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 4: return [2 /*return*/];
+                    const vectors = input;
+                    const rawCentroid = hyperbolic.hyperbolicCentroid(vectors, { curvature });
+                    const centroid = Array.from(rawCentroid);
+                    output.writeln(output.success('Hyperbolic centroid (Fréchet mean):'));
+                    output.writeln();
+                    output.writeln(`Input vectors: ${vectors.length}`);
+                    output.writeln(`Centroid: [${centroid.slice(0, 6).map(v => v.toFixed(4)).join(', ')}${centroid.length > 6 ? ', ...' : ''}]`);
+                    return { success: true, data: { centroid } };
+                }
+                default:
+                    output.printError(`Unknown action: ${action}. Use: convert, distance, centroid`);
+                    return { success: false, exitCode: 1 };
             }
-        });
-    }); }
+        }
+        catch (error) {
+            output.printError(`Hyperbolic operation failed: ${error.message}`);
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Neural subcommand
-var neuralCommand = {
+const neuralCommand = {
     name: 'neural',
     description: 'Neural substrate features (RuVector integration)',
     options: [
-        { name: 'feature', short: 'f', type: 'string', description: 'Feature: drift, memory, swarm, coherence, all', "default": 'all' },
+        { name: 'feature', short: 'f', type: 'string', description: 'Feature: drift, memory, swarm, coherence, all', default: 'all' },
         { name: 'init', type: 'boolean', description: 'Initialize neural substrate with RuVector' },
-        { name: 'drift-threshold', type: 'string', description: 'Semantic drift detection threshold', "default": '0.3' },
-        { name: 'decay-rate', type: 'string', description: 'Memory decay rate (hippocampal dynamics)', "default": '0.01' },
-        { name: 'consolidation-interval', type: 'string', description: 'Memory consolidation interval (ms)', "default": '60000' },
+        { name: 'drift-threshold', type: 'string', description: 'Semantic drift detection threshold', default: '0.3' },
+        { name: 'decay-rate', type: 'string', description: 'Memory decay rate (hippocampal dynamics)', default: '0.01' },
+        { name: 'consolidation-interval', type: 'string', description: 'Memory consolidation interval (ms)', default: '60000' },
     ],
     examples: [
         { command: 'claude-flow embeddings neural --init', description: 'Initialize RuVector substrate' },
@@ -1083,676 +956,555 @@ var neuralCommand = {
         { command: 'claude-flow embeddings neural -f coherence', description: 'Safety & alignment monitoring' },
         { command: 'claude-flow embeddings neural --drift-threshold=0.2', description: 'Custom drift threshold' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var feature, init, driftThreshold, decayRate, consolidationInterval, fs, path, configPath, config, neuralConfig, features, ruvector;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    feature = ctx.flags.feature || 'all';
-                    init = ctx.flags.init;
-                    driftThreshold = parseFloat((ctx.flags['drift-threshold'] || ctx.flags.driftThreshold || '0.3'));
-                    decayRate = parseFloat((ctx.flags['decay-rate'] || ctx.flags.decayRate || '0.01'));
-                    consolidationInterval = parseInt((ctx.flags['consolidation-interval'] || ctx.flags.consolidationInterval || '60000'), 10);
-                    output.writeln();
-                    output.writeln(output.bold('Neural Embedding Substrate (RuVector)'));
-                    output.writeln(output.dim('Treating embeddings as a synthetic nervous system'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    return [4 /*yield*/, import('fs')];
-                case 1:
-                    fs = _a.sent();
-                    return [4 /*yield*/, import('path')];
-                case 2:
-                    path = _a.sent();
-                    configPath = path.join(process.cwd(), '.claude-flow', 'embeddings.json');
-                    if (!fs.existsSync(configPath)) {
-                        output.printWarning('Embeddings not initialized');
-                        output.printInfo('Run "embeddings init" first to configure ONNX model');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    config = {};
-                    try {
-                        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-                    }
-                    catch (_b) {
-                        config = {};
-                    }
-                    if (init) {
-                        // Initialize neural substrate configuration
-                        config.neural = {
-                            enabled: true,
-                            driftThreshold: driftThreshold,
-                            decayRate: decayRate,
-                            consolidationInterval: consolidationInterval,
-                            ruvector: {
-                                enabled: true,
-                                sona: true,
-                                flashAttention: true,
-                                ewcPlusPlus: true
-                            },
-                            features: {
-                                semanticDrift: true,
-                                memoryPhysics: true,
-                                stateMachine: true,
-                                swarmCoordination: true,
-                                coherenceMonitor: true
-                            },
-                            initializedAt: new Date().toISOString()
-                        };
-                        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-                        output.printSuccess('Neural substrate initialized');
-                        output.writeln();
-                    }
-                    neuralConfig = (config.neural || {});
-                    features = (neuralConfig.features || {});
-                    ruvector = (neuralConfig.ruvector || {});
-                    output.printTable({
-                        columns: [
-                            { key: 'feature', header: 'Feature', width: 24 },
-                            { key: 'description', header: 'Description', width: 38 },
-                            { key: 'status', header: 'Status', width: 12 },
-                        ],
-                        data: [
-                            {
-                                feature: 'SemanticDriftDetector',
-                                description: "Monitor semantic movement (threshold: " + driftThreshold + ")",
-                                status: features.semanticDrift ? output.success('Active') : output.dim('Inactive')
-                            },
-                            {
-                                feature: 'MemoryPhysics',
-                                description: "Hippocampal dynamics (decay: " + decayRate + ")",
-                                status: features.memoryPhysics ? output.success('Active') : output.dim('Inactive')
-                            },
-                            {
-                                feature: 'EmbeddingStateMachine',
-                                description: 'Agent state through geometry',
-                                status: features.stateMachine ? output.success('Active') : output.dim('Inactive')
-                            },
-                            {
-                                feature: 'SwarmCoordinator',
-                                description: 'Multi-agent embedding coordination',
-                                status: features.swarmCoordination ? output.success('Active') : output.dim('Inactive')
-                            },
-                            {
-                                feature: 'CoherenceMonitor',
-                                description: 'Safety & alignment detection',
-                                status: features.coherenceMonitor ? output.success('Active') : output.dim('Inactive')
-                            },
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.bold('RuVector Integration'));
-                    output.printTable({
-                        columns: [
-                            { key: 'component', header: 'Component', width: 24 },
-                            { key: 'description', header: 'Description', width: 38 },
-                            { key: 'status', header: 'Status', width: 12 },
-                        ],
-                        data: [
-                            {
-                                component: 'SONA',
-                                description: 'Self-Optimizing Neural Architecture (<0.05ms)',
-                                status: ruvector.sona ? output.success('Enabled') : output.dim('Disabled')
-                            },
-                            {
-                                component: 'Flash Attention',
-                                description: '2.49x-7.47x attention speedup',
-                                status: ruvector.flashAttention ? output.success('Enabled') : output.dim('Disabled')
-                            },
-                            {
-                                component: 'EWC++',
-                                description: 'Elastic Weight Consolidation (anti-forgetting)',
-                                status: ruvector.ewcPlusPlus ? output.success('Enabled') : output.dim('Disabled')
-                            },
-                            {
-                                component: 'Hyperbolic Space',
-                                description: 'Poincaré ball for hierarchy preservation',
-                                status: config.hyperbolic ? output.success('Enabled') : output.dim('Disabled')
-                            },
-                        ]
-                    });
-                    output.writeln();
-                    if (!neuralConfig.enabled) {
-                        output.printInfo('Run with --init to enable neural substrate');
-                    }
-                    else {
-                        output.writeln(output.dim('Configuration: .claude-flow/embeddings.json'));
-                        output.writeln(output.dim('Next: Use "hooks pretrain" to train patterns'));
-                    }
-                    return [2 /*return*/, { success: true, data: { config: neuralConfig, feature: feature } }];
-            }
+    action: async (ctx) => {
+        const feature = ctx.flags.feature || 'all';
+        const init = ctx.flags.init;
+        const driftThreshold = parseFloat((ctx.flags['drift-threshold'] || ctx.flags.driftThreshold || '0.3'));
+        const decayRate = parseFloat((ctx.flags['decay-rate'] || ctx.flags.decayRate || '0.01'));
+        const consolidationInterval = parseInt((ctx.flags['consolidation-interval'] || ctx.flags.consolidationInterval || '60000'), 10);
+        output.writeln();
+        output.writeln(output.bold('Neural Embedding Substrate (RuVector)'));
+        output.writeln(output.dim('Treating embeddings as a synthetic nervous system'));
+        output.writeln(output.dim('─'.repeat(60)));
+        // Check if embeddings config exists
+        const fs = await import('fs');
+        const path = await import('path');
+        const configPath = path.join(process.cwd(), '.claude-flow', 'embeddings.json');
+        if (!fs.existsSync(configPath)) {
+            output.printWarning('Embeddings not initialized');
+            output.printInfo('Run "embeddings init" first to configure ONNX model');
+            return { success: false, exitCode: 1 };
+        }
+        // Load and update config
+        let config = {};
+        try {
+            config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+        }
+        catch {
+            config = {};
+        }
+        if (init) {
+            // Initialize neural substrate configuration
+            config.neural = {
+                enabled: true,
+                driftThreshold,
+                decayRate,
+                consolidationInterval,
+                ruvector: {
+                    enabled: true,
+                    sona: true, // Self-Optimizing Neural Architecture
+                    flashAttention: true,
+                    ewcPlusPlus: true, // Elastic Weight Consolidation
+                },
+                features: {
+                    semanticDrift: true,
+                    memoryPhysics: true,
+                    stateMachine: true,
+                    swarmCoordination: true,
+                    coherenceMonitor: true,
+                },
+                initializedAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            output.printSuccess('Neural substrate initialized');
+            output.writeln();
+        }
+        const neuralConfig = (config.neural || {});
+        const features = (neuralConfig.features || {});
+        const ruvector = (neuralConfig.ruvector || {});
+        output.printTable({
+            columns: [
+                { key: 'feature', header: 'Feature', width: 24 },
+                { key: 'description', header: 'Description', width: 38 },
+                { key: 'status', header: 'Status', width: 12 },
+            ],
+            data: [
+                {
+                    feature: 'SemanticDriftDetector',
+                    description: `Monitor semantic movement (threshold: ${driftThreshold})`,
+                    status: features.semanticDrift ? output.success('Active') : output.dim('Inactive')
+                },
+                {
+                    feature: 'MemoryPhysics',
+                    description: `Hippocampal dynamics (decay: ${decayRate})`,
+                    status: features.memoryPhysics ? output.success('Active') : output.dim('Inactive')
+                },
+                {
+                    feature: 'EmbeddingStateMachine',
+                    description: 'Agent state through geometry',
+                    status: features.stateMachine ? output.success('Active') : output.dim('Inactive')
+                },
+                {
+                    feature: 'SwarmCoordinator',
+                    description: 'Multi-agent embedding coordination',
+                    status: features.swarmCoordination ? output.success('Active') : output.dim('Inactive')
+                },
+                {
+                    feature: 'CoherenceMonitor',
+                    description: 'Safety & alignment detection',
+                    status: features.coherenceMonitor ? output.success('Active') : output.dim('Inactive')
+                },
+            ],
         });
-    }); }
+        output.writeln();
+        output.writeln(output.bold('RuVector Integration'));
+        output.printTable({
+            columns: [
+                { key: 'component', header: 'Component', width: 24 },
+                { key: 'description', header: 'Description', width: 38 },
+                { key: 'status', header: 'Status', width: 12 },
+            ],
+            data: [
+                {
+                    component: 'SONA',
+                    description: 'Self-Optimizing Neural Architecture (<0.05ms)',
+                    status: ruvector.sona ? output.success('Enabled') : output.dim('Disabled')
+                },
+                {
+                    component: 'Flash Attention',
+                    description: '2.49x-7.47x attention speedup',
+                    status: ruvector.flashAttention ? output.success('Enabled') : output.dim('Disabled')
+                },
+                {
+                    component: 'EWC++',
+                    description: 'Elastic Weight Consolidation (anti-forgetting)',
+                    status: ruvector.ewcPlusPlus ? output.success('Enabled') : output.dim('Disabled')
+                },
+                {
+                    component: 'Hyperbolic Space',
+                    description: 'Poincaré ball for hierarchy preservation',
+                    status: config.hyperbolic ? output.success('Enabled') : output.dim('Disabled')
+                },
+            ],
+        });
+        output.writeln();
+        if (!neuralConfig.enabled) {
+            output.printInfo('Run with --init to enable neural substrate');
+        }
+        else {
+            output.writeln(output.dim('Configuration: .claude-flow/embeddings.json'));
+            output.writeln(output.dim('Next: Use "hooks pretrain" to train patterns'));
+        }
+        return { success: true, data: { config: neuralConfig, feature } };
+    },
 };
 // Models subcommand
-var modelsCommand = {
+const modelsCommand = {
     name: 'models',
     description: 'List and download embedding models',
     options: [
         { name: 'download', short: 'd', type: 'string', description: 'Model ID to download' },
-        { name: 'list', short: 'l', type: 'boolean', description: 'List available models', "default": 'true' },
+        { name: 'list', short: 'l', type: 'boolean', description: 'List available models', default: 'true' },
     ],
     examples: [
         { command: 'claude-flow embeddings models', description: 'List models' },
         { command: 'claude-flow embeddings models -d all-MiniLM-L6-v2', description: 'Download model' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var download, embeddings, spinner_2, err_1, models, _a;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    download = ctx.flags.download;
-                    return [4 /*yield*/, getEmbeddings()];
-                case 1:
-                    embeddings = _b.sent();
-                    output.writeln();
-                    output.writeln(output.bold('Embedding Models'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    if (!download) return [3 /*break*/, 9];
-                    spinner_2 = output.createSpinner({ text: "Downloading " + download + "...", spinner: 'dots' });
-                    spinner_2.start();
-                    if (!embeddings) return [3 /*break*/, 6];
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, embeddings.downloadEmbeddingModel(download, '.models', function (p) {
-                            spinner_2.setText("Downloading " + download + "... " + p.percent.toFixed(1) + "%");
-                        })];
-                case 3:
-                    _b.sent();
-                    spinner_2.succeed("Downloaded " + download);
-                    return [3 /*break*/, 5];
-                case 4:
-                    err_1 = _b.sent();
-                    spinner_2.fail("Failed to download: " + err_1);
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5: return [3 /*break*/, 8];
-                case 6: return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, 500); })];
-                case 7:
-                    _b.sent();
-                    spinner_2.succeed("Download complete (simulated)");
-                    _b.label = 8;
-                case 8: return [2 /*return*/, { success: true }];
-                case 9:
-                    models = [
-                        { id: 'all-MiniLM-L6-v2', dimension: 384, size: '23MB', quantized: false, downloaded: true },
-                        { id: 'all-mpnet-base-v2', dimension: 768, size: '110MB', quantized: false, downloaded: false },
-                        { id: 'paraphrase-MiniLM-L3-v2', dimension: 384, size: '17MB', quantized: false, downloaded: false },
-                    ];
-                    if (!embeddings) return [3 /*break*/, 13];
-                    _b.label = 10;
-                case 10:
-                    _b.trys.push([10, 12, , 13]);
-                    return [4 /*yield*/, embeddings.listEmbeddingModels()];
-                case 11:
-                    models = _b.sent();
-                    return [3 /*break*/, 13];
-                case 12:
-                    _a = _b.sent();
-                    return [3 /*break*/, 13];
-                case 13:
-                    output.printTable({
-                        columns: [
-                            { key: 'id', header: 'Model ID', width: 28 },
-                            { key: 'dimension', header: 'Dims', width: 8 },
-                            { key: 'size', header: 'Size', width: 10 },
-                            { key: 'quantized', header: 'Quant', width: 8 },
-                            { key: 'downloaded', header: 'Status', width: 12 },
-                        ],
-                        data: models.map(function (m) { return ({
-                            id: m.id,
-                            dimension: String(m.dimension),
-                            size: m.size,
-                            quantized: m.quantized ? 'Yes' : 'No',
-                            downloaded: m.downloaded ? output.success('Downloaded') : output.dim('Available')
-                        }); })
+    action: async (ctx) => {
+        const download = ctx.flags.download;
+        const embeddings = await getEmbeddings();
+        output.writeln();
+        output.writeln(output.bold('Embedding Models'));
+        output.writeln(output.dim('─'.repeat(60)));
+        if (download) {
+            const spinner = output.createSpinner({ text: `Downloading ${download}...`, spinner: 'dots' });
+            spinner.start();
+            if (embeddings) {
+                try {
+                    await embeddings.downloadEmbeddingModel(download, '.models', (p) => {
+                        spinner.setText(`Downloading ${download}... ${p.percent.toFixed(1)}%`);
                     });
-                    return [2 /*return*/, { success: true }];
+                    spinner.succeed(`Downloaded ${download}`);
+                }
+                catch (err) {
+                    spinner.fail(`Failed to download: ${err}`);
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            else {
+                await new Promise(r => setTimeout(r, 500));
+                spinner.succeed(`Download complete (simulated)`);
             }
+            return { success: true };
+        }
+        // List models
+        let models = [
+            { id: 'all-MiniLM-L6-v2', dimension: 384, size: '23MB', quantized: false, downloaded: true },
+            { id: 'all-mpnet-base-v2', dimension: 768, size: '110MB', quantized: false, downloaded: false },
+            { id: 'paraphrase-MiniLM-L3-v2', dimension: 384, size: '17MB', quantized: false, downloaded: false },
+        ];
+        if (embeddings) {
+            try {
+                models = await embeddings.listEmbeddingModels();
+            }
+            catch { /* use defaults */ }
+        }
+        output.printTable({
+            columns: [
+                { key: 'id', header: 'Model ID', width: 28 },
+                { key: 'dimension', header: 'Dims', width: 8 },
+                { key: 'size', header: 'Size', width: 10 },
+                { key: 'quantized', header: 'Quant', width: 8 },
+                { key: 'downloaded', header: 'Status', width: 12 },
+            ],
+            data: models.map(m => ({
+                id: m.id,
+                dimension: String(m.dimension),
+                size: m.size,
+                quantized: m.quantized ? 'Yes' : 'No',
+                downloaded: m.downloaded ? output.success('Downloaded') : output.dim('Available'),
+            })),
         });
-    }); }
+        return { success: true };
+    },
 };
 // Cache subcommand
-var cacheCommand = {
+const cacheCommand = {
     name: 'cache',
     description: 'Manage embedding cache',
     options: [
-        { name: 'action', short: 'a', type: 'string', description: 'Action: stats, clear, persist', "default": 'stats' },
-        { name: 'db-path', type: 'string', description: 'SQLite database path', "default": '.cache/embeddings.db' },
+        { name: 'action', short: 'a', type: 'string', description: 'Action: stats, clear, persist', default: 'stats' },
+        { name: 'db-path', type: 'string', description: 'SQLite database path', default: '.cache/embeddings.db' },
     ],
     examples: [
         { command: 'claude-flow embeddings cache', description: 'Show cache stats' },
         { command: 'claude-flow embeddings cache -a clear', description: 'Clear cache' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var action, dbPath, fs, path, resolvedDbPath, sqliteEntries, sqliteSize, sqliteExists, stats, sizeBytes, initSqlJs, SQL, fileBuffer, db, result, _a, _b, memoryEntries, memorySize, getHNSWStatus, hnswStatus, memBytes, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    action = ctx.flags.action || 'stats';
-                    dbPath = ctx.flags['db-path'] || '.cache/embeddings.db';
-                    output.writeln();
-                    output.writeln(output.bold('Embedding Cache'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    return [4 /*yield*/, import('fs')];
-                case 1:
-                    fs = _d.sent();
-                    return [4 /*yield*/, import('path')];
-                case 2:
-                    path = _d.sent();
-                    resolvedDbPath = path.resolve(dbPath);
-                    sqliteEntries = 0;
-                    sqliteSize = '0 B';
-                    sqliteExists = false;
-                    _d.label = 3;
-                case 3:
-                    _d.trys.push([3, 9, , 10]);
-                    if (!fs.existsSync(resolvedDbPath)) return [3 /*break*/, 8];
-                    sqliteExists = true;
-                    stats = fs.statSync(resolvedDbPath);
-                    sizeBytes = stats.size;
-                    // Format size
-                    if (sizeBytes >= 1024 * 1024) {
-                        sqliteSize = (sizeBytes / 1024 / 1024).toFixed(1) + " MB";
-                    }
-                    else if (sizeBytes >= 1024) {
-                        sqliteSize = (sizeBytes / 1024).toFixed(1) + " KB";
-                    }
-                    else {
-                        sqliteSize = sizeBytes + " B";
-                    }
-                    _d.label = 4;
-                case 4:
-                    _d.trys.push([4, 7, , 8]);
-                    return [4 /*yield*/, import('sql.js')];
-                case 5:
-                    initSqlJs = (_d.sent())["default"];
-                    return [4 /*yield*/, initSqlJs()];
-                case 6:
-                    SQL = _d.sent();
-                    fileBuffer = fs.readFileSync(resolvedDbPath);
-                    db = new SQL.Database(fileBuffer);
-                    result = db.exec('SELECT COUNT(*) as count FROM embeddings');
+    action: async (ctx) => {
+        const action = ctx.flags.action || 'stats';
+        const dbPath = ctx.flags['db-path'] || '.cache/embeddings.db';
+        output.writeln();
+        output.writeln(output.bold('Embedding Cache'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const fs = await import('fs');
+        const path = await import('path');
+        // Get real cache stats
+        const resolvedDbPath = path.resolve(dbPath);
+        let sqliteEntries = 0;
+        let sqliteSize = '0 B';
+        let sqliteExists = false;
+        try {
+            if (fs.existsSync(resolvedDbPath)) {
+                sqliteExists = true;
+                const stats = fs.statSync(resolvedDbPath);
+                const sizeBytes = stats.size;
+                // Format size
+                if (sizeBytes >= 1024 * 1024) {
+                    sqliteSize = `${(sizeBytes / 1024 / 1024).toFixed(1)} MB`;
+                }
+                else if (sizeBytes >= 1024) {
+                    sqliteSize = `${(sizeBytes / 1024).toFixed(1)} KB`;
+                }
+                else {
+                    sqliteSize = `${sizeBytes} B`;
+                }
+                // Try to count real entries via sql.js
+                try {
+                    const initSqlJs = (await import('sql.js')).default;
+                    const SQL = await initSqlJs();
+                    const fileBuffer = fs.readFileSync(resolvedDbPath);
+                    const db = new SQL.Database(fileBuffer);
+                    const result = db.exec('SELECT COUNT(*) as count FROM embeddings');
                     if (result.length > 0 && result[0].values.length > 0) {
                         sqliteEntries = result[0].values[0][0];
                     }
                     db.close();
-                    return [3 /*break*/, 8];
-                case 7:
-                    _a = _d.sent();
+                }
+                catch {
                     // Estimate entries from file size (~1600 bytes per entry for 384-dim embeddings)
                     sqliteEntries = Math.floor(stats.size / 1600);
-                    return [3 /*break*/, 8];
-                case 8: return [3 /*break*/, 10];
-                case 9:
-                    _b = _d.sent();
-                    return [3 /*break*/, 10];
-                case 10:
-                    memoryEntries = 0;
-                    memorySize = '0 B';
-                    _d.label = 11;
-                case 11:
-                    _d.trys.push([11, 13, , 14]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 12:
-                    getHNSWStatus = (_d.sent()).getHNSWStatus;
-                    hnswStatus = getHNSWStatus();
-                    if (hnswStatus && hnswStatus.initialized) {
-                        memoryEntries = hnswStatus.entryCount || 0;
-                        memBytes = memoryEntries * (hnswStatus.dimensions || 384) * 4;
-                        if (memBytes >= 1024 * 1024) {
-                            memorySize = (memBytes / 1024 / 1024).toFixed(1) + " MB";
-                        }
-                        else if (memBytes >= 1024) {
-                            memorySize = (memBytes / 1024).toFixed(1) + " KB";
-                        }
-                        else {
-                            memorySize = memBytes + " B";
-                        }
-                    }
-                    return [3 /*break*/, 14];
-                case 13:
-                    _c = _d.sent();
-                    return [3 /*break*/, 14];
-                case 14:
-                    if (action === 'clear') {
-                        try {
-                            if (fs.existsSync(resolvedDbPath)) {
-                                fs.unlinkSync(resolvedDbPath);
-                                output.writeln(output.success('Cache cleared!'));
-                            }
-                            else {
-                                output.writeln(output.dim('No cache to clear.'));
-                            }
-                            return [2 /*return*/, { success: true }];
-                        }
-                        catch (error) {
-                            output.printError("Failed to clear cache: " + error);
-                            return [2 /*return*/, { success: false }];
-                        }
-                    }
-                    // Display real stats
-                    output.printTable({
-                        columns: [
-                            { key: 'cache', header: 'Cache Type', width: 18 },
-                            { key: 'entries', header: 'Entries', width: 12 },
-                            { key: 'status', header: 'Status', width: 12 },
-                            { key: 'size', header: 'Size', width: 12 },
-                        ],
-                        data: [
-                            {
-                                cache: 'LRU (Memory)',
-                                entries: String(memoryEntries),
-                                status: memoryEntries > 0 ? output.success('Active') : output.dim('Empty'),
-                                size: memorySize
-                            },
-                            {
-                                cache: 'SQLite (Disk)',
-                                entries: String(sqliteEntries),
-                                status: sqliteExists ? output.success('Active') : output.dim('Not Found'),
-                                size: sqliteSize
-                            },
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.dim("Database: " + resolvedDbPath));
-                    if (sqliteExists) {
-                        output.writeln(output.dim('Persistent cache survives restarts'));
-                    }
-                    else {
-                        output.writeln(output.dim('Cache will be created on first embedding operation'));
-                    }
-                    return [2 /*return*/, { success: true }];
+                }
+            }
+        }
+        catch { /* file access error */ }
+        // Get in-memory HNSW stats if available
+        let memoryEntries = 0;
+        let memorySize = '0 B';
+        try {
+            const { getHNSWStatus } = await import('../memory/memory-initializer.js');
+            const hnswStatus = getHNSWStatus();
+            if (hnswStatus && hnswStatus.initialized) {
+                memoryEntries = hnswStatus.entryCount || 0;
+                const memBytes = memoryEntries * (hnswStatus.dimensions || 384) * 4; // Float32 = 4 bytes per dimension
+                if (memBytes >= 1024 * 1024) {
+                    memorySize = `${(memBytes / 1024 / 1024).toFixed(1)} MB`;
+                }
+                else if (memBytes >= 1024) {
+                    memorySize = `${(memBytes / 1024).toFixed(1)} KB`;
+                }
+                else {
+                    memorySize = `${memBytes} B`;
+                }
+            }
+        }
+        catch { /* HNSW not initialized */ }
+        if (action === 'clear') {
+            try {
+                if (fs.existsSync(resolvedDbPath)) {
+                    fs.unlinkSync(resolvedDbPath);
+                    output.writeln(output.success('Cache cleared!'));
+                }
+                else {
+                    output.writeln(output.dim('No cache to clear.'));
+                }
+                return { success: true };
             }
+            catch (error) {
+                output.printError(`Failed to clear cache: ${error}`);
+                return { success: false };
+            }
+        }
+        // Display real stats
+        output.printTable({
+            columns: [
+                { key: 'cache', header: 'Cache Type', width: 18 },
+                { key: 'entries', header: 'Entries', width: 12 },
+                { key: 'status', header: 'Status', width: 12 },
+                { key: 'size', header: 'Size', width: 12 },
+            ],
+            data: [
+                {
+                    cache: 'LRU (Memory)',
+                    entries: String(memoryEntries),
+                    status: memoryEntries > 0 ? output.success('Active') : output.dim('Empty'),
+                    size: memorySize,
+                },
+                {
+                    cache: 'SQLite (Disk)',
+                    entries: String(sqliteEntries),
+                    status: sqliteExists ? output.success('Active') : output.dim('Not Found'),
+                    size: sqliteSize,
+                },
+            ],
         });
-    }); }
+        output.writeln();
+        output.writeln(output.dim(`Database: ${resolvedDbPath}`));
+        if (sqliteExists) {
+            output.writeln(output.dim('Persistent cache survives restarts'));
+        }
+        else {
+            output.writeln(output.dim('Cache will be created on first embedding operation'));
+        }
+        return { success: true };
+    },
 };
 // Warmup subcommand - Preload model for faster first embed
-var warmupCommand = {
+const warmupCommand = {
     name: 'warmup',
     description: 'Preload embedding model for faster subsequent operations',
     options: [
-        { name: 'background', short: 'b', type: 'boolean', description: 'Run warmup in background daemon', "default": 'false' },
-        { name: 'test', short: 't', type: 'boolean', description: 'Run test embedding after warmup', "default": 'true' },
+        { name: 'background', short: 'b', type: 'boolean', description: 'Run warmup in background daemon', default: 'false' },
+        { name: 'test', short: 't', type: 'boolean', description: 'Run test embedding after warmup', default: 'true' },
     ],
     examples: [
         { command: 'claude-flow embeddings warmup', description: 'Preload model with test' },
         { command: 'claude-flow embeddings warmup -b', description: 'Background warmup' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var runTest, background, spinner, overallStart, _a, loadEmbeddingModel, generateEmbedding, loadStart, modelInfo, loadTime, testSpinner, warmupTexts, embedTimes, _i, warmupTexts_1, text, embedStart, avgWarmEmbed, totalTime, error_8;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    runTest = ctx.flags.test !== false;
-                    background = ctx.flags.background === true;
-                    output.writeln();
-                    output.writeln(output.bold('Embedding Model Warmup'));
-                    output.writeln(output.dim('─'.repeat(50)));
-                    spinner = output.createSpinner({ text: 'Loading embedding model...', spinner: 'dots' });
-                    spinner.start();
-                    overallStart = Date.now();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 9, , 10]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    _a = _b.sent(), loadEmbeddingModel = _a.loadEmbeddingModel, generateEmbedding = _a.generateEmbedding;
-                    loadStart = Date.now();
-                    return [4 /*yield*/, loadEmbeddingModel({ verbose: false })];
-                case 3:
-                    modelInfo = _b.sent();
-                    loadTime = Date.now() - loadStart;
-                    spinner.succeed("Model loaded in " + loadTime + "ms");
-                    if (!runTest) return [3 /*break*/, 8];
-                    testSpinner = output.createSpinner({ text: 'Running warmup embedding...', spinner: 'dots' });
-                    testSpinner.start();
-                    warmupTexts = [
-                        'The quick brown fox jumps over the lazy dog',
-                        'Machine learning embeddings enable semantic search',
-                        'Vector databases use HNSW for fast similarity'
-                    ];
-                    embedTimes = [];
-                    _i = 0, warmupTexts_1 = warmupTexts;
-                    _b.label = 4;
-                case 4:
-                    if (!(_i < warmupTexts_1.length)) return [3 /*break*/, 7];
-                    text = warmupTexts_1[_i];
-                    embedStart = Date.now();
-                    return [4 /*yield*/, generateEmbedding(text)];
-                case 5:
-                    _b.sent();
+    action: async (ctx) => {
+        const runTest = ctx.flags.test !== false;
+        const background = ctx.flags.background === true;
+        output.writeln();
+        output.writeln(output.bold('Embedding Model Warmup'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Loading embedding model...', spinner: 'dots' });
+        spinner.start();
+        const overallStart = Date.now();
+        try {
+            const { loadEmbeddingModel, generateEmbedding } = await import('../memory/memory-initializer.js');
+            // Phase 1: Load model
+            const loadStart = Date.now();
+            const modelInfo = await loadEmbeddingModel({ verbose: false });
+            const loadTime = Date.now() - loadStart;
+            spinner.succeed(`Model loaded in ${loadTime}ms`);
+            // Phase 2: Test embed (warms ONNX runtime)
+            if (runTest) {
+                const testSpinner = output.createSpinner({ text: 'Running warmup embedding...', spinner: 'dots' });
+                testSpinner.start();
+                const warmupTexts = [
+                    'The quick brown fox jumps over the lazy dog',
+                    'Machine learning embeddings enable semantic search',
+                    'Vector databases use HNSW for fast similarity'
+                ];
+                const embedTimes = [];
+                for (const text of warmupTexts) {
+                    const embedStart = Date.now();
+                    await generateEmbedding(text);
                     embedTimes.push(Date.now() - embedStart);
-                    _b.label = 6;
-                case 6:
-                    _i++;
-                    return [3 /*break*/, 4];
-                case 7:
-                    avgWarmEmbed = embedTimes.slice(1).reduce(function (a, b) { return a + b; }, 0) / (embedTimes.length - 1);
-                    testSpinner.succeed("Warmup complete: " + avgWarmEmbed.toFixed(1) + "ms avg (warm)");
-                    _b.label = 8;
-                case 8:
-                    totalTime = Date.now() - overallStart;
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'metric', header: 'Metric', width: 22 },
-                            { key: 'value', header: 'Value', width: 25 },
-                        ],
-                        data: [
-                            { metric: 'Model', value: modelInfo.modelName },
-                            { metric: 'Dimensions', value: String(modelInfo.dimensions) },
-                            { metric: 'Initial Load', value: loadTime + "ms" },
-                            { metric: 'Warm Embed', value: runTest ? "~2-3ms" : 'Skipped' },
-                            { metric: 'Total Warmup', value: totalTime + "ms" },
-                            { metric: 'Status', value: output.success('Ready') },
-                        ]
-                    });
-                    output.writeln();
-                    output.writeln(output.dim('Model is now cached for fast subsequent embeddings'));
-                    return [2 /*return*/, { success: true, data: { loadTime: loadTime, totalTime: totalTime, dimensions: modelInfo.dimensions } }];
-                case 9:
-                    error_8 = _b.sent();
-                    spinner.fail('Warmup failed');
-                    output.printError(error_8 instanceof Error ? error_8.message : String(error_8));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 10: return [2 /*return*/];
+                }
+                const avgWarmEmbed = embedTimes.slice(1).reduce((a, b) => a + b, 0) / (embedTimes.length - 1);
+                testSpinner.succeed(`Warmup complete: ${avgWarmEmbed.toFixed(1)}ms avg (warm)`);
             }
-        });
-    }); }
+            const totalTime = Date.now() - overallStart;
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'metric', header: 'Metric', width: 22 },
+                    { key: 'value', header: 'Value', width: 25 },
+                ],
+                data: [
+                    { metric: 'Model', value: modelInfo.modelName },
+                    { metric: 'Dimensions', value: String(modelInfo.dimensions) },
+                    { metric: 'Initial Load', value: `${loadTime}ms` },
+                    { metric: 'Warm Embed', value: runTest ? `~2-3ms` : 'Skipped' },
+                    { metric: 'Total Warmup', value: `${totalTime}ms` },
+                    { metric: 'Status', value: output.success('Ready') },
+                ],
+            });
+            output.writeln();
+            output.writeln(output.dim('Model is now cached for fast subsequent embeddings'));
+            return { success: true, data: { loadTime, totalTime, dimensions: modelInfo.dimensions } };
+        }
+        catch (error) {
+            spinner.fail('Warmup failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Benchmark subcommand - Performance testing
-var benchmarkCommand = {
+const benchmarkCommand = {
     name: 'benchmark',
     description: 'Run embedding performance benchmarks',
     options: [
-        { name: 'iterations', short: 'n', type: 'number', description: 'Number of iterations', "default": '10' },
-        { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size for batch test', "default": '5' },
-        { name: 'full', short: 'f', type: 'boolean', description: 'Run full benchmark suite', "default": 'false' },
+        { name: 'iterations', short: 'n', type: 'number', description: 'Number of iterations', default: '10' },
+        { name: 'batch-size', short: 'b', type: 'number', description: 'Batch size for batch test', default: '5' },
+        { name: 'full', short: 'f', type: 'boolean', description: 'Run full benchmark suite', default: 'false' },
     ],
     examples: [
         { command: 'claude-flow embeddings benchmark', description: 'Quick benchmark' },
         { command: 'claude-flow embeddings benchmark -n 50 -f', description: 'Full benchmark' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var iterations, batchSize, full, results, _a, loadEmbeddingModel, generateEmbedding_1, coldStart, modelInfo, coldTime, firstStart, firstTime, warmTimes, i, start, avgWarm, minWarm, maxWarm, batchTexts, seqStart, _i, batchTexts_1, text, seqTime, parallelTexts, parallelStart, parallelTime, speedup, cacheText, cacheTimes, i, start, avgCache, emb1, emb2, simTimes, i, start, avgSim, error_9;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    iterations = parseInt(ctx.flags.iterations || '10', 10);
-                    batchSize = parseInt(ctx.flags['batch-size'] || '5', 10);
-                    full = ctx.flags.full === true;
-                    output.writeln();
-                    output.writeln(output.bold('Embedding Performance Benchmark'));
-                    output.writeln(output.dim('─'.repeat(60)));
-                    results = [];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 22, , 23]);
-                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
-                case 2:
-                    _a = _b.sent(), loadEmbeddingModel = _a.loadEmbeddingModel, generateEmbedding_1 = _a.generateEmbedding;
-                    // Test 1: Cold start (model load)
-                    output.writeln(output.dim('Testing cold start...'));
-                    coldStart = Date.now();
-                    return [4 /*yield*/, loadEmbeddingModel({ verbose: false })];
-                case 3:
-                    modelInfo = _b.sent();
-                    coldTime = Date.now() - coldStart;
-                    results.push({
-                        test: 'Cold Start (model load)',
-                        time: coldTime + "ms",
-                        opsPerSec: '-'
-                    });
-                    firstStart = Date.now();
-                    return [4 /*yield*/, generateEmbedding_1('First embedding test')];
-                case 4:
-                    _b.sent();
-                    firstTime = Date.now() - firstStart;
-                    results.push({
-                        test: 'First Embed',
-                        time: firstTime + "ms",
-                        opsPerSec: "" + (1000 / firstTime).toFixed(1)
-                    });
-                    // Test 3: Warm embeds (multiple iterations)
-                    output.writeln(output.dim("Testing " + iterations + " warm embeds..."));
-                    warmTimes = [];
-                    i = 0;
-                    _b.label = 5;
-                case 5:
-                    if (!(i < iterations)) return [3 /*break*/, 8];
-                    start = Date.now();
-                    return [4 /*yield*/, generateEmbedding_1("Warm embedding test " + i + " with some content")];
-                case 6:
-                    _b.sent();
-                    warmTimes.push(Date.now() - start);
-                    _b.label = 7;
-                case 7:
-                    i++;
-                    return [3 /*break*/, 5];
-                case 8:
-                    avgWarm = warmTimes.reduce(function (a, b) { return a + b; }, 0) / warmTimes.length;
-                    minWarm = Math.min.apply(Math, warmTimes);
-                    maxWarm = Math.max.apply(Math, warmTimes);
-                    results.push({
-                        test: "Warm Embed (n=" + iterations + ")",
-                        time: avgWarm.toFixed(1) + "ms avg (" + minWarm + "-" + maxWarm + ")",
-                        opsPerSec: "" + (1000 / avgWarm).toFixed(1)
-                    });
-                    // Test 4a: Sequential batch embed
-                    output.writeln(output.dim("Testing sequential batch of " + batchSize + "..."));
-                    batchTexts = Array.from({ length: batchSize }, function (_, i) { return "Batch text " + (i + 1) + " for testing"; });
-                    seqStart = Date.now();
-                    _i = 0, batchTexts_1 = batchTexts;
-                    _b.label = 9;
-                case 9:
-                    if (!(_i < batchTexts_1.length)) return [3 /*break*/, 12];
-                    text = batchTexts_1[_i];
-                    return [4 /*yield*/, generateEmbedding_1(text)];
-                case 10:
-                    _b.sent();
-                    _b.label = 11;
-                case 11:
-                    _i++;
-                    return [3 /*break*/, 9];
-                case 12:
-                    seqTime = Date.now() - seqStart;
-                    results.push({
-                        test: "Sequential (n=" + batchSize + ")",
-                        time: seqTime + "ms total (" + (seqTime / batchSize).toFixed(1) + "ms/item)",
-                        opsPerSec: "" + (1000 * batchSize / seqTime).toFixed(1)
-                    });
-                    // Test 4b: Parallel batch embed
-                    // Note: Local ONNX is CPU-bound so parallelism has limited benefit
-                    // Parallelism gives 2-4x speedup for API-based providers (OpenAI, etc.)
-                    output.writeln(output.dim("Testing parallel batch of " + batchSize + "..."));
-                    parallelTexts = Array.from({ length: batchSize }, function (_, i) { return "Parallel batch text " + (i + 1); });
-                    parallelStart = Date.now();
-                    return [4 /*yield*/, Promise.all(parallelTexts.map(function (text) { return generateEmbedding_1(text); }))];
-                case 13:
-                    _b.sent();
-                    parallelTime = Date.now() - parallelStart;
-                    speedup = seqTime / parallelTime;
-                    results.push({
-                        test: "Parallel (n=" + batchSize + ")",
-                        time: parallelTime + "ms total (" + (parallelTime / batchSize).toFixed(1) + "ms/item)",
-                        opsPerSec: (1000 * batchSize / parallelTime).toFixed(1) + " (" + speedup.toFixed(2) + "x vs seq)"
-                    });
-                    if (!full) return [3 /*break*/, 21];
-                    output.writeln(output.dim('Testing cache hits...'));
-                    cacheText = 'Cached embedding test text';
-                    return [4 /*yield*/, generateEmbedding_1(cacheText)];
-                case 14:
-                    _b.sent(); // Prime cache
-                    cacheTimes = [];
-                    i = 0;
-                    _b.label = 15;
-                case 15:
-                    if (!(i < 10)) return [3 /*break*/, 18];
-                    start = Date.now();
-                    return [4 /*yield*/, generateEmbedding_1(cacheText)];
-                case 16:
-                    _b.sent();
+    action: async (ctx) => {
+        const iterations = parseInt(ctx.flags.iterations || '10', 10);
+        const batchSize = parseInt(ctx.flags['batch-size'] || '5', 10);
+        const full = ctx.flags.full === true;
+        output.writeln();
+        output.writeln(output.bold('Embedding Performance Benchmark'));
+        output.writeln(output.dim('─'.repeat(60)));
+        const results = [];
+        try {
+            const { loadEmbeddingModel, generateEmbedding } = await import('../memory/memory-initializer.js');
+            // Test 1: Cold start (model load)
+            output.writeln(output.dim('Testing cold start...'));
+            const coldStart = Date.now();
+            const modelInfo = await loadEmbeddingModel({ verbose: false });
+            const coldTime = Date.now() - coldStart;
+            results.push({
+                test: 'Cold Start (model load)',
+                time: `${coldTime}ms`,
+                opsPerSec: '-'
+            });
+            // Test 2: First embed
+            const firstStart = Date.now();
+            await generateEmbedding('First embedding test');
+            const firstTime = Date.now() - firstStart;
+            results.push({
+                test: 'First Embed',
+                time: `${firstTime}ms`,
+                opsPerSec: `${(1000 / firstTime).toFixed(1)}`
+            });
+            // Test 3: Warm embeds (multiple iterations)
+            output.writeln(output.dim(`Testing ${iterations} warm embeds...`));
+            const warmTimes = [];
+            for (let i = 0; i < iterations; i++) {
+                const start = Date.now();
+                await generateEmbedding(`Warm embedding test ${i} with some content`);
+                warmTimes.push(Date.now() - start);
+            }
+            const avgWarm = warmTimes.reduce((a, b) => a + b, 0) / warmTimes.length;
+            const minWarm = Math.min(...warmTimes);
+            const maxWarm = Math.max(...warmTimes);
+            results.push({
+                test: `Warm Embed (n=${iterations})`,
+                time: `${avgWarm.toFixed(1)}ms avg (${minWarm}-${maxWarm})`,
+                opsPerSec: `${(1000 / avgWarm).toFixed(1)}`
+            });
+            // Test 4a: Sequential batch embed
+            output.writeln(output.dim(`Testing sequential batch of ${batchSize}...`));
+            const batchTexts = Array.from({ length: batchSize }, (_, i) => `Batch text ${i + 1} for testing`);
+            const seqStart = Date.now();
+            for (const text of batchTexts) {
+                await generateEmbedding(text);
+            }
+            const seqTime = Date.now() - seqStart;
+            results.push({
+                test: `Sequential (n=${batchSize})`,
+                time: `${seqTime}ms total (${(seqTime / batchSize).toFixed(1)}ms/item)`,
+                opsPerSec: `${(1000 * batchSize / seqTime).toFixed(1)}`
+            });
+            // Test 4b: Parallel batch embed
+            // Note: Local ONNX is CPU-bound so parallelism has limited benefit
+            // Parallelism gives 2-4x speedup for API-based providers (OpenAI, etc.)
+            output.writeln(output.dim(`Testing parallel batch of ${batchSize}...`));
+            const parallelTexts = Array.from({ length: batchSize }, (_, i) => `Parallel batch text ${i + 1}`);
+            const parallelStart = Date.now();
+            await Promise.all(parallelTexts.map(text => generateEmbedding(text)));
+            const parallelTime = Date.now() - parallelStart;
+            const speedup = seqTime / parallelTime;
+            results.push({
+                test: `Parallel (n=${batchSize})`,
+                time: `${parallelTime}ms total (${(parallelTime / batchSize).toFixed(1)}ms/item)`,
+                opsPerSec: `${(1000 * batchSize / parallelTime).toFixed(1)} (${speedup.toFixed(2)}x vs seq)`
+            });
+            // Test 5: Cache hit (same text)
+            if (full) {
+                output.writeln(output.dim('Testing cache hits...'));
+                const cacheText = 'Cached embedding test text';
+                await generateEmbedding(cacheText); // Prime cache
+                const cacheTimes = [];
+                for (let i = 0; i < 10; i++) {
+                    const start = Date.now();
+                    await generateEmbedding(cacheText);
                     cacheTimes.push(Date.now() - start);
-                    _b.label = 17;
-                case 17:
-                    i++;
-                    return [3 /*break*/, 15];
-                case 18:
-                    avgCache = cacheTimes.reduce(function (a, b) { return a + b; }, 0) / cacheTimes.length;
-                    results.push({
-                        test: 'Cache Hit',
-                        time: avgCache.toFixed(2) + "ms avg",
-                        opsPerSec: "" + (1000 / avgCache).toFixed(0)
-                    });
-                    // Test 6: Similarity computation
-                    output.writeln(output.dim('Testing similarity...'));
-                    return [4 /*yield*/, generateEmbedding_1('Hello world')];
-                case 19:
-                    emb1 = (_b.sent()).embedding;
-                    return [4 /*yield*/, generateEmbedding_1('Hi there')];
-                case 20:
-                    emb2 = (_b.sent()).embedding;
-                    simTimes = [];
-                    for (i = 0; i < 1000; i++) {
-                        start = performance.now();
-                        cosineSimilarity(emb1, emb2);
-                        simTimes.push(performance.now() - start);
-                    }
-                    avgSim = simTimes.reduce(function (a, b) { return a + b; }, 0) / simTimes.length;
-                    results.push({
-                        test: 'Cosine Similarity',
-                        time: (avgSim * 1000).toFixed(2) + "\u03BCs",
-                        opsPerSec: "" + (1000000 / (avgSim * 1000)).toFixed(0)
-                    });
-                    _b.label = 21;
-                case 21:
-                    output.writeln();
-                    output.printTable({
-                        columns: [
-                            { key: 'test', header: 'Test', width: 28 },
-                            { key: 'time', header: 'Time', width: 32 },
-                            { key: 'opsPerSec', header: 'Ops/sec', width: 12 },
-                        ],
-                        data: results
-                    });
-                    output.writeln();
-                    output.writeln(output.bold('Summary:'));
-                    output.writeln("  Model: " + modelInfo.modelName + " (" + modelInfo.dimensions + "-dim)");
-                    output.writeln("  Cold start: " + coldTime + "ms");
-                    output.writeln("  Warm embed: ~" + avgWarm.toFixed(1) + "ms");
-                    output.writeln("  Throughput: ~" + (1000 / avgWarm).toFixed(0) + " embeds/sec");
-                    return [2 /*return*/, { success: true, data: { results: results, avgWarm: avgWarm, coldTime: coldTime } }];
-                case 22:
-                    error_9 = _b.sent();
-                    output.printError(error_9 instanceof Error ? error_9.message : String(error_9));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 23: return [2 /*return*/];
+                }
+                const avgCache = cacheTimes.reduce((a, b) => a + b, 0) / cacheTimes.length;
+                results.push({
+                    test: 'Cache Hit',
+                    time: `${avgCache.toFixed(2)}ms avg`,
+                    opsPerSec: `${(1000 / avgCache).toFixed(0)}`
+                });
+                // Test 6: Similarity computation
+                output.writeln(output.dim('Testing similarity...'));
+                const emb1 = (await generateEmbedding('Hello world')).embedding;
+                const emb2 = (await generateEmbedding('Hi there')).embedding;
+                const simTimes = [];
+                for (let i = 0; i < 1000; i++) {
+                    const start = performance.now();
+                    cosineSimilarity(emb1, emb2);
+                    simTimes.push(performance.now() - start);
+                }
+                const avgSim = simTimes.reduce((a, b) => a + b, 0) / simTimes.length;
+                results.push({
+                    test: 'Cosine Similarity',
+                    time: `${(avgSim * 1000).toFixed(2)}μs`,
+                    opsPerSec: `${(1000000 / (avgSim * 1000)).toFixed(0)}`
+                });
             }
-        });
-    }); }
+            output.writeln();
+            output.printTable({
+                columns: [
+                    { key: 'test', header: 'Test', width: 28 },
+                    { key: 'time', header: 'Time', width: 32 },
+                    { key: 'opsPerSec', header: 'Ops/sec', width: 12 },
+                ],
+                data: results,
+            });
+            output.writeln();
+            output.writeln(output.bold('Summary:'));
+            output.writeln(`  Model: ${modelInfo.modelName} (${modelInfo.dimensions}-dim)`);
+            output.writeln(`  Cold start: ${coldTime}ms`);
+            output.writeln(`  Warm embed: ~${avgWarm.toFixed(1)}ms`);
+            output.writeln(`  Throughput: ~${(1000 / avgWarm).toFixed(0)} embeds/sec`);
+            return { success: true, data: { results, avgWarm, coldTime } };
+        }
+        catch (error) {
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 // Main embeddings command
-export var embeddingsCommand = {
+export const embeddingsCommand = {
     name: 'embeddings',
     description: 'Vector embeddings, semantic search, similarity operations',
     aliases: ['embed'],
@@ -1782,45 +1534,43 @@ export var embeddingsCommand = {
         { command: 'claude-flow embeddings hyperbolic -a convert', description: 'Hyperbolic space' },
         { command: 'claude-flow embed neural -f drift', description: 'Neural substrate' },
     ],
-    action: function () { return __awaiter(void 0, void 0, Promise, function () {
-        return __generator(this, function (_a) {
-            output.writeln();
-            output.writeln(output.bold('RuFlo Embeddings'));
-            output.writeln(output.dim('Vector embeddings and semantic search'));
-            output.writeln();
-            output.writeln('Core Commands:');
-            output.printList([
-                'init        - Initialize ONNX models and hyperbolic config',
-                'generate    - Generate embeddings for text',
-                'search      - Semantic similarity search',
-                'compare     - Compare similarity between texts',
-                'collections - Manage embedding collections',
-                'index       - Manage HNSW indexes',
-                'providers   - List available providers',
-            ]);
-            output.writeln();
-            output.writeln('Advanced Features:');
-            output.printList([
-                'chunk       - Document chunking with overlap',
-                'normalize   - L2/L1/minmax/zscore normalization',
-                'hyperbolic  - Poincaré ball embeddings',
-                'neural      - Neural substrate (drift, memory, swarm)',
-                'models      - List/download ONNX models',
-                'cache       - Manage persistent SQLite cache',
-            ]);
-            output.writeln();
-            output.writeln('Performance:');
-            output.printList([
-                'HNSW indexing: 150x-12,500x faster search',
-                'Agentic Flow: 75x faster than Transformers.js (~3ms)',
-                'Persistent cache: SQLite-backed, survives restarts',
-                'Hyperbolic: Better hierarchical representation',
-            ]);
-            output.writeln();
-            output.writeln(output.dim('Created with ❤️ by ruv.io'));
-            return [2 /*return*/, { success: true }];
-        });
-    }); }
+    action: async () => {
+        output.writeln();
+        output.writeln(output.bold('RuFlo Embeddings'));
+        output.writeln(output.dim('Vector embeddings and semantic search'));
+        output.writeln();
+        output.writeln('Core Commands:');
+        output.printList([
+            'init        - Initialize ONNX models and hyperbolic config',
+            'generate    - Generate embeddings for text',
+            'search      - Semantic similarity search',
+            'compare     - Compare similarity between texts',
+            'collections - Manage embedding collections',
+            'index       - Manage HNSW indexes',
+            'providers   - List available providers',
+        ]);
+        output.writeln();
+        output.writeln('Advanced Features:');
+        output.printList([
+            'chunk       - Document chunking with overlap',
+            'normalize   - L2/L1/minmax/zscore normalization',
+            'hyperbolic  - Poincaré ball embeddings',
+            'neural      - Neural substrate (drift, memory, swarm)',
+            'models      - List/download ONNX models',
+            'cache       - Manage persistent SQLite cache',
+        ]);
+        output.writeln();
+        output.writeln('Performance:');
+        output.printList([
+            'HNSW indexing: 150x-12,500x faster search',
+            'Agentic Flow: 75x faster than Transformers.js (~3ms)',
+            'Persistent cache: SQLite-backed, survives restarts',
+            'Hyperbolic: Better hierarchical representation',
+        ]);
+        output.writeln();
+        output.writeln(output.dim('Created with ❤️ by ruv.io'));
+        return { success: true };
+    },
 };
 export default embeddingsCommand;
 //# sourceMappingURL=embeddings.js.map