kynjal-cli 3.1.3 → 4.0.0

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

@@ -11,48 +11,114 @@
  *
  * 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 from @claude-flow/embeddings
-let realEmbeddings = null;
-let embeddingServiceName = 'none';
+// Try to import real embeddings — prefer agentic-flow v3 ReasoningBank, then @claude-flow/embeddings
+var realEmbeddings = null;
+var embeddingServiceName = 'none';
 try {
-    // Dynamic import to avoid hard dependency
-    const embeddingsModule = await import('@claude-flow/embeddings');
-    if (embeddingsModule.createEmbeddingService) {
-        // Try to create agentic-flow service (fastest), fall back to mock
-        try {
-            const service = embeddingsModule.createEmbeddingService({ provider: 'agentic-flow' });
-            realEmbeddings = {
-                embed: async (text) => {
-                    const result = await service.embed(text);
-                    // Convert Float32Array to number[] if needed
-                    return Array.from(result.embedding);
-                },
-            };
-            embeddingServiceName = 'agentic-flow';
-        }
-        catch {
-            // Fall back to mock service
-            const service = embeddingsModule.createEmbeddingService({ provider: 'mock' });
-            realEmbeddings = {
-                embed: async (text) => {
-                    const result = await service.embed(text);
-                    return Array.from(result.embedding);
-                },
-            };
-            embeddingServiceName = 'mock';
+    // 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); } };
+        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) {
+            try {
+                var service_1 = 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)];
+                            }
+                        });
+                    }); }
+                };
+                embeddingServiceName = 'agentic-flow';
+            }
+            catch (_a) {
+                var service_2 = 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)];
+                            }
+                        });
+                    }); }
+                };
+                embeddingServiceName = 'mock';
+            }
         }
     }
 }
-catch {
-    // @claude-flow/embeddings not available, will use fallback
+catch (_b) {
+    // No embedding provider available, will use fallback
 }
 // Storage paths
-const STORAGE_DIR = '.claude-flow';
-const NEURAL_DIR = 'neural';
-const MODELS_FILE = 'models.json';
-const PATTERNS_FILE = 'patterns.json';
+var STORAGE_DIR = '.claude-flow';
+var NEURAL_DIR = 'neural';
+var MODELS_FILE = 'models.json';
+var PATTERNS_FILE = 'patterns.json';
 function getNeuralDir() {
     return join(process.cwd(), STORAGE_DIR, NEURAL_DIR);
 }
@@ -60,19 +126,19 @@ function getNeuralPath() {
     return join(getNeuralDir(), MODELS_FILE);
 }
 function ensureNeuralDir() {
-    const dir = getNeuralDir();
+    var dir = getNeuralDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadNeuralStore() {
     try {
-        const path = getNeuralPath();
+        var path = getNeuralPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch {
+    catch (_a) {
         // Return empty store
     }
     return { models: {}, patterns: {}, version: '3.0.0' };
@@ -82,49 +148,58 @@ function saveNeuralStore(store) {
     writeFileSync(getNeuralPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
 // Generate embedding - uses real embeddings if available, falls back to hash-based
-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);
+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; })];
+            }
+        });
+    });
 }
 // Cosine similarity for pattern search
 function cosineSimilarity(a, b) {
     if (a.length !== b.length)
         return 0;
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-    for (let i = 0; i < a.length; i++) {
+    var dotProduct = 0;
+    var normA = 0;
+    var normB = 0;
+    for (var 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 const neuralTools = [
+export var neuralTools = [
     {
         name: 'neural_train',
         description: 'Train a neural model',
@@ -133,48 +208,57 @@ export const 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'],
-        },
-        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,
-            };
+            required: ['modelType']
         },
+        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',
@@ -185,44 +269,49 @@ export const 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'],
-        },
-        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,
-            };
+            required: ['input']
         },
+        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',
@@ -231,101 +320,105 @@ export const 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' },
-            },
-        },
-        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,
-                };
+                data: { type: 'object', description: 'Pattern data' }
             }
-            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' };
         },
+        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' }];
+                }
+            });
+        }); }
     },
     {
         name: 'neural_compress',
@@ -335,30 +428,33 @@ export const 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)' },
-            },
-        },
-        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',
-            };
+                method: { type: 'string', "enum": ['quantize', 'prune', 'distill'], description: 'Compression method' },
+                targetSize: { type: 'number', description: 'Target size reduction (0-1)' }
+            }
         },
+        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',
@@ -368,47 +464,50 @@ export const neuralTools = [
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Specific model ID' },
-                detailed: { type: 'boolean', description: 'Include detailed info' },
-            },
-        },
-        handler: async (input) => {
-            const store = loadNeuralStore();
-            if (input.modelId) {
-                const model = store.models[input.modelId];
-                if (!model) {
-                    return { success: false, error: 'Model not found' };
-                }
-                return { success: true, model };
+                detailed: { type: 'boolean', description: 'Include detailed info' }
             }
-            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,
-                },
-            };
         },
+        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 }];
+                }
+                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
+                        }
+                    }];
+            });
+        }); }
     },
     {
         name: 'neural_optimize',
@@ -418,39 +517,42 @@ export const neuralTools = [
             type: 'object',
             properties: {
                 modelId: { type: 'string', description: 'Model ID to optimize' },
-                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(),
-            };
+                target: { type: 'string', "enum": ['speed', 'memory', 'accuracy', 'balanced'], description: 'Optimization target' }
+            }
         },
+        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