kynjal-cli 4.0.0 → 4.0.1

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

@@ -11,114 +11,53 @@
  *
  * Note: For production neural features, use @claude-flow/neural module
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
 // Try to import real embeddings — prefer agentic-flow v3 ReasoningBank, then @claude-flow/embeddings
-var realEmbeddings = null;
-var embeddingServiceName = 'none';
+let realEmbeddings = null;
+let embeddingServiceName = 'none';
 try {
     // Tier 1: agentic-flow v3 ReasoningBank (fastest — WASM-accelerated)
-    var rb_1 = await import('agentic-flow/reasoningbank')["catch"](function () { return null; });
-    if (rb_1 === null || rb_1 === void 0 ? void 0 : rb_1.computeEmbedding) {
-        realEmbeddings = { embed: function (text) { return rb_1.computeEmbedding(text); } };
+    const rb = await import('agentic-flow/reasoningbank').catch(() => null);
+    if (rb?.computeEmbedding) {
+        realEmbeddings = { embed: (text) => rb.computeEmbedding(text) };
         embeddingServiceName = 'agentic-flow/reasoningbank';
     }
     // Tier 2: @claude-flow/embeddings
     if (!realEmbeddings) {
-        var embeddingsModule = await import('@claude-flow/embeddings')["catch"](function () { return null; });
-        if (embeddingsModule === null || embeddingsModule === void 0 ? void 0 : embeddingsModule.createEmbeddingService) {
+        const embeddingsModule = await import('@claude-flow/embeddings').catch(() => null);
+        if (embeddingsModule?.createEmbeddingService) {
             try {
-                var service_1 = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
+                const service = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
                 realEmbeddings = {
-                    embed: function (text) { return __awaiter(void 0, void 0, void 0, function () {
-                        var result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, service_1.embed(text)];
-                                case 1:
-                                    result = _a.sent();
-                                    return [2 /*return*/, Array.from(result.embedding)];
-                            }
-                        });
-                    }); }
+                    embed: async (text) => {
+                        const result = await service.embed(text);
+                        return Array.from(result.embedding);
+                    },
                 };
                 embeddingServiceName = 'agentic-flow';
             }
-            catch (_a) {
-                var service_2 = embeddingsModule.createEmbeddingService({ provider: 'mock' });
+            catch {
+                const service = embeddingsModule.createEmbeddingService({ provider: 'mock' });
                 realEmbeddings = {
-                    embed: function (text) { return __awaiter(void 0, void 0, void 0, function () {
-                        var result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0: return [4 /*yield*/, service_2.embed(text)];
-                                case 1:
-                                    result = _a.sent();
-                                    return [2 /*return*/, Array.from(result.embedding)];
-                            }
-                        });
-                    }); }
+                    embed: async (text) => {
+                        const result = await service.embed(text);
+                        return Array.from(result.embedding);
+                    },
                 };
                 embeddingServiceName = 'mock';
             }
         }
     }
 }
-catch (_b) {
+catch {
     // No embedding provider available, will use fallback
 }
 // Storage paths
-var STORAGE_DIR = '.claude-flow';
-var NEURAL_DIR = 'neural';
-var MODELS_FILE = 'models.json';
-var PATTERNS_FILE = 'patterns.json';
+const STORAGE_DIR = '.claude-flow';
+const NEURAL_DIR = 'neural';
+const MODELS_FILE = 'models.json';
+const PATTERNS_FILE = 'patterns.json';
 function getNeuralDir() {
     return join(process.cwd(), STORAGE_DIR, NEURAL_DIR);
 }
@@ -126,19 +65,19 @@ function getNeuralPath() {
     return join(getNeuralDir(), MODELS_FILE);
 }
 function ensureNeuralDir() {
-    var dir = getNeuralDir();
+    const dir = getNeuralDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadNeuralStore() {
     try {
-        var path = getNeuralPath();
+        const path = getNeuralPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch (_a) {
+    catch {
         // Return empty store
     }
     return { models: {}, patterns: {}, version: '3.0.0' };
@@ -148,58 +87,49 @@ function saveNeuralStore(store) {
     writeFileSync(getNeuralPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
 // Generate embedding - uses real embeddings if available, falls back to hash-based
-function generateEmbedding(text, dims) {
-    if (dims === void 0) { dims = 384; }
-    return __awaiter(this, void 0, Promise, function () {
-        var _a, hash, embedding, seed, i;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!(realEmbeddings && text)) return [3 /*break*/, 4];
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, realEmbeddings.embed(text)];
-                case 2: return [2 /*return*/, _b.sent()];
-                case 3:
-                    _a = _b.sent();
-                    return [3 /*break*/, 4];
-                case 4:
-                    // Hash-based deterministic embedding (better than pure random for consistency)
-                    if (text) {
-                        hash = text.split('').reduce(function (acc, char, i) {
-                            return acc + char.charCodeAt(0) * (i + 1);
-                        }, 0);
-                        embedding = [];
-                        seed = hash;
-                        for (i = 0; i < dims; i++) {
-                            // Simple LCG random with seed
-                            seed = (seed * 1103515245 + 12345) & 0x7fffffff;
-                            embedding.push((seed / 0x7fffffff) * 2 - 1);
-                        }
-                        return [2 /*return*/, embedding];
-                    }
-                    // Pure random fallback
-                    return [2 /*return*/, Array.from({ length: dims }, function () { return Math.random() * 2 - 1; })];
-            }
-        });
-    });
+async function generateEmbedding(text, dims = 384) {
+    // If real embeddings available and text provided, use them
+    if (realEmbeddings && text) {
+        try {
+            return await realEmbeddings.embed(text);
+        }
+        catch {
+            // Fall back to hash-based
+        }
+    }
+    // Hash-based deterministic embedding (better than pure random for consistency)
+    if (text) {
+        const hash = text.split('').reduce((acc, char, i) => {
+            return acc + char.charCodeAt(0) * (i + 1);
+        }, 0);
+        // Use hash to seed a deterministic embedding
+        const embedding = [];
+        let seed = hash;
+        for (let i = 0; i < dims; i++) {
+            // Simple LCG random with seed
+            seed = (seed * 1103515245 + 12345) & 0x7fffffff;
+            embedding.push((seed / 0x7fffffff) * 2 - 1);
+        }
+        return embedding;
+    }
+    // Pure random fallback
+    return Array.from({ length: dims }, () => Math.random() * 2 - 1);
 }
 // Cosine similarity for pattern search
 function cosineSimilarity(a, b) {
     if (a.length !== b.length)
         return 0;
-    var dotProduct = 0;
-    var normA = 0;
-    var normB = 0;
-    for (var i = 0; i < a.length; i++) {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
         dotProduct += a[i] * b[i];
         normA += a[i] * a[i];
         normB += b[i] * b[i];
     }
     return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB) || 1);
 }
-export var neuralTools = [
+export const neuralTools = [
     {
         name: 'neural_train',
         description: 'Train a neural model',
@@ -208,57 +138,48 @@ export var neuralTools = [
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Model ID to train' },
-                modelType: { type: 'string', "enum": ['moe', 'transformer', 'classifier', 'embedding'], description: 'Model type' },
+                modelType: { type: 'string', enum: ['moe', 'transformer', 'classifier', 'embedding'], description: 'Model type' },
                 epochs: { type: 'number', description: 'Number of training epochs' },
                 learningRate: { type: 'number', description: 'Learning rate' },
-                data: { type: 'object', description: 'Training data' }
+                data: { type: 'object', description: 'Training data' },
             },
-            required: ['modelType']
+            required: ['modelType'],
+        },
+        handler: async (input) => {
+            const store = loadNeuralStore();
+            const modelId = input.modelId || `model-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+            const modelType = input.modelType;
+            const epochs = input.epochs || 10;
+            const model = {
+                id: modelId,
+                name: `${modelType}-model`,
+                type: modelType,
+                status: 'training',
+                accuracy: 0,
+                epochs,
+                config: {
+                    learningRate: input.learningRate || 0.001,
+                    batchSize: 32,
+                },
+            };
+            store.models[modelId] = model;
+            saveNeuralStore(store);
+            // Simulate training
+            await new Promise(resolve => setTimeout(resolve, 100));
+            model.status = 'ready';
+            model.accuracy = 0.85 + Math.random() * 0.1;
+            model.trainedAt = new Date().toISOString();
+            saveNeuralStore(store);
+            return {
+                success: true,
+                modelId,
+                type: modelType,
+                status: model.status,
+                accuracy: model.accuracy,
+                epochs,
+                trainedAt: model.trainedAt,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, modelId, modelType, epochs, model;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        store = loadNeuralStore();
-                        modelId = input.modelId || "model-" + Date.now() + "-" + Math.random().toString(36).slice(2, 6);
-                        modelType = input.modelType;
-                        epochs = input.epochs || 10;
-                        model = {
-                            id: modelId,
-                            name: modelType + "-model",
-                            type: modelType,
-                            status: 'training',
-                            accuracy: 0,
-                            epochs: epochs,
-                            config: {
-                                learningRate: input.learningRate || 0.001,
-                                batchSize: 32
-                            }
-                        };
-                        store.models[modelId] = model;
-                        saveNeuralStore(store);
-                        // Simulate training
-                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
-                    case 1:
-                        // Simulate training
-                        _a.sent();
-                        model.status = 'ready';
-                        model.accuracy = 0.85 + Math.random() * 0.1;
-                        model.trainedAt = new Date().toISOString();
-                        saveNeuralStore(store);
-                        return [2 /*return*/, {
-                                success: true,
-                                modelId: modelId,
-                                type: modelType,
-                                status: model.status,
-                                accuracy: model.accuracy,
-                                epochs: epochs,
-                                trainedAt: model.trainedAt
-                            }];
-                }
-            });
-        }); }
     },
     {
         name: 'neural_predict',
@@ -269,49 +190,44 @@ export var neuralTools = [
             properties: {
                 modelId: { type: 'string', description: 'Model ID to use' },
                 input: { type: 'string', description: 'Input text or data' },
-                topK: { type: 'number', description: 'Number of top predictions' }
+                topK: { type: 'number', description: 'Number of top predictions' },
             },
-            required: ['input']
+            required: ['input'],
+        },
+        handler: async (input) => {
+            const store = loadNeuralStore();
+            const modelId = input.modelId;
+            const inputText = input.input;
+            const topK = input.topK || 3;
+            // Find model or use default
+            const model = modelId ? store.models[modelId] : Object.values(store.models).find(m => m.status === 'ready');
+            if (model && model.status !== 'ready') {
+                return { success: false, error: 'Model not ready' };
+            }
+            // Simulate predictions
+            const predictions = [
+                { label: 'coder', confidence: 0.75 + Math.random() * 0.2 },
+                { label: 'researcher', confidence: 0.5 + Math.random() * 0.3 },
+                { label: 'reviewer', confidence: 0.3 + Math.random() * 0.4 },
+                { label: 'tester', confidence: 0.2 + Math.random() * 0.3 },
+            ]
+                .sort((a, b) => b.confidence - a.confidence)
+                .slice(0, topK);
+            // Generate real embedding for the input
+            const startTime = performance.now();
+            const embedding = await generateEmbedding(inputText, 128);
+            const latency = Math.round(performance.now() - startTime);
+            return {
+                success: true,
+                _realEmbedding: !!realEmbeddings,
+                modelId: model?.id || 'default',
+                input: inputText,
+                predictions,
+                embedding: embedding.slice(0, 8), // Preview of embedding
+                embeddingDims: embedding.length,
+                latency,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, modelId, inputText, topK, model, predictions, startTime, embedding, latency;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        store = loadNeuralStore();
-                        modelId = input.modelId;
-                        inputText = input.input;
-                        topK = input.topK || 3;
-                        model = modelId ? store.models[modelId] : Object.values(store.models).find(function (m) { return m.status === 'ready'; });
-                        if (model && model.status !== 'ready') {
-                            return [2 /*return*/, { success: false, error: 'Model not ready' }];
-                        }
-                        predictions = [
-                            { label: 'coder', confidence: 0.75 + Math.random() * 0.2 },
-                            { label: 'researcher', confidence: 0.5 + Math.random() * 0.3 },
-                            { label: 'reviewer', confidence: 0.3 + Math.random() * 0.4 },
-                            { label: 'tester', confidence: 0.2 + Math.random() * 0.3 },
-                        ]
-                            .sort(function (a, b) { return b.confidence - a.confidence; })
-                            .slice(0, topK);
-                        startTime = performance.now();
-                        return [4 /*yield*/, generateEmbedding(inputText, 128)];
-                    case 1:
-                        embedding = _a.sent();
-                        latency = Math.round(performance.now() - startTime);
-                        return [2 /*return*/, {
-                                success: true,
-                                _realEmbedding: !!realEmbeddings,
-                                modelId: (model === null || model === void 0 ? void 0 : model.id) || 'default',
-                                input: inputText,
-                                predictions: predictions,
-                                embedding: embedding.slice(0, 8),
-                                embeddingDims: embedding.length,
-                                latency: latency
-                            }];
-                }
-            });
-        }); }
     },
     {
         name: 'neural_patterns',
@@ -320,105 +236,101 @@ export var neuralTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['list', 'get', 'store', 'search', 'delete'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['list', 'get', 'store', 'search', 'delete'], description: 'Action to perform' },
                 patternId: { type: 'string', description: 'Pattern ID' },
                 name: { type: 'string', description: 'Pattern name' },
                 type: { type: 'string', description: 'Pattern type' },
                 query: { type: 'string', description: 'Search query' },
-                data: { type: 'object', description: 'Pattern data' }
-            }
+                data: { type: 'object', description: 'Pattern data' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, patterns, typeFilter_1, filtered, pattern, patternId, patternName, embedding, pattern, query, queryEmbedding_1, results, patternId;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        store = loadNeuralStore();
-                        action = input.action || 'list';
-                        if (action === 'list') {
-                            patterns = Object.values(store.patterns);
-                            typeFilter_1 = input.type;
-                            filtered = typeFilter_1 ? patterns.filter(function (p) { return p.type === typeFilter_1; }) : patterns;
-                            return [2 /*return*/, {
-                                    patterns: filtered.map(function (p) { return ({
-                                        id: p.id,
-                                        name: p.name,
-                                        type: p.type,
-                                        usageCount: p.usageCount,
-                                        createdAt: p.createdAt
-                                    }); }),
-                                    total: filtered.length
-                                }];
-                        }
-                        if (action === 'get') {
-                            pattern = store.patterns[input.patternId];
-                            if (!pattern) {
-                                return [2 /*return*/, { success: false, error: 'Pattern not found' }];
-                            }
-                            return [2 /*return*/, { success: true, pattern: pattern }];
-                        }
-                        if (!(action === 'store')) return [3 /*break*/, 2];
-                        patternId = "pattern-" + Date.now() + "-" + Math.random().toString(36).slice(2, 6);
-                        patternName = input.name || 'Unnamed pattern';
-                        return [4 /*yield*/, generateEmbedding(patternName, 384)];
-                    case 1:
-                        embedding = _a.sent();
-                        pattern = {
-                            id: patternId,
-                            name: patternName,
-                            type: input.type || 'general',
-                            embedding: embedding,
-                            metadata: input.data || {},
-                            createdAt: new Date().toISOString(),
-                            usageCount: 0
-                        };
-                        store.patterns[patternId] = pattern;
-                        saveNeuralStore(store);
-                        return [2 /*return*/, {
-                                success: true,
-                                _realEmbedding: !!realEmbeddings,
-                                patternId: patternId,
-                                name: pattern.name,
-                                type: pattern.type,
-                                embeddingDims: embedding.length,
-                                createdAt: pattern.createdAt
-                            }];
-                    case 2:
-                        if (!(action === 'search')) return [3 /*break*/, 4];
-                        query = input.query;
-                        return [4 /*yield*/, generateEmbedding(query, 384)];
-                    case 3:
-                        queryEmbedding_1 = _a.sent();
-                        results = Object.values(store.patterns)
-                            .map(function (p) { return (__assign(__assign({}, p), { similarity: cosineSimilarity(queryEmbedding_1, p.embedding) })); })
-                            .sort(function (a, b) { return b.similarity - a.similarity; })
-                            .slice(0, 10);
-                        return [2 /*return*/, {
-                                _realSimilarity: true,
-                                _realEmbedding: !!realEmbeddings,
-                                query: query,
-                                results: results.map(function (r) { return ({
-                                    id: r.id,
-                                    name: r.name,
-                                    type: r.type,
-                                    similarity: r.similarity
-                                }); }),
-                                total: results.length
-                            }];
-                    case 4:
-                        if (action === 'delete') {
-                            patternId = input.patternId;
-                            if (!store.patterns[patternId]) {
-                                return [2 /*return*/, { success: false, error: 'Pattern not found' }];
-                            }
-                            delete store.patterns[patternId];
-                            saveNeuralStore(store);
-                            return [2 /*return*/, { success: true, deleted: patternId }];
-                        }
-                        return [2 /*return*/, { success: false, error: 'Unknown action' }];
+        handler: async (input) => {
+            const store = loadNeuralStore();
+            const action = input.action || 'list';
+            if (action === 'list') {
+                const patterns = Object.values(store.patterns);
+                const typeFilter = input.type;
+                const filtered = typeFilter ? patterns.filter(p => p.type === typeFilter) : patterns;
+                return {
+                    patterns: filtered.map(p => ({
+                        id: p.id,
+                        name: p.name,
+                        type: p.type,
+                        usageCount: p.usageCount,
+                        createdAt: p.createdAt,
+                    })),
+                    total: filtered.length,
+                };
+            }
+            if (action === 'get') {
+                const pattern = store.patterns[input.patternId];
+                if (!pattern) {
+                    return { success: false, error: 'Pattern not found' };
+                }
+                return { success: true, pattern };
+            }
+            if (action === 'store') {
+                const patternId = `pattern-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+                const patternName = input.name || 'Unnamed pattern';
+                // Generate embedding from pattern name/content
+                const embedding = await generateEmbedding(patternName, 384);
+                const pattern = {
+                    id: patternId,
+                    name: patternName,
+                    type: input.type || 'general',
+                    embedding,
+                    metadata: input.data || {},
+                    createdAt: new Date().toISOString(),
+                    usageCount: 0,
+                };
+                store.patterns[patternId] = pattern;
+                saveNeuralStore(store);
+                return {
+                    success: true,
+                    _realEmbedding: !!realEmbeddings,
+                    patternId,
+                    name: pattern.name,
+                    type: pattern.type,
+                    embeddingDims: embedding.length,
+                    createdAt: pattern.createdAt,
+                };
+            }
+            if (action === 'search') {
+                const query = input.query;
+                // Generate query embedding for real similarity search
+                const queryEmbedding = await generateEmbedding(query, 384);
+                // Calculate REAL cosine similarity against stored patterns
+                const results = Object.values(store.patterns)
+                    .map(p => ({
+                    ...p,
+                    similarity: cosineSimilarity(queryEmbedding, p.embedding),
+                }))
+                    .sort((a, b) => b.similarity - a.similarity)
+                    .slice(0, 10);
+                return {
+                    _realSimilarity: true,
+                    _realEmbedding: !!realEmbeddings,
+                    query,
+                    results: results.map(r => ({
+                        id: r.id,
+                        name: r.name,
+                        type: r.type,
+                        similarity: r.similarity,
+                    })),
+                    total: results.length,
+                };
+            }
+            if (action === 'delete') {
+                const patternId = input.patternId;
+                if (!store.patterns[patternId]) {
+                    return { success: false, error: 'Pattern not found' };
                 }
-            });
-        }); }
+                delete store.patterns[patternId];
+                saveNeuralStore(store);
+                return { success: true, deleted: patternId };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'neural_compress',
@@ -428,33 +340,30 @@ export var neuralTools = [
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Model ID to compress' },
-                method: { type: 'string', "enum": ['quantize', 'prune', 'distill'], description: 'Compression method' },
-                targetSize: { type: 'number', description: 'Target size reduction (0-1)' }
-            }
+                method: { type: 'string', enum: ['quantize', 'prune', 'distill'], description: 'Compression method' },
+                targetSize: { type: 'number', description: 'Target size reduction (0-1)' },
+            },
+        },
+        handler: async (input) => {
+            const method = input.method || 'quantize';
+            const targetSize = input.targetSize || 0.25;
+            const compressionResults = {
+                quantize: { ratio: 3.92, method: 'Int8', memory: '75% reduction' },
+                prune: { ratio: 2.5, method: 'Magnitude pruning', memory: '60% reduction' },
+                distill: { ratio: 4.0, method: 'Knowledge distillation', memory: '75% reduction' },
+            };
+            const result = compressionResults[method] || compressionResults.quantize;
+            return {
+                success: true,
+                method,
+                originalSize: '1536 dims',
+                compressedSize: `${Math.floor(1536 * targetSize)} dims`,
+                compressionRatio: result.ratio,
+                memoryReduction: result.memory,
+                qualityRetention: 0.98,
+                latencyImprovement: '2.5x faster',
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var method, targetSize, compressionResults, result;
-            return __generator(this, function (_a) {
-                method = input.method || 'quantize';
-                targetSize = input.targetSize || 0.25;
-                compressionResults = {
-                    quantize: { ratio: 3.92, method: 'Int8', memory: '75% reduction' },
-                    prune: { ratio: 2.5, method: 'Magnitude pruning', memory: '60% reduction' },
-                    distill: { ratio: 4.0, method: 'Knowledge distillation', memory: '75% reduction' }
-                };
-                result = compressionResults[method] || compressionResults.quantize;
-                return [2 /*return*/, {
-                        success: true,
-                        method: method,
-                        originalSize: '1536 dims',
-                        compressedSize: Math.floor(1536 * targetSize) + " dims",
-                        compressionRatio: result.ratio,
-                        memoryReduction: result.memory,
-                        qualityRetention: 0.98,
-                        latencyImprovement: '2.5x faster'
-                    }];
-            });
-        }); }
     },
     {
         name: 'neural_status',
@@ -464,50 +373,47 @@ export var neuralTools = [
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Specific model ID' },
-                detailed: { type: 'boolean', description: 'Include detailed info' }
-            }
+                detailed: { type: 'boolean', description: 'Include detailed info' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, model, models, patterns;
-            return __generator(this, function (_a) {
-                store = loadNeuralStore();
-                if (input.modelId) {
-                    model = store.models[input.modelId];
-                    if (!model) {
-                        return [2 /*return*/, { success: false, error: 'Model not found' }];
-                    }
-                    return [2 /*return*/, { success: true, model: model }];
+        handler: async (input) => {
+            const store = loadNeuralStore();
+            if (input.modelId) {
+                const model = store.models[input.modelId];
+                if (!model) {
+                    return { success: false, error: 'Model not found' };
                 }
-                models = Object.values(store.models);
-                patterns = Object.values(store.patterns);
-                return [2 /*return*/, {
-                        _realEmbeddings: !!realEmbeddings,
-                        embeddingProvider: realEmbeddings ? "@claude-flow/embeddings (" + embeddingServiceName + ")" : 'hash-based (deterministic)',
-                        models: {
-                            total: models.length,
-                            ready: models.filter(function (m) { return m.status === 'ready'; }).length,
-                            training: models.filter(function (m) { return m.status === 'training'; }).length,
-                            avgAccuracy: models.length > 0
-                                ? models.reduce(function (sum, m) { return sum + m.accuracy; }, 0) / models.length
-                                : 0
-                        },
-                        patterns: {
-                            total: patterns.length,
-                            byType: patterns.reduce(function (acc, p) {
-                                acc[p.type] = (acc[p.type] || 0) + 1;
-                                return acc;
-                            }, {}),
-                            totalEmbeddingDims: patterns.length > 0 ? patterns[0].embedding.length : 384
-                        },
-                        features: {
-                            hnsw: true,
-                            quantization: true,
-                            flashAttention: false,
-                            reasoningBank: true
-                        }
-                    }];
-            });
-        }); }
+                return { success: true, model };
+            }
+            const models = Object.values(store.models);
+            const patterns = Object.values(store.patterns);
+            return {
+                _realEmbeddings: !!realEmbeddings,
+                embeddingProvider: realEmbeddings ? `@claude-flow/embeddings (${embeddingServiceName})` : 'hash-based (deterministic)',
+                models: {
+                    total: models.length,
+                    ready: models.filter(m => m.status === 'ready').length,
+                    training: models.filter(m => m.status === 'training').length,
+                    avgAccuracy: models.length > 0
+                        ? models.reduce((sum, m) => sum + m.accuracy, 0) / models.length
+                        : 0,
+                },
+                patterns: {
+                    total: patterns.length,
+                    byType: patterns.reduce((acc, p) => {
+                        acc[p.type] = (acc[p.type] || 0) + 1;
+                        return acc;
+                    }, {}),
+                    totalEmbeddingDims: patterns.length > 0 ? patterns[0].embedding.length : 384,
+                },
+                features: {
+                    hnsw: true,
+                    quantization: true,
+                    flashAttention: false,
+                    reasoningBank: true,
+                },
+            };
+        },
     },
     {
         name: 'neural_optimize',
@@ -517,42 +423,39 @@ export var neuralTools = [
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Model ID to optimize' },
-                target: { type: 'string', "enum": ['speed', 'memory', 'accuracy', 'balanced'], description: 'Optimization target' }
-            }
+                target: { type: 'string', enum: ['speed', 'memory', 'accuracy', 'balanced'], description: 'Optimization target' },
+            },
+        },
+        handler: async (input) => {
+            const target = input.target || 'balanced';
+            const optimizations = {
+                speed: {
+                    applied: ['Flash Attention', 'Batch processing', 'SIMD vectorization'],
+                    improvement: '2.49x-7.47x faster inference',
+                },
+                memory: {
+                    applied: ['Int8 quantization', 'Gradient checkpointing', 'Memory pooling'],
+                    improvement: '50-75% memory reduction',
+                },
+                accuracy: {
+                    applied: ['EWC++ regularization', 'Ensemble averaging', 'Data augmentation'],
+                    improvement: '3-5% accuracy boost',
+                },
+                balanced: {
+                    applied: ['HNSW indexing', 'Smart caching', 'Adaptive batch size'],
+                    improvement: 'Balanced 30% improvement across metrics',
+                },
+            };
+            const result = optimizations[target] || optimizations.balanced;
+            return {
+                success: true,
+                target,
+                optimizations: result.applied,
+                improvement: result.improvement,
+                status: 'applied',
+                timestamp: new Date().toISOString(),
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var target, optimizations, result;
-            return __generator(this, function (_a) {
-                target = input.target || 'balanced';
-                optimizations = {
-                    speed: {
-                        applied: ['Flash Attention', 'Batch processing', 'SIMD vectorization'],
-                        improvement: '2.49x-7.47x faster inference'
-                    },
-                    memory: {
-                        applied: ['Int8 quantization', 'Gradient checkpointing', 'Memory pooling'],
-                        improvement: '50-75% memory reduction'
-                    },
-                    accuracy: {
-                        applied: ['EWC++ regularization', 'Ensemble averaging', 'Data augmentation'],
-                        improvement: '3-5% accuracy boost'
-                    },
-                    balanced: {
-                        applied: ['HNSW indexing', 'Smart caching', 'Adaptive batch size'],
-                        improvement: 'Balanced 30% improvement across metrics'
-                    }
-                };
-                result = optimizations[target] || optimizations.balanced;
-                return [2 /*return*/, {
-                        success: true,
-                        target: target,
-                        optimizations: result.applied,
-                        improvement: result.improvement,
-                        status: 'applied',
-                        timestamp: new Date().toISOString()
-                    }];
-            });
-        }); }
     },
 ];
 //# sourceMappingURL=neural-tools.js.map