kynjal-cli 3.1.3 → 4.0.0

package/dist/src/mcp-tools/embeddings-tools.js

@@ -4,29 +4,65 @@
  * Tool definitions for ONNX embeddings with hyperbolic support and neural substrate.
  * Implements ADR-024: Embeddings MCP Tools
  */
+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 { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join, resolve } from 'path';
 // Configuration paths
-const CONFIG_DIR = '.claude-flow';
-const EMBEDDINGS_CONFIG = 'embeddings.json';
-const MODELS_DIR = 'models';
+var CONFIG_DIR = '.claude-flow';
+var EMBEDDINGS_CONFIG = 'embeddings.json';
+var MODELS_DIR = 'models';
 function getConfigPath() {
     return resolve(join(CONFIG_DIR, EMBEDDINGS_CONFIG));
 }
 function ensureConfigDir() {
-    const dir = resolve(CONFIG_DIR);
+    var dir = resolve(CONFIG_DIR);
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadConfig() {
     try {
-        const path = getConfigPath();
+        var path = getConfigPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (_a) {
         // Return null on error
     }
     return null;
@@ -36,73 +72,96 @@ function saveConfig(config) {
     writeFileSync(getConfigPath(), JSON.stringify(config, null, 2), 'utf-8');
 }
 // Real ONNX embedding generation via memory-initializer
-let realEmbeddingFn = null;
-async function getRealEmbeddingFunction() {
-    if (!realEmbeddingFn) {
-        try {
-            const { generateEmbedding } = await import('../memory/memory-initializer.js');
-            realEmbeddingFn = generateEmbedding;
-        }
-        catch {
-            realEmbeddingFn = null;
-        }
-    }
-    return realEmbeddingFn;
+var realEmbeddingFn = null;
+function getRealEmbeddingFunction() {
+    return __awaiter(this, void 0, void 0, function () {
+        var generateEmbedding, _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!!realEmbeddingFn) return [3 /*break*/, 4];
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                case 2:
+                    generateEmbedding = (_b.sent()).generateEmbedding;
+                    realEmbeddingFn = generateEmbedding;
+                    return [3 /*break*/, 4];
+                case 3:
+                    _a = _b.sent();
+                    realEmbeddingFn = null;
+                    return [3 /*break*/, 4];
+                case 4: return [2 /*return*/, realEmbeddingFn];
+            }
+        });
+    });
 }
 // Generate real ONNX embedding (falls back to deterministic hash if ONNX unavailable)
-async function generateRealEmbedding(text, dimension) {
-    const realFn = await getRealEmbeddingFunction();
-    if (realFn) {
-        try {
-            const result = await realFn(text);
-            return result.embedding;
-        }
-        catch {
-            // Fall through to fallback
-        }
-    }
-    // Fallback: deterministic hash-based (only if ONNX truly unavailable)
-    console.warn('[MCP] ONNX unavailable, using fallback embedding');
-    const embedding = [];
-    let hash = 0;
-    for (let i = 0; i < text.length; i++) {
-        hash = ((hash << 5) - hash + text.charCodeAt(i)) | 0;
-    }
-    for (let i = 0; i < dimension; i++) {
-        const seed = hash + i * 1337;
-        embedding.push(Math.sin(seed) * Math.cos(seed * 0.5));
-    }
-    // L2 normalize
-    const norm = Math.sqrt(embedding.reduce((sum, x) => sum + x * x, 0));
-    return embedding.map(x => x / norm);
+function generateRealEmbedding(text, dimension) {
+    return __awaiter(this, void 0, Promise, function () {
+        var realFn, result, _a, embedding, hash, i, i, seed, norm;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0: return [4 /*yield*/, getRealEmbeddingFunction()];
+                case 1:
+                    realFn = _b.sent();
+                    if (!realFn) return [3 /*break*/, 5];
+                    _b.label = 2;
+                case 2:
+                    _b.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, realFn(text)];
+                case 3:
+                    result = _b.sent();
+                    return [2 /*return*/, result.embedding];
+                case 4:
+                    _a = _b.sent();
+                    return [3 /*break*/, 5];
+                case 5:
+                    // Fallback: deterministic hash-based (only if ONNX truly unavailable)
+                    console.warn('[MCP] ONNX unavailable, using fallback embedding');
+                    embedding = [];
+                    hash = 0;
+                    for (i = 0; i < text.length; i++) {
+                        hash = ((hash << 5) - hash + text.charCodeAt(i)) | 0;
+                    }
+                    for (i = 0; i < dimension; i++) {
+                        seed = hash + i * 1337;
+                        embedding.push(Math.sin(seed) * Math.cos(seed * 0.5));
+                    }
+                    norm = Math.sqrt(embedding.reduce(function (sum, x) { return sum + x * x; }, 0));
+                    return [2 /*return*/, embedding.map(function (x) { return x / norm; })];
+            }
+        });
+    });
 }
 // Convert Euclidean embedding to Poincaré ball
 function toPoincare(euclidean, curvature) {
-    const c = Math.abs(curvature);
-    const sqrtC = Math.sqrt(c);
-    const norm = Math.sqrt(euclidean.reduce((sum, x) => sum + x * x, 0));
+    var c = Math.abs(curvature);
+    var sqrtC = Math.sqrt(c);
+    var norm = Math.sqrt(euclidean.reduce(function (sum, x) { return sum + x * x; }, 0));
     // Exponential map at origin
-    const factor = Math.tanh(sqrtC * norm / 2) / (sqrtC * norm + 1e-15);
-    return euclidean.map(x => x * factor);
+    var factor = Math.tanh(sqrtC * norm / 2) / (sqrtC * norm + 1e-15);
+    return euclidean.map(function (x) { return x * factor; });
 }
 // Poincaré distance
 function poincareDistance(a, b, curvature) {
-    const c = Math.abs(curvature);
-    const diffSq = a.reduce((sum, _, i) => sum + (a[i] - b[i]) ** 2, 0);
-    const normASq = a.reduce((sum, x) => sum + x * x, 0);
-    const normBSq = b.reduce((sum, x) => sum + x * x, 0);
-    const denom = (1 - normASq) * (1 - normBSq);
-    const delta = 2 * diffSq / (denom + 1e-15);
+    var c = Math.abs(curvature);
+    var diffSq = a.reduce(function (sum, _, i) { return sum + Math.pow((a[i] - b[i]), 2); }, 0);
+    var normASq = a.reduce(function (sum, x) { return sum + x * x; }, 0);
+    var normBSq = b.reduce(function (sum, x) { return sum + x * x; }, 0);
+    var denom = (1 - normASq) * (1 - normBSq);
+    var delta = 2 * diffSq / (denom + 1e-15);
     return (1 / Math.sqrt(c)) * Math.acosh(1 + delta);
 }
 // Cosine similarity
 function cosineSimilarity(a, b) {
-    const dot = a.reduce((sum, _, i) => sum + a[i] * b[i], 0);
-    const normA = Math.sqrt(a.reduce((sum, x) => sum + x * x, 0));
-    const normB = Math.sqrt(b.reduce((sum, x) => sum + x * x, 0));
+    var dot = a.reduce(function (sum, _, i) { return sum + a[i] * b[i]; }, 0);
+    var normA = Math.sqrt(a.reduce(function (sum, x) { return sum + x * x; }, 0));
+    var normB = Math.sqrt(b.reduce(function (sum, x) { return sum + x * x; }, 0));
     return dot / (normA * normB + 1e-15);
 }
-export const embeddingsTools = [
+export var embeddingsTools = [
     {
         name: 'embeddings_init',
         description: 'Initialize the ONNX embedding subsystem with hyperbolic support',
@@ -113,89 +172,92 @@ export const embeddingsTools = [
                 model: {
                     type: 'string',
                     description: 'ONNX model ID',
-                    enum: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
-                    default: 'all-MiniLM-L6-v2',
+                    "enum": ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
+                    "default": 'all-MiniLM-L6-v2'
                 },
                 hyperbolic: {
                     type: 'boolean',
                     description: 'Enable hyperbolic (Poincaré ball) embeddings',
-                    default: true,
+                    "default": true
                 },
                 curvature: {
                     type: 'number',
                     description: 'Poincaré ball curvature (negative)',
-                    default: -1,
+                    "default": -1
                 },
                 cacheSize: {
                     type: 'number',
                     description: 'LRU cache size',
-                    default: 256,
+                    "default": 256
                 },
                 force: {
                     type: 'boolean',
                     description: 'Overwrite existing configuration',
-                    default: false,
-                },
-            },
+                    "default": false
+                }
+            }
         },
-        handler: async (input) => {
-            const model = input.model || 'all-MiniLM-L6-v2';
-            const hyperbolic = input.hyperbolic !== false;
-            const curvature = input.curvature || -1;
-            const cacheSize = input.cacheSize || 256;
-            const force = input.force === true;
-            const existingConfig = loadConfig();
-            if (existingConfig && !force) {
-                return {
-                    success: false,
-                    error: 'Embeddings already initialized. Use force=true to overwrite.',
-                    existingConfig: {
-                        model: existingConfig.model,
-                        initialized: existingConfig.initialized,
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var model, hyperbolic, curvature, cacheSize, force, existingConfig, dimension, modelPath, config;
+            return __generator(this, function (_a) {
+                model = input.model || 'all-MiniLM-L6-v2';
+                hyperbolic = input.hyperbolic !== false;
+                curvature = input.curvature || -1;
+                cacheSize = input.cacheSize || 256;
+                force = input.force === true;
+                existingConfig = loadConfig();
+                if (existingConfig && !force) {
+                    return [2 /*return*/, {
+                            success: false,
+                            error: 'Embeddings already initialized. Use force=true to overwrite.',
+                            existingConfig: {
+                                model: existingConfig.model,
+                                initialized: existingConfig.initialized
+                            }
+                        }];
+                }
+                dimension = model.includes('mpnet') ? 768 : 384;
+                modelPath = resolve(join(CONFIG_DIR, MODELS_DIR));
+                // Create models directory
+                if (!existsSync(modelPath)) {
+                    mkdirSync(modelPath, { recursive: true });
+                }
+                config = {
+                    model: model,
+                    modelPath: modelPath,
+                    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()
                 };
-            }
-            const dimension = model.includes('mpnet') ? 768 : 384;
-            const modelPath = resolve(join(CONFIG_DIR, MODELS_DIR));
-            // Create models directory
-            if (!existsSync(modelPath)) {
-                mkdirSync(modelPath, { recursive: true });
-            }
-            const config = {
-                model,
-                modelPath,
-                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(),
-            };
-            saveConfig(config);
-            return {
-                success: true,
-                config: {
-                    model,
-                    dimension,
-                    cacheSize,
-                    hyperbolic: hyperbolic ? { enabled: true, curvature } : { enabled: false },
-                    neural: { enabled: true },
-                },
-                paths: {
-                    config: getConfigPath(),
-                    models: modelPath,
-                },
-                message: 'Embedding subsystem initialized successfully',
-            };
-        },
+                saveConfig(config);
+                return [2 /*return*/, {
+                        success: true,
+                        config: {
+                            model: model,
+                            dimension: dimension,
+                            cacheSize: cacheSize,
+                            hyperbolic: hyperbolic ? { enabled: true, curvature: curvature } : { enabled: false },
+                            neural: { enabled: true }
+                        },
+                        paths: {
+                            config: getConfigPath(),
+                            models: modelPath
+                        },
+                        message: 'Embedding subsystem initialized successfully'
+                    }];
+            });
+        }); }
     },
     {
         name: 'embeddings_generate',
@@ -206,56 +268,61 @@ export const embeddingsTools = [
             properties: {
                 text: {
                     type: 'string',
-                    description: 'Text to embed',
+                    description: 'Text to embed'
                 },
                 hyperbolic: {
                     type: 'boolean',
                     description: 'Return hyperbolic (Poincaré) embedding',
-                    default: false,
+                    "default": false
                 },
                 normalize: {
                     type: 'boolean',
                     description: 'L2 normalize the embedding',
-                    default: true,
-                },
+                    "default": true
+                }
             },
-            required: ['text'],
-        },
-        handler: async (input) => {
-            const config = loadConfig();
-            if (!config) {
-                return {
-                    success: false,
-                    error: 'Embeddings not initialized. Run embeddings/init first.',
-                };
-            }
-            const text = input.text;
-            const useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
-            // Generate real ONNX embedding
-            const embedding = await generateRealEmbedding(text, config.dimension);
-            let result;
-            let geometry;
-            if (useHyperbolic) {
-                result = toPoincare(embedding, config.hyperbolic.curvature);
-                geometry = 'poincare';
-            }
-            else {
-                result = embedding;
-                geometry = 'euclidean';
-            }
-            return {
-                success: true,
-                embedding: result,
-                metadata: {
-                    model: config.model,
-                    dimension: config.dimension,
-                    geometry,
-                    curvature: useHyperbolic ? config.hyperbolic.curvature : null,
-                    textLength: text.length,
-                    norm: Math.sqrt(result.reduce((sum, x) => sum + x * x, 0)),
-                },
-            };
+            required: ['text']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var config, text, useHyperbolic, embedding, result, geometry;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        config = loadConfig();
+                        if (!config) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: 'Embeddings not initialized. Run embeddings/init first.'
+                                }];
+                        }
+                        text = input.text;
+                        useHyperbolic = input.hyperbolic === true && config.hyperbolic.enabled;
+                        return [4 /*yield*/, generateRealEmbedding(text, config.dimension)];
+                    case 1:
+                        embedding = _a.sent();
+                        if (useHyperbolic) {
+                            result = toPoincare(embedding, config.hyperbolic.curvature);
+                            geometry = 'poincare';
+                        }
+                        else {
+                            result = embedding;
+                            geometry = 'euclidean';
+                        }
+                        return [2 /*return*/, {
+                                success: true,
+                                embedding: result,
+                                metadata: {
+                                    model: config.model,
+                                    dimension: config.dimension,
+                                    geometry: geometry,
+                                    curvature: useHyperbolic ? config.hyperbolic.curvature : null,
+                                    textLength: text.length,
+                                    norm: Math.sqrt(result.reduce(function (sum, x) { return sum + x * x; }, 0))
+                                }
+                            }];
+                }
+            });
+        }); }
     },
     {
         name: 'embeddings_compare',
@@ -266,75 +333,80 @@ export const embeddingsTools = [
             properties: {
                 text1: {
                     type: 'string',
-                    description: 'First text',
+                    description: 'First text'
                 },
                 text2: {
                     type: 'string',
-                    description: 'Second text',
+                    description: 'Second text'
                 },
                 metric: {
                     type: 'string',
                     description: 'Similarity metric',
-                    enum: ['cosine', 'euclidean', 'poincare'],
-                    default: 'cosine',
-                },
+                    "enum": ['cosine', 'euclidean', 'poincare'],
+                    "default": 'cosine'
+                }
             },
-            required: ['text1', 'text2'],
-        },
-        handler: async (input) => {
-            const config = loadConfig();
-            if (!config) {
-                return {
-                    success: false,
-                    error: 'Embeddings not initialized. Run embeddings/init first.',
-                };
-            }
-            const text1 = input.text1;
-            const text2 = input.text2;
-            const metric = input.metric || 'cosine';
-            // Generate real ONNX embeddings for both texts
-            const [emb1, emb2] = await Promise.all([
-                generateRealEmbedding(text1, config.dimension),
-                generateRealEmbedding(text2, config.dimension)
-            ]);
-            let similarity;
-            let distance;
-            switch (metric) {
-                case 'poincare':
-                    if (!config.hyperbolic.enabled) {
-                        return {
-                            success: false,
-                            error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.',
-                        };
-                    }
-                    const poinc1 = toPoincare(emb1, config.hyperbolic.curvature);
-                    const poinc2 = toPoincare(emb2, config.hyperbolic.curvature);
-                    distance = poincareDistance(poinc1, poinc2, config.hyperbolic.curvature);
-                    similarity = 1 / (1 + distance);
-                    break;
-                case 'euclidean':
-                    distance = Math.sqrt(emb1.reduce((sum, _, i) => sum + (emb1[i] - emb2[i]) ** 2, 0));
-                    similarity = 1 / (1 + distance);
-                    break;
-                default: // cosine
-                    similarity = cosineSimilarity(emb1, emb2);
-                    distance = 1 - similarity;
-            }
-            return {
-                success: true,
-                similarity,
-                distance,
-                metric,
-                texts: {
-                    text1: { length: text1.length, preview: text1.slice(0, 50) },
-                    text2: { length: text2.length, preview: text2.slice(0, 50) },
-                },
-                interpretation: similarity > 0.8 ? 'very similar' :
-                    similarity > 0.6 ? 'similar' :
-                        similarity > 0.4 ? 'somewhat similar' :
-                            similarity > 0.2 ? 'different' : 'very different',
-            };
+            required: ['text1', 'text2']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var config, text1, text2, metric, _a, emb1, emb2, similarity, distance, poinc1, poinc2;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        config = loadConfig();
+                        if (!config) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: 'Embeddings not initialized. Run embeddings/init first.'
+                                }];
+                        }
+                        text1 = input.text1;
+                        text2 = input.text2;
+                        metric = input.metric || 'cosine';
+                        return [4 /*yield*/, Promise.all([
+                                generateRealEmbedding(text1, config.dimension),
+                                generateRealEmbedding(text2, config.dimension)
+                            ])];
+                    case 1:
+                        _a = _b.sent(), emb1 = _a[0], emb2 = _a[1];
+                        switch (metric) {
+                            case 'poincare':
+                                if (!config.hyperbolic.enabled) {
+                                    return [2 /*return*/, {
+                                            success: false,
+                                            error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.'
+                                        }];
+                                }
+                                poinc1 = toPoincare(emb1, config.hyperbolic.curvature);
+                                poinc2 = toPoincare(emb2, config.hyperbolic.curvature);
+                                distance = poincareDistance(poinc1, poinc2, config.hyperbolic.curvature);
+                                similarity = 1 / (1 + distance);
+                                break;
+                            case 'euclidean':
+                                distance = Math.sqrt(emb1.reduce(function (sum, _, i) { return sum + Math.pow((emb1[i] - emb2[i]), 2); }, 0));
+                                similarity = 1 / (1 + distance);
+                                break;
+                            default: // cosine
+                                similarity = cosineSimilarity(emb1, emb2);
+                                distance = 1 - similarity;
+                        }
+                        return [2 /*return*/, {
+                                success: true,
+                                similarity: similarity,
+                                distance: distance,
+                                metric: metric,
+                                texts: {
+                                    text1: { length: text1.length, preview: text1.slice(0, 50) },
+                                    text2: { length: text2.length, preview: text2.slice(0, 50) }
+                                },
+                                interpretation: similarity > 0.8 ? 'very similar' :
+                                    similarity > 0.6 ? 'similar' :
+                                        similarity > 0.4 ? 'somewhat similar' :
+                                            similarity > 0.2 ? 'different' : 'very different'
+                            }];
+                }
+            });
+        }); }
     },
     {
         name: 'embeddings_search',
@@ -345,89 +417,103 @@ export const embeddingsTools = [
             properties: {
                 query: {
                     type: 'string',
-                    description: 'Search query',
+                    description: 'Search query'
                 },
                 topK: {
                     type: 'number',
                     description: 'Number of results to return',
-                    default: 5,
+                    "default": 5
                 },
                 threshold: {
                     type: 'number',
                     description: 'Minimum similarity threshold (0-1)',
-                    default: 0.5,
+                    "default": 0.5
                 },
                 namespace: {
                     type: 'string',
-                    description: 'Search in specific namespace',
-                },
+                    description: 'Search in specific namespace'
+                }
             },
-            required: ['query'],
-        },
-        handler: async (input) => {
-            const config = loadConfig();
-            if (!config) {
-                return {
-                    success: false,
-                    error: 'Embeddings not initialized. Run embeddings/init first.',
-                };
-            }
-            const query = input.query;
-            const topK = input.topK || 5;
-            const threshold = input.threshold || 0.5;
-            const namespace = input.namespace;
-            const startTime = performance.now();
-            // Generate real ONNX embedding for query
-            const queryEmbedding = await generateRealEmbedding(query, config.dimension);
-            // Try to search using real memory search
-            try {
-                const { searchEntries } = await import('../memory/memory-initializer.js');
-                const searchResult = await searchEntries({
-                    query,
-                    limit: topK,
-                    threshold,
-                    namespace: namespace || 'default'
-                });
-                const searchTime = (performance.now() - startTime).toFixed(2);
-                return {
-                    success: true,
-                    query,
-                    results: searchResult.results.map((r) => ({
-                        key: r.key,
-                        content: r.content?.substring(0, 100),
-                        similarity: r.score,
-                        namespace: r.namespace
-                    })),
-                    metadata: {
-                        model: config.model,
-                        topK,
-                        threshold,
-                        namespace: namespace || 'default',
-                        searchTime: `${searchTime}ms`,
-                        indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
-                        resultCount: searchResult.results.length
-                    },
-                };
-            }
-            catch {
-                // Database not available - return empty but truthful
-                const searchTime = (performance.now() - startTime).toFixed(2);
-                return {
-                    success: true,
-                    query,
-                    results: [],
-                    metadata: {
-                        model: config.model,
-                        topK,
-                        threshold,
-                        namespace: namespace || 'default',
-                        searchTime: `${searchTime}ms`,
-                        indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
-                    },
-                    message: 'No embeddings indexed yet. Use memory store to add documents.',
-                };
-            }
+            required: ['query']
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var config, query, topK, threshold, namespace, startTime, queryEmbedding, searchEntries, searchResult, searchTime, _a, searchTime;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        config = loadConfig();
+                        if (!config) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: 'Embeddings not initialized. Run embeddings/init first.'
+                                }];
+                        }
+                        query = input.query;
+                        topK = input.topK || 5;
+                        threshold = input.threshold || 0.5;
+                        namespace = input.namespace;
+                        startTime = performance.now();
+                        return [4 /*yield*/, generateRealEmbedding(query, config.dimension)];
+                    case 1:
+                        queryEmbedding = _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        _b.trys.push([2, 5, , 6]);
+                        return [4 /*yield*/, import('../memory/memory-initializer.js')];
+                    case 3:
+                        searchEntries = (_b.sent()).searchEntries;
+                        return [4 /*yield*/, searchEntries({
+                                query: query,
+                                limit: topK,
+                                threshold: threshold,
+                                namespace: namespace || 'default'
+                            })];
+                    case 4:
+                        searchResult = _b.sent();
+                        searchTime = (performance.now() - startTime).toFixed(2);
+                        return [2 /*return*/, {
+                                success: true,
+                                query: query,
+                                results: searchResult.results.map(function (r) {
+                                    var _a;
+                                    return ({
+                                        key: r.key,
+                                        content: (_a = r.content) === null || _a === void 0 ? void 0 : _a.substring(0, 100),
+                                        similarity: r.score,
+                                        namespace: r.namespace
+                                    });
+                                }),
+                                metadata: {
+                                    model: config.model,
+                                    topK: topK,
+                                    threshold: threshold,
+                                    namespace: namespace || 'default',
+                                    searchTime: searchTime + "ms",
+                                    indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)',
+                                    resultCount: searchResult.results.length
+                                }
+                            }];
+                    case 5:
+                        _a = _b.sent();
+                        searchTime = (performance.now() - startTime).toFixed(2);
+                        return [2 /*return*/, {
+                                success: true,
+                                query: query,
+                                results: [],
+                                metadata: {
+                                    model: config.model,
+                                    topK: topK,
+                                    threshold: threshold,
+                                    namespace: namespace || 'default',
+                                    searchTime: searchTime + "ms",
+                                    indexType: config.hyperbolic.enabled ? 'HNSW (hyperbolic)' : 'HNSW (euclidean)'
+                                },
+                                message: 'No embeddings indexed yet. Use memory store to add documents.'
+                            }];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'embeddings_neural',
@@ -439,189 +525,207 @@ export const embeddingsTools = [
                 action: {
                     type: 'string',
                     description: 'Neural action',
-                    enum: ['status', 'init', 'drift', 'consolidate', 'adapt'],
-                    default: 'status',
+                    "enum": ['status', 'init', 'drift', 'consolidate', 'adapt'],
+                    "default": 'status'
                 },
                 driftThreshold: {
                     type: 'number',
                     description: 'Semantic drift detection threshold',
-                    default: 0.3,
+                    "default": 0.3
                 },
                 decayRate: {
                     type: 'number',
                     description: 'Memory decay rate (hippocampal dynamics)',
-                    default: 0.01,
-                },
-            },
-        },
-        handler: async (input) => {
-            const config = loadConfig();
-            if (!config) {
-                return {
-                    success: false,
-                    error: 'Embeddings not initialized. Run embeddings/init first.',
-                };
+                    "default": 0.01
+                }
             }
-            const action = input.action || 'status';
-            switch (action) {
-                case 'init':
-                    config.neural = {
-                        enabled: true,
-                        driftThreshold: input.driftThreshold || 0.3,
-                        decayRate: input.decayRate || 0.01,
-                        ruvector: {
+        },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var config, action, _a, getIntelligenceStats, stats, _b, getIntelligenceStats, stats, _c, _d, benchmarkAdaptation, initializeIntelligence, benchmark, _e, _f, getIntelligenceStats, benchmarkAdaptation, initializeIntelligence, stats, benchmark, _g;
+            var _h, _j, _k, _l;
+            return __generator(this, function (_m) {
+                switch (_m.label) {
+                    case 0:
+                        config = loadConfig();
+                        if (!config) {
+                            return [2 /*return*/, {
+                                    success: false,
+                                    error: 'Embeddings not initialized. Run embeddings/init first.'
+                                }];
+                        }
+                        action = input.action || 'status';
+                        _a = action;
+                        switch (_a) {
+                            case 'init': return [3 /*break*/, 1];
+                            case 'drift': return [3 /*break*/, 2];
+                            case 'consolidate': return [3 /*break*/, 5];
+                            case 'adapt': return [3 /*break*/, 8];
+                        }
+                        return [3 /*break*/, 12];
+                    case 1:
+                        config.neural = {
                             enabled: true,
-                            sona: true,
-                            flashAttention: true,
-                            ewcPlusPlus: true,
-                        },
-                        features: {
-                            semanticDrift: true,
-                            memoryPhysics: true,
-                            stateMachine: true,
-                            swarmCoordination: true,
-                            coherenceMonitor: true,
-                        },
-                    };
-                    saveConfig(config);
-                    return {
-                        success: true,
-                        action: 'init',
-                        neural: config.neural,
-                        message: 'Neural substrate initialized with RuVector integration',
-                    };
-                case 'drift':
-                    // Get real drift metrics if available
-                    try {
-                        const { getIntelligenceStats } = await import('../memory/intelligence.js');
-                        const stats = getIntelligenceStats();
-                        return {
-                            success: true,
-                            action: 'drift',
-                            status: {
-                                semanticDrift: {
-                                    enabled: config.neural.features?.semanticDrift ?? false,
-                                    threshold: config.neural.driftThreshold,
-                                    patternsTracked: stats.patternsLearned,
-                                    status: stats.patternsLearned > 0 ? 'tracking' : 'no patterns',
-                                },
+                            driftThreshold: input.driftThreshold || 0.3,
+                            decayRate: input.decayRate || 0.01,
+                            ruvector: {
+                                enabled: true,
+                                sona: true,
+                                flashAttention: true,
+                                ewcPlusPlus: true
                             },
-                            message: stats.patternsLearned > 0
-                                ? `Tracking ${stats.patternsLearned} patterns for drift`
-                                : 'No patterns stored yet - drift detection inactive',
+                            features: {
+                                semanticDrift: true,
+                                memoryPhysics: true,
+                                stateMachine: true,
+                                swarmCoordination: true,
+                                coherenceMonitor: true
+                            }
                         };
-                    }
-                    catch {
-                        return {
-                            success: true,
-                            action: 'drift',
-                            status: { semanticDrift: { enabled: false, reason: 'Intelligence module unavailable' } },
-                        };
-                    }
-                case 'consolidate':
-                    // Get real consolidation metrics
-                    try {
-                        const { getIntelligenceStats } = await import('../memory/intelligence.js');
-                        const stats = getIntelligenceStats();
-                        return {
-                            success: true,
-                            action: 'consolidate',
-                            status: {
-                                memoryPhysics: {
-                                    enabled: config.neural.features?.memoryPhysics ?? false,
-                                    decayRate: config.neural.decayRate,
-                                    patternsStored: stats.reasoningBankSize,
-                                    trajectoriesRecorded: stats.trajectoriesRecorded,
+                        saveConfig(config);
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'init',
+                                neural: config.neural,
+                                message: 'Neural substrate initialized with RuVector integration'
+                            }];
+                    case 2:
+                        _m.trys.push([2, 4, , 5]);
+                        return [4 /*yield*/, import('../memory/intelligence.js')];
+                    case 3:
+                        getIntelligenceStats = (_m.sent()).getIntelligenceStats;
+                        stats = getIntelligenceStats();
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'drift',
+                                status: {
+                                    semanticDrift: {
+                                        enabled: (_j = (_h = config.neural.features) === null || _h === void 0 ? void 0 : _h.semanticDrift) !== null && _j !== void 0 ? _j : false,
+                                        threshold: config.neural.driftThreshold,
+                                        patternsTracked: stats.patternsLearned,
+                                        status: stats.patternsLearned > 0 ? 'tracking' : 'no patterns'
+                                    }
                                 },
-                            },
-                            message: `ReasoningBank: ${stats.reasoningBankSize} patterns, ${stats.trajectoriesRecorded} trajectories`,
-                        };
-                    }
-                    catch {
-                        return {
-                            success: true,
-                            action: 'consolidate',
-                            status: { memoryPhysics: { enabled: false, reason: 'Intelligence module unavailable' } },
-                        };
-                    }
-                case 'adapt':
-                    // Get real SONA adaptation metrics
-                    try {
-                        const { benchmarkAdaptation, initializeIntelligence } = await import('../memory/intelligence.js');
-                        await initializeIntelligence();
-                        const benchmark = benchmarkAdaptation(100);
-                        return {
-                            success: true,
-                            action: 'adapt',
-                            status: {
-                                sona: {
-                                    enabled: true,
-                                    adaptationTime: `${(benchmark.avgMs * 1000).toFixed(2)}μs`,
-                                    targetMet: benchmark.targetMet,
-                                    minTime: `${(benchmark.minMs * 1000).toFixed(2)}μs`,
-                                    maxTime: `${(benchmark.maxMs * 1000).toFixed(2)}μs`,
+                                message: stats.patternsLearned > 0
+                                    ? "Tracking " + stats.patternsLearned + " patterns for drift"
+                                    : 'No patterns stored yet - drift detection inactive'
+                            }];
+                    case 4:
+                        _b = _m.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'drift',
+                                status: { semanticDrift: { enabled: false, reason: 'Intelligence module unavailable' } }
+                            }];
+                    case 5:
+                        _m.trys.push([5, 7, , 8]);
+                        return [4 /*yield*/, import('../memory/intelligence.js')];
+                    case 6:
+                        getIntelligenceStats = (_m.sent()).getIntelligenceStats;
+                        stats = getIntelligenceStats();
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'consolidate',
+                                status: {
+                                    memoryPhysics: {
+                                        enabled: (_l = (_k = config.neural.features) === null || _k === void 0 ? void 0 : _k.memoryPhysics) !== null && _l !== void 0 ? _l : false,
+                                        decayRate: config.neural.decayRate,
+                                        patternsStored: stats.reasoningBankSize,
+                                        trajectoriesRecorded: stats.trajectoriesRecorded
+                                    }
                                 },
-                            },
-                            message: benchmark.targetMet
-                                ? `SONA adaptation: ${(benchmark.avgMs * 1000).toFixed(2)}μs (target <50μs met)`
-                                : `SONA adaptation: ${(benchmark.avgMs * 1000).toFixed(2)}μs (target not met)`,
-                        };
-                    }
-                    catch {
-                        return {
-                            success: true,
-                            action: 'adapt',
-                            status: { sona: { enabled: false, reason: 'Intelligence module unavailable' } },
-                        };
-                    }
-                default: // status
-                    // Get real neural system status
-                    try {
-                        const { getIntelligenceStats, benchmarkAdaptation, initializeIntelligence } = await import('../memory/intelligence.js');
-                        await initializeIntelligence();
-                        const stats = getIntelligenceStats();
-                        const benchmark = benchmarkAdaptation(50);
-                        return {
-                            success: true,
-                            action: 'status',
-                            neural: {
-                                enabled: config.neural.enabled,
-                                sonaEnabled: stats.sonaEnabled,
-                                ruvector: config.neural.ruvector || { enabled: false },
-                                features: config.neural.features || {},
-                                realMetrics: {
-                                    patternsLearned: stats.patternsLearned,
-                                    trajectoriesRecorded: stats.trajectoriesRecorded,
-                                    reasoningBankSize: stats.reasoningBankSize,
-                                    adaptationTime: `${(benchmark.avgMs * 1000).toFixed(2)}μs`,
-                                    targetMet: benchmark.targetMet,
-                                    lastAdaptation: stats.lastAdaptation
-                                        ? new Date(stats.lastAdaptation).toISOString()
-                                        : null,
+                                message: "ReasoningBank: " + stats.reasoningBankSize + " patterns, " + stats.trajectoriesRecorded + " trajectories"
+                            }];
+                    case 7:
+                        _c = _m.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'consolidate',
+                                status: { memoryPhysics: { enabled: false, reason: 'Intelligence module unavailable' } }
+                            }];
+                    case 8:
+                        _m.trys.push([8, 11, , 12]);
+                        return [4 /*yield*/, import('../memory/intelligence.js')];
+                    case 9:
+                        _d = _m.sent(), benchmarkAdaptation = _d.benchmarkAdaptation, initializeIntelligence = _d.initializeIntelligence;
+                        return [4 /*yield*/, initializeIntelligence()];
+                    case 10:
+                        _m.sent();
+                        benchmark = benchmarkAdaptation(100);
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'adapt',
+                                status: {
+                                    sona: {
+                                        enabled: true,
+                                        adaptationTime: (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs",
+                                        targetMet: benchmark.targetMet,
+                                        minTime: (benchmark.minMs * 1000).toFixed(2) + "\u03BCs",
+                                        maxTime: (benchmark.maxMs * 1000).toFixed(2) + "\u03BCs"
+                                    }
                                 },
-                            },
-                            capabilities: [
-                                stats.sonaEnabled ? '✅ SONA Active' : '❌ SONA Inactive',
-                                benchmark.targetMet ? '✅ <0.05ms Target Met' : '⚠️ Target Not Met',
-                                `${stats.patternsLearned} patterns learned`,
-                                `${stats.trajectoriesRecorded} trajectories recorded`,
-                            ],
-                        };
-                    }
-                    catch {
-                        return {
-                            success: true,
-                            action: 'status',
-                            neural: {
-                                enabled: config.neural.enabled,
-                                ruvector: config.neural.ruvector || { enabled: false },
-                                features: config.neural.features || {},
-                            },
-                            message: 'Intelligence module not available - showing config only',
-                        };
-                    }
-            }
-        },
+                                message: benchmark.targetMet
+                                    ? "SONA adaptation: " + (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs (target <50\u03BCs met)"
+                                    : "SONA adaptation: " + (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs (target not met)"
+                            }];
+                    case 11:
+                        _e = _m.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'adapt',
+                                status: { sona: { enabled: false, reason: 'Intelligence module unavailable' } }
+                            }];
+                    case 12:
+                        _m.trys.push([12, 15, , 16]);
+                        return [4 /*yield*/, import('../memory/intelligence.js')];
+                    case 13:
+                        _f = _m.sent(), getIntelligenceStats = _f.getIntelligenceStats, benchmarkAdaptation = _f.benchmarkAdaptation, initializeIntelligence = _f.initializeIntelligence;
+                        return [4 /*yield*/, initializeIntelligence()];
+                    case 14:
+                        _m.sent();
+                        stats = getIntelligenceStats();
+                        benchmark = benchmarkAdaptation(50);
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'status',
+                                neural: {
+                                    enabled: config.neural.enabled,
+                                    sonaEnabled: stats.sonaEnabled,
+                                    ruvector: config.neural.ruvector || { enabled: false },
+                                    features: config.neural.features || {},
+                                    realMetrics: {
+                                        patternsLearned: stats.patternsLearned,
+                                        trajectoriesRecorded: stats.trajectoriesRecorded,
+                                        reasoningBankSize: stats.reasoningBankSize,
+                                        adaptationTime: (benchmark.avgMs * 1000).toFixed(2) + "\u03BCs",
+                                        targetMet: benchmark.targetMet,
+                                        lastAdaptation: stats.lastAdaptation
+                                            ? new Date(stats.lastAdaptation).toISOString()
+                                            : null
+                                    }
+                                },
+                                capabilities: [
+                                    stats.sonaEnabled ? '✅ SONA Active' : '❌ SONA Inactive',
+                                    benchmark.targetMet ? '✅ <0.05ms Target Met' : '⚠️ Target Not Met',
+                                    stats.patternsLearned + " patterns learned",
+                                    stats.trajectoriesRecorded + " trajectories recorded",
+                                ]
+                            }];
+                    case 15:
+                        _g = _m.sent();
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'status',
+                                neural: {
+                                    enabled: config.neural.enabled,
+                                    ruvector: config.neural.ruvector || { enabled: false },
+                                    features: config.neural.features || {}
+                                },
+                                message: 'Intelligence module not available - showing config only'
+                            }];
+                    case 16: return [2 /*return*/];
+                }
+            });
+        }); }
     },
     {
         name: 'embeddings_hyperbolic',
@@ -633,106 +737,109 @@ export const embeddingsTools = [
                 action: {
                     type: 'string',
                     description: 'Hyperbolic action',
-                    enum: ['status', 'convert', 'distance', 'midpoint'],
-                    default: 'status',
+                    "enum": ['status', 'convert', 'distance', 'midpoint'],
+                    "default": 'status'
                 },
                 embedding: {
                     type: 'array',
                     description: 'Euclidean embedding to convert',
-                    items: { type: 'number' },
+                    items: { type: 'number' }
                 },
                 embedding1: {
                     type: 'array',
                     description: 'First embedding for distance/midpoint',
-                    items: { type: 'number' },
+                    items: { type: 'number' }
                 },
                 embedding2: {
                     type: 'array',
                     description: 'Second embedding for distance/midpoint',
-                    items: { type: 'number' },
-                },
-            },
-        },
-        handler: async (input) => {
-            const config = loadConfig();
-            if (!config) {
-                return {
-                    success: false,
-                    error: 'Embeddings not initialized. Run embeddings/init first.',
-                };
-            }
-            if (!config.hyperbolic.enabled) {
-                return {
-                    success: false,
-                    error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.',
-                };
-            }
-            const action = input.action || 'status';
-            const curvature = config.hyperbolic.curvature;
-            switch (action) {
-                case 'convert':
-                    const embedding = input.embedding;
-                    if (!embedding || !Array.isArray(embedding)) {
-                        return { success: false, error: 'Embedding array required for convert action' };
-                    }
-                    const poincare = toPoincare(embedding, curvature);
-                    return {
-                        success: true,
-                        action: 'convert',
-                        euclidean: embedding,
-                        poincare,
-                        curvature,
-                        poincareNorm: Math.sqrt(poincare.reduce((sum, x) => sum + x * x, 0)),
-                    };
-                case 'distance':
-                    const emb1 = input.embedding1;
-                    const emb2 = input.embedding2;
-                    if (!emb1 || !emb2) {
-                        return { success: false, error: 'embedding1 and embedding2 required for distance action' };
-                    }
-                    const dist = poincareDistance(emb1, emb2, curvature);
-                    return {
-                        success: true,
-                        action: 'distance',
-                        distance: dist,
-                        curvature,
-                        interpretation: dist < 1 ? 'close' : dist < 2 ? 'moderate' : 'far',
-                    };
-                case 'midpoint':
-                    const e1 = input.embedding1;
-                    const e2 = input.embedding2;
-                    if (!e1 || !e2) {
-                        return { success: false, error: 'embedding1 and embedding2 required for midpoint action' };
-                    }
-                    // Simplified midpoint (proper Möbius midpoint is more complex)
-                    const mid = e1.map((_, i) => (e1[i] + e2[i]) / 2);
-                    const norm = Math.sqrt(mid.reduce((sum, x) => sum + x * x, 0));
-                    const scaledMid = mid.map(x => x * (config.hyperbolic.maxNorm / Math.max(norm, config.hyperbolic.maxNorm)));
-                    return {
-                        success: true,
-                        action: 'midpoint',
-                        midpoint: scaledMid,
-                        curvature,
-                    };
-                default: // status
-                    return {
-                        success: true,
-                        action: 'status',
-                        hyperbolic: {
-                            enabled: true,
-                            curvature,
-                            epsilon: config.hyperbolic.epsilon,
-                            maxNorm: config.hyperbolic.maxNorm,
-                        },
-                        benefits: [
-                            'Better hierarchical data representation',
-                            'Exponential capacity in low dimensions',
-                            'Preserves tree-like structures',
-                            'Natural for taxonomy embeddings',
-                        ],
-                    };
+                    items: { type: 'number' }
+                }
             }
         },
+        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+            var config, action, curvature, embedding, poincare, emb1, emb2, dist, e1_1, e2_1, mid, norm_1, scaledMid;
+            return __generator(this, function (_a) {
+                config = loadConfig();
+                if (!config) {
+                    return [2 /*return*/, {
+                            success: false,
+                            error: 'Embeddings not initialized. Run embeddings/init first.'
+                        }];
+                }
+                if (!config.hyperbolic.enabled) {
+                    return [2 /*return*/, {
+                            success: false,
+                            error: 'Hyperbolic mode not enabled. Initialize with hyperbolic=true.'
+                        }];
+                }
+                action = input.action || 'status';
+                curvature = config.hyperbolic.curvature;
+                switch (action) {
+                    case 'convert':
+                        embedding = input.embedding;
+                        if (!embedding || !Array.isArray(embedding)) {
+                            return [2 /*return*/, { success: false, error: 'Embedding array required for convert action' }];
+                        }
+                        poincare = toPoincare(embedding, curvature);
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'convert',
+                                euclidean: embedding,
+                                poincare: poincare,
+                                curvature: curvature,
+                                poincareNorm: Math.sqrt(poincare.reduce(function (sum, x) { return sum + x * x; }, 0))
+                            }];
+                    case 'distance':
+                        emb1 = input.embedding1;
+                        emb2 = input.embedding2;
+                        if (!emb1 || !emb2) {
+                            return [2 /*return*/, { success: false, error: 'embedding1 and embedding2 required for distance action' }];
+                        }
+                        dist = poincareDistance(emb1, emb2, curvature);
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'distance',
+                                distance: dist,
+                                curvature: curvature,
+                                interpretation: dist < 1 ? 'close' : dist < 2 ? 'moderate' : 'far'
+                            }];
+                    case 'midpoint':
+                        e1_1 = input.embedding1;
+                        e2_1 = input.embedding2;
+                        if (!e1_1 || !e2_1) {
+                            return [2 /*return*/, { success: false, error: 'embedding1 and embedding2 required for midpoint action' }];
+                        }
+                        mid = e1_1.map(function (_, i) { return (e1_1[i] + e2_1[i]) / 2; });
+                        norm_1 = Math.sqrt(mid.reduce(function (sum, x) { return sum + x * x; }, 0));
+                        scaledMid = mid.map(function (x) { return x * (config.hyperbolic.maxNorm / Math.max(norm_1, config.hyperbolic.maxNorm)); });
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'midpoint',
+                                midpoint: scaledMid,
+                                curvature: curvature
+                            }];
+                    default: // status
+                        return [2 /*return*/, {
+                                success: true,
+                                action: 'status',
+                                hyperbolic: {
+                                    enabled: true,
+                                    curvature: curvature,
+                                    epsilon: config.hyperbolic.epsilon,
+                                    maxNorm: config.hyperbolic.maxNorm
+                                },
+                                benefits: [
+                                    'Better hierarchical data representation',
+                                    'Exponential capacity in low dimensions',
+                                    'Preserves tree-like structures',
+                                    'Natural for taxonomy embeddings',
+                                ]
+                            }];
+                }
+                return [2 /*return*/];
+            });
+        }); }
     },
     {
         name: 'embeddings_status',
@@ -740,43 +847,47 @@ export const embeddingsTools = [
         category: 'embeddings',
         inputSchema: {
             type: 'object',
-            properties: {},
-        },
-        handler: async () => {
-            const config = loadConfig();
-            if (!config) {
-                return {
-                    success: false,
-                    initialized: false,
-                    message: 'Embeddings not initialized. Run embeddings/init first.',
-                };
-            }
-            return {
-                success: true,
-                initialized: true,
-                config: {
-                    model: config.model,
-                    dimension: config.dimension,
-                    cacheSize: config.cacheSize,
-                    hyperbolic: config.hyperbolic,
-                    neural: {
-                        enabled: config.neural.enabled,
-                        ruvector: config.neural.ruvector?.enabled ?? false,
-                    },
-                },
-                paths: {
-                    config: getConfigPath(),
-                    models: config.modelPath,
-                },
-                initializedAt: config.initialized,
-                capabilities: {
-                    onnxModels: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
-                    geometries: ['euclidean', 'poincare'],
-                    normalizations: ['L2', 'L1', 'minmax', 'zscore'],
-                    features: ['semantic search', 'hyperbolic projection', 'neural substrate'],
-                },
-            };
+            properties: {}
         },
+        handler: function () { return __awaiter(void 0, void 0, void 0, function () {
+            var config;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                config = loadConfig();
+                if (!config) {
+                    return [2 /*return*/, {
+                            success: false,
+                            initialized: false,
+                            message: 'Embeddings not initialized. Run embeddings/init first.'
+                        }];
+                }
+                return [2 /*return*/, {
+                        success: true,
+                        initialized: true,
+                        config: {
+                            model: config.model,
+                            dimension: config.dimension,
+                            cacheSize: config.cacheSize,
+                            hyperbolic: config.hyperbolic,
+                            neural: {
+                                enabled: config.neural.enabled,
+                                ruvector: (_b = (_a = config.neural.ruvector) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false
+                            }
+                        },
+                        paths: {
+                            config: getConfigPath(),
+                            models: config.modelPath
+                        },
+                        initializedAt: config.initialized,
+                        capabilities: {
+                            onnxModels: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
+                            geometries: ['euclidean', 'poincare'],
+                            normalizations: ['L2', 'L1', 'minmax', 'zscore'],
+                            features: ['semantic search', 'hyperbolic projection', 'neural substrate']
+                        }
+                    }];
+            });
+        }); }
     },
 ];
 //# sourceMappingURL=embeddings-tools.js.map