kynjal-cli 4.0.0 → 4.0.1

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

@@ -8,59 +8,12 @@
  * - No actual distributed coordination
  * - Useful for single-machine workflow orchestration
  */
-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';
 // Storage paths
-var STORAGE_DIR = '.claude-flow';
-var COORD_DIR = 'coordination';
-var COORD_FILE = 'store.json';
+const STORAGE_DIR = '.claude-flow';
+const COORD_DIR = 'coordination';
+const COORD_FILE = 'store.json';
 function getCoordDir() {
     return join(process.cwd(), STORAGE_DIR, COORD_DIR);
 }
@@ -68,19 +21,19 @@ function getCoordPath() {
     return join(getCoordDir(), COORD_FILE);
 }
 function ensureCoordDir() {
-    var dir = getCoordDir();
+    const dir = getCoordDir();
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true });
     }
 }
 function loadCoordStore() {
     try {
-        var path = getCoordPath();
+        const path = getCoordPath();
         if (existsSync(path)) {
             return JSON.parse(readFileSync(path, 'utf-8'));
         }
     }
-    catch (_a) {
+    catch {
         // Return default store
     }
     return {
@@ -88,28 +41,28 @@ function loadCoordStore() {
             type: 'hierarchical',
             maxNodes: 15,
             redundancy: 2,
-            consensusAlgorithm: 'raft'
+            consensusAlgorithm: 'raft',
         },
         loadBalance: {
             algorithm: 'adaptive',
             weights: {},
-            healthCheck: true
+            healthCheck: true,
         },
         sync: {
             lastSync: new Date().toISOString(),
             syncCount: 0,
             conflicts: 0,
-            pendingChanges: 0
+            pendingChanges: 0,
         },
         nodes: {},
-        version: '3.0.0'
+        version: '3.0.0',
     };
 }
 function saveCoordStore(store) {
     ensureCoordDir();
     writeFileSync(getCoordPath(), JSON.stringify(store, null, 2), 'utf-8');
 }
-export var coordinationTools = [
+export const coordinationTools = [
     {
         name: 'coordination_topology',
         description: 'Configure swarm topology',
@@ -117,69 +70,67 @@ export var coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['get', 'set', 'optimize'], description: 'Action to perform' },
-                type: { type: 'string', "enum": ['mesh', 'hierarchical', 'ring', 'star', 'hybrid', 'hierarchical-mesh'], description: 'Topology type' },
+                action: { type: 'string', enum: ['get', 'set', 'optimize'], description: 'Action to perform' },
+                type: { type: 'string', enum: ['mesh', 'hierarchical', 'ring', 'star', 'hybrid', 'hierarchical-mesh'], description: 'Topology type' },
                 maxNodes: { type: 'number', description: 'Maximum nodes' },
                 redundancy: { type: 'number', description: 'Redundancy level' },
-                consensusAlgorithm: { type: 'string', "enum": ['raft', 'byzantine', 'gossip', 'crdt'], description: 'Consensus algorithm' }
-            }
+                consensusAlgorithm: { type: 'string', enum: ['raft', 'byzantine', 'gossip', 'crdt'], description: 'Consensus algorithm' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, nodeCount, recommended;
-            return __generator(this, function (_a) {
-                store = loadCoordStore();
-                action = input.action || 'get';
-                if (action === 'get') {
-                    return [2 /*return*/, {
-                            success: true,
-                            topology: store.topology,
-                            nodes: Object.keys(store.nodes).length,
-                            status: 'active'
-                        }];
-                }
-                if (action === 'set') {
-                    if (input.type)
-                        store.topology.type = input.type;
-                    if (input.maxNodes)
-                        store.topology.maxNodes = input.maxNodes;
-                    if (input.redundancy)
-                        store.topology.redundancy = input.redundancy;
-                    if (input.consensusAlgorithm)
-                        store.topology.consensusAlgorithm = input.consensusAlgorithm;
-                    saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'updated',
-                            topology: store.topology
-                        }];
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const action = input.action || 'get';
+            if (action === 'get') {
+                return {
+                    success: true,
+                    topology: store.topology,
+                    nodes: Object.keys(store.nodes).length,
+                    status: 'active',
+                };
+            }
+            if (action === 'set') {
+                if (input.type)
+                    store.topology.type = input.type;
+                if (input.maxNodes)
+                    store.topology.maxNodes = input.maxNodes;
+                if (input.redundancy)
+                    store.topology.redundancy = input.redundancy;
+                if (input.consensusAlgorithm)
+                    store.topology.consensusAlgorithm = input.consensusAlgorithm;
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'updated',
+                    topology: store.topology,
+                };
+            }
+            if (action === 'optimize') {
+                // Analyze current state and suggest optimal topology
+                const nodeCount = Object.keys(store.nodes).length;
+                let recommended = 'hierarchical';
+                if (nodeCount <= 5) {
+                    recommended = 'mesh';
                 }
-                if (action === 'optimize') {
-                    nodeCount = Object.keys(store.nodes).length;
+                else if (nodeCount <= 15) {
                     recommended = 'hierarchical';
-                    if (nodeCount <= 5) {
-                        recommended = 'mesh';
-                    }
-                    else if (nodeCount <= 15) {
-                        recommended = 'hierarchical';
-                    }
-                    else {
-                        recommended = 'hybrid';
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'optimize',
-                            current: store.topology.type,
-                            recommended: recommended,
-                            reason: nodeCount <= 5
-                                ? 'Small cluster benefits from full mesh connectivity'
-                                : nodeCount <= 15
-                                    ? 'Medium cluster works well with hierarchical coordination'
-                                    : 'Large cluster needs hybrid approach for scalability'
-                        }];
                 }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
+                else {
+                    recommended = 'hybrid';
+                }
+                return {
+                    success: true,
+                    action: 'optimize',
+                    current: store.topology.type,
+                    recommended,
+                    reason: nodeCount <= 5
+                        ? 'Small cluster benefits from full mesh connectivity'
+                        : nodeCount <= 15
+                            ? 'Medium cluster works well with hierarchical coordination'
+                            : 'Large cluster needs hybrid approach for scalability',
+                };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'coordination_load_balance',
@@ -188,79 +139,77 @@ export var coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['get', 'set', 'distribute'], description: 'Action to perform' },
-                algorithm: { type: 'string', "enum": ['round-robin', 'least-connections', 'weighted', 'adaptive'], description: 'Algorithm' },
+                action: { type: 'string', enum: ['get', 'set', 'distribute'], description: 'Action to perform' },
+                algorithm: { type: 'string', enum: ['round-robin', 'least-connections', 'weighted', 'adaptive'], description: 'Algorithm' },
                 weights: { type: 'object', description: 'Node weights' },
-                task: { type: 'string', description: 'Task to distribute' }
-            }
+                task: { type: 'string', description: 'Task to distribute' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, nodes, avgLoad, task, nodes, selectedNode, algorithm, weights_1;
-            return __generator(this, function (_a) {
-                store = loadCoordStore();
-                action = input.action || 'get';
-                if (action === 'get') {
-                    nodes = Object.values(store.nodes);
-                    avgLoad = nodes.length > 0
-                        ? nodes.reduce(function (sum, n) { return sum + n.load; }, 0) / nodes.length
-                        : 0;
-                    return [2 /*return*/, {
-                            success: true,
-                            loadBalance: store.loadBalance,
-                            metrics: {
-                                nodeCount: nodes.length,
-                                avgLoad: avgLoad,
-                                maxLoad: nodes.length > 0 ? Math.max.apply(Math, nodes.map(function (n) { return n.load; })) : 0,
-                                minLoad: nodes.length > 0 ? Math.min.apply(Math, nodes.map(function (n) { return n.load; })) : 0
-                            }
-                        }];
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const action = input.action || 'get';
+            if (action === 'get') {
+                const nodes = Object.values(store.nodes);
+                const avgLoad = nodes.length > 0
+                    ? nodes.reduce((sum, n) => sum + n.load, 0) / nodes.length
+                    : 0;
+                return {
+                    success: true,
+                    loadBalance: store.loadBalance,
+                    metrics: {
+                        nodeCount: nodes.length,
+                        avgLoad,
+                        maxLoad: nodes.length > 0 ? Math.max(...nodes.map(n => n.load)) : 0,
+                        minLoad: nodes.length > 0 ? Math.min(...nodes.map(n => n.load)) : 0,
+                    },
+                };
+            }
+            if (action === 'set') {
+                if (input.algorithm)
+                    store.loadBalance.algorithm = input.algorithm;
+                if (input.weights)
+                    store.loadBalance.weights = input.weights;
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'updated',
+                    loadBalance: store.loadBalance,
+                };
+            }
+            if (action === 'distribute') {
+                const task = input.task;
+                const nodes = Object.values(store.nodes).filter(n => n.status === 'active');
+                if (nodes.length === 0) {
+                    return { success: false, error: 'No active nodes available' };
                 }
-                if (action === 'set') {
-                    if (input.algorithm)
-                        store.loadBalance.algorithm = input.algorithm;
-                    if (input.weights)
-                        store.loadBalance.weights = input.weights;
-                    saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'updated',
-                            loadBalance: store.loadBalance
-                        }];
+                // Select node based on algorithm
+                let selectedNode;
+                const algorithm = store.loadBalance.algorithm;
+                if (algorithm === 'least-connections' || algorithm === 'adaptive') {
+                    selectedNode = nodes.reduce((min, n) => n.load < min.load ? n : min);
                 }
-                if (action === 'distribute') {
-                    task = input.task;
-                    nodes = Object.values(store.nodes).filter(function (n) { return n.status === 'active'; });
-                    if (nodes.length === 0) {
-                        return [2 /*return*/, { success: false, error: 'No active nodes available' }];
-                    }
-                    selectedNode = void 0;
-                    algorithm = store.loadBalance.algorithm;
-                    if (algorithm === 'least-connections' || algorithm === 'adaptive') {
-                        selectedNode = nodes.reduce(function (min, n) { return n.load < min.load ? n : min; });
-                    }
-                    else if (algorithm === 'weighted') {
-                        weights_1 = store.loadBalance.weights;
-                        selectedNode = nodes.reduce(function (max, n) { return (weights_1[n.id] || 1) > (weights_1[max.id] || 1) ? n : max; });
-                    }
-                    else {
-                        // Round robin - just pick first active
-                        selectedNode = nodes[0];
-                    }
-                    // Update load
-                    selectedNode.load += 1;
-                    saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'distributed',
-                            task: task,
-                            assignedTo: selectedNode.id,
-                            algorithm: algorithm,
-                            nodeLoad: selectedNode.load
-                        }];
+                else if (algorithm === 'weighted') {
+                    const weights = store.loadBalance.weights;
+                    selectedNode = nodes.reduce((max, n) => (weights[n.id] || 1) > (weights[max.id] || 1) ? n : max);
                 }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
+                else {
+                    // Round robin - just pick first active
+                    selectedNode = nodes[0];
+                }
+                // Update load
+                selectedNode.load += 1;
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'distributed',
+                    task,
+                    assignedTo: selectedNode.id,
+                    algorithm,
+                    nodeLoad: selectedNode.load,
+                };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'coordination_sync',
@@ -269,68 +218,59 @@ export var coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['status', 'trigger', 'resolve'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['status', 'trigger', 'resolve'], description: 'Action to perform' },
                 force: { type: 'boolean', description: 'Force synchronization' },
-                conflictResolution: { type: 'string', "enum": ['latest', 'merge', 'manual'], description: 'Conflict resolution strategy' }
-            }
+                conflictResolution: { type: 'string', enum: ['latest', 'merge', 'manual'], description: 'Conflict resolution strategy' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, timeSinceSync, strategy, resolved;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        store = loadCoordStore();
-                        action = input.action || 'status';
-                        if (action === 'status') {
-                            timeSinceSync = Date.now() - new Date(store.sync.lastSync).getTime();
-                            return [2 /*return*/, {
-                                    success: true,
-                                    sync: store.sync,
-                                    timeSinceSync: Math.floor(timeSinceSync / 1000) + "s",
-                                    status: store.sync.conflicts > 0 ? 'conflicts' : store.sync.pendingChanges > 0 ? 'pending' : 'synced'
-                                }];
-                        }
-                        if (!(action === 'trigger')) return [3 /*break*/, 2];
-                        store.sync.syncCount++;
-                        store.sync.lastSync = new Date().toISOString();
-                        store.sync.pendingChanges = 0;
-                        // Simulate sync
-                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 50); })];
-                    case 1:
-                        // Simulate sync
-                        _a.sent();
-                        saveCoordStore(store);
-                        return [2 /*return*/, {
-                                success: true,
-                                action: 'synchronized',
-                                syncCount: store.sync.syncCount,
-                                syncedAt: store.sync.lastSync,
-                                nodesSync: Object.keys(store.nodes).length
-                            }];
-                    case 2:
-                        if (action === 'resolve') {
-                            strategy = input.conflictResolution || 'latest';
-                            if (store.sync.conflicts > 0) {
-                                resolved = store.sync.conflicts;
-                                store.sync.conflicts = 0;
-                                saveCoordStore(store);
-                                return [2 /*return*/, {
-                                        success: true,
-                                        action: 'resolved',
-                                        strategy: strategy,
-                                        conflictsResolved: resolved
-                                    }];
-                            }
-                            return [2 /*return*/, {
-                                    success: true,
-                                    action: 'resolve',
-                                    message: 'No conflicts to resolve'
-                                }];
-                        }
-                        return [2 /*return*/, { success: false, error: 'Unknown action' }];
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const action = input.action || 'status';
+            if (action === 'status') {
+                const timeSinceSync = Date.now() - new Date(store.sync.lastSync).getTime();
+                return {
+                    success: true,
+                    sync: store.sync,
+                    timeSinceSync: `${Math.floor(timeSinceSync / 1000)}s`,
+                    status: store.sync.conflicts > 0 ? 'conflicts' : store.sync.pendingChanges > 0 ? 'pending' : 'synced',
+                };
+            }
+            if (action === 'trigger') {
+                store.sync.syncCount++;
+                store.sync.lastSync = new Date().toISOString();
+                store.sync.pendingChanges = 0;
+                // Simulate sync
+                await new Promise(resolve => setTimeout(resolve, 50));
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'synchronized',
+                    syncCount: store.sync.syncCount,
+                    syncedAt: store.sync.lastSync,
+                    nodesSync: Object.keys(store.nodes).length,
+                };
+            }
+            if (action === 'resolve') {
+                const strategy = input.conflictResolution || 'latest';
+                if (store.sync.conflicts > 0) {
+                    const resolved = store.sync.conflicts;
+                    store.sync.conflicts = 0;
+                    saveCoordStore(store);
+                    return {
+                        success: true,
+                        action: 'resolved',
+                        strategy,
+                        conflictsResolved: resolved,
+                    };
                 }
-            });
-        }); }
+                return {
+                    success: true,
+                    action: 'resolve',
+                    message: 'No conflicts to resolve',
+                };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'coordination_node',
@@ -339,77 +279,74 @@ export var coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['list', 'add', 'remove', 'heartbeat'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['list', 'add', 'remove', 'heartbeat'], description: 'Action to perform' },
                 nodeId: { type: 'string', description: 'Node ID' },
-                status: { type: 'string', description: 'Node status' }
-            }
+                status: { type: 'string', description: 'Node status' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, action, nodes, nodeId, nodeId, nodeId;
-            return __generator(this, function (_a) {
-                store = loadCoordStore();
-                action = input.action || 'list';
-                if (action === 'list') {
-                    nodes = Object.values(store.nodes);
-                    return [2 /*return*/, {
-                            success: true,
-                            nodes: nodes.map(function (n) { return ({
-                                id: n.id,
-                                status: n.status,
-                                load: n.load,
-                                lastHeartbeat: n.lastHeartbeat
-                            }); }),
-                            total: nodes.length,
-                            active: nodes.filter(function (n) { return n.status === 'active'; }).length
-                        }];
-                }
-                if (action === 'add') {
-                    nodeId = input.nodeId || "node-" + Date.now();
-                    store.nodes[nodeId] = {
-                        id: nodeId,
-                        status: 'active',
-                        load: 0,
-                        lastHeartbeat: new Date().toISOString()
-                    };
-                    saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'added',
-                            nodeId: nodeId,
-                            totalNodes: Object.keys(store.nodes).length
-                        }];
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const action = input.action || 'list';
+            if (action === 'list') {
+                const nodes = Object.values(store.nodes);
+                return {
+                    success: true,
+                    nodes: nodes.map(n => ({
+                        id: n.id,
+                        status: n.status,
+                        load: n.load,
+                        lastHeartbeat: n.lastHeartbeat,
+                    })),
+                    total: nodes.length,
+                    active: nodes.filter(n => n.status === 'active').length,
+                };
+            }
+            if (action === 'add') {
+                const nodeId = input.nodeId || `node-${Date.now()}`;
+                store.nodes[nodeId] = {
+                    id: nodeId,
+                    status: 'active',
+                    load: 0,
+                    lastHeartbeat: new Date().toISOString(),
+                };
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'added',
+                    nodeId,
+                    totalNodes: Object.keys(store.nodes).length,
+                };
+            }
+            if (action === 'remove') {
+                const nodeId = input.nodeId;
+                if (!store.nodes[nodeId]) {
+                    return { success: false, error: 'Node not found' };
                 }
-                if (action === 'remove') {
-                    nodeId = input.nodeId;
-                    if (!store.nodes[nodeId]) {
-                        return [2 /*return*/, { success: false, error: 'Node not found' }];
-                    }
-                    delete store.nodes[nodeId];
+                delete store.nodes[nodeId];
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'removed',
+                    nodeId,
+                    totalNodes: Object.keys(store.nodes).length,
+                };
+            }
+            if (action === 'heartbeat') {
+                const nodeId = input.nodeId;
+                if (store.nodes[nodeId]) {
+                    store.nodes[nodeId].lastHeartbeat = new Date().toISOString();
+                    store.nodes[nodeId].status = 'active';
                     saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'removed',
-                            nodeId: nodeId,
-                            totalNodes: Object.keys(store.nodes).length
-                        }];
-                }
-                if (action === 'heartbeat') {
-                    nodeId = input.nodeId;
-                    if (store.nodes[nodeId]) {
-                        store.nodes[nodeId].lastHeartbeat = new Date().toISOString();
-                        store.nodes[nodeId].status = 'active';
-                        saveCoordStore(store);
-                    }
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'heartbeat',
-                            nodeId: nodeId,
-                            timestamp: new Date().toISOString()
-                        }];
                 }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
+                return {
+                    success: true,
+                    action: 'heartbeat',
+                    nodeId,
+                    timestamp: new Date().toISOString(),
+                };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'coordination_consensus',
@@ -418,17 +355,26 @@ export var coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                action: { type: 'string', "enum": ['status', 'propose', 'vote', 'commit'], description: 'Action to perform' },
+                action: { type: 'string', enum: ['status', 'propose', 'vote', 'commit'], description: 'Action to perform' },
                 proposal: { type: 'object', description: 'Proposal data (for propose)' },
                 proposalId: { type: 'string', description: 'Proposal ID (for vote/commit/status)' },
-                vote: { type: 'string', "enum": ['accept', 'reject'], description: 'Vote' },
+                vote: { type: 'string', enum: ['accept', 'reject'], description: 'Vote' },
                 voterId: { type: 'string', description: 'Voter node ID' },
-                strategy: { type: 'string', "enum": ['bft', 'raft', 'quorum'], description: 'Consensus strategy (default: raft)' },
-                quorumPreset: { type: 'string', "enum": ['unanimous', 'majority', 'supermajority'], description: 'Quorum threshold preset (default: majority)' },
-                term: { type: 'number', description: 'Term number (for raft strategy)' }
-            }
+                strategy: { type: 'string', enum: ['bft', 'raft', 'quorum'], description: 'Consensus strategy (default: raft)' },
+                quorumPreset: { type: 'string', enum: ['unanimous', 'majority', 'supermajority'], description: 'Quorum threshold preset (default: majority)' },
+                term: { type: 'number', description: 'Term number (for raft strategy)' },
+            },
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const action = input.action || 'status';
+            const strategy = input.strategy || 'raft';
+            const nodeCount = Object.keys(store.nodes).length || 1;
+            // Initialize consensus storage in the coordination store if missing
+            if (!store.consensus) {
+                store.consensus = { pending: [], history: [] };
+            }
+            const consensus = store.consensus;
             function calcRequired(strat, total, preset) {
                 if (total <= 0)
                     return 1;
@@ -442,211 +388,199 @@ export var coordinationTools = [
                 }
                 return Math.floor(total / 2) + 1;
             }
-            var store, action, strategy, nodeCount, consensus, p, votesFor, votesAgainst, h, quorum, proposalId, quorumPreset, term_1, required, existing, p_1, voterId, voteValue, pStrategy, required, _i, _a, other, votesFor, votesAgainst, resolved, result, h;
-            var _b;
-            return __generator(this, function (_c) {
-                store = loadCoordStore();
-                action = input.action || 'status';
-                strategy = input.strategy || 'raft';
-                nodeCount = Object.keys(store.nodes).length || 1;
-                // Initialize consensus storage in the coordination store if missing
-                if (!store.consensus) {
-                    store.consensus = { pending: [], history: [] };
+            if (action === 'status') {
+                if (input.proposalId) {
+                    // Status for specific proposal
+                    const p = consensus.pending.find(x => x.proposalId === input.proposalId);
+                    if (p) {
+                        const votesFor = Object.values(p.votes).filter(v => v).length;
+                        const votesAgainst = Object.values(p.votes).filter(v => !v).length;
+                        return {
+                            success: true,
+                            proposalId: p.proposalId,
+                            strategy: p.strategy,
+                            status: p.status,
+                            votesFor,
+                            votesAgainst,
+                            required: calcRequired(p.strategy, nodeCount, p.quorumPreset),
+                            totalNodes: nodeCount,
+                            resolved: false,
+                        };
+                    }
+                    const h = consensus.history.find(x => x.proposalId === input.proposalId);
+                    if (h)
+                        return { success: true, ...h, resolved: true, historical: true };
+                    return { success: false, error: 'Proposal not found' };
                 }
-                consensus = store.consensus;
-                if (action === 'status') {
-                    if (input.proposalId) {
-                        p = consensus.pending.find(function (x) { return x.proposalId === input.proposalId; });
-                        if (p) {
-                            votesFor = Object.values(p.votes).filter(function (v) { return v; }).length;
-                            votesAgainst = Object.values(p.votes).filter(function (v) { return !v; }).length;
-                            return [2 /*return*/, {
-                                    success: true,
-                                    proposalId: p.proposalId,
-                                    strategy: p.strategy,
-                                    status: p.status,
-                                    votesFor: votesFor,
-                                    votesAgainst: votesAgainst,
-                                    required: calcRequired(p.strategy, nodeCount, p.quorumPreset),
-                                    totalNodes: nodeCount,
-                                    resolved: false
-                                }];
-                        }
-                        h = consensus.history.find(function (x) { return x.proposalId === input.proposalId; });
-                        if (h)
-                            return [2 /*return*/, __assign(__assign({ success: true }, h), { resolved: true, historical: true })];
-                        return [2 /*return*/, { success: false, error: 'Proposal not found' }];
+                const quorum = calcRequired(strategy, nodeCount);
+                return {
+                    success: true,
+                    algorithm: store.topology.consensusAlgorithm,
+                    strategy,
+                    nodes: nodeCount,
+                    quorum,
+                    pendingProposals: consensus.pending.length,
+                    resolvedProposals: consensus.history.length,
+                    status: nodeCount >= quorum ? 'operational' : 'degraded',
+                };
+            }
+            if (action === 'propose') {
+                const proposalId = `proposal-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const quorumPreset = input.quorumPreset || 'majority';
+                const term = input.term || 1;
+                const required = calcRequired(strategy, nodeCount, quorumPreset);
+                // Raft: one pending proposal per term
+                if (strategy === 'raft') {
+                    const existing = consensus.pending.find(p => p.strategy === 'raft' && p.term === term);
+                    if (existing) {
+                        return {
+                            success: false,
+                            error: `Raft term ${term} already has pending proposal: ${existing.proposalId}`,
+                            existingProposalId: existing.proposalId,
+                        };
                     }
-                    quorum = calcRequired(strategy, nodeCount);
-                    return [2 /*return*/, {
-                            success: true,
-                            algorithm: store.topology.consensusAlgorithm,
-                            strategy: strategy,
-                            nodes: nodeCount,
-                            quorum: quorum,
-                            pendingProposals: consensus.pending.length,
-                            resolvedProposals: consensus.history.length,
-                            status: nodeCount >= quorum ? 'operational' : 'degraded'
-                        }];
                 }
-                if (action === 'propose') {
-                    proposalId = "proposal-" + Date.now() + "-" + Math.random().toString(36).slice(2, 8);
-                    quorumPreset = input.quorumPreset || 'majority';
-                    term_1 = input.term || 1;
-                    required = calcRequired(strategy, nodeCount, quorumPreset);
-                    // Raft: one pending proposal per term
-                    if (strategy === 'raft') {
-                        existing = consensus.pending.find(function (p) { return p.strategy === 'raft' && p.term === term_1; });
-                        if (existing) {
-                            return [2 /*return*/, {
-                                    success: false,
-                                    error: "Raft term " + term_1 + " already has pending proposal: " + existing.proposalId,
-                                    existingProposalId: existing.proposalId
-                                }];
-                        }
+                consensus.pending.push({
+                    proposalId,
+                    type: 'coordination',
+                    proposal: input.proposal,
+                    proposedBy: input.voterId || 'system',
+                    proposedAt: new Date().toISOString(),
+                    votes: {},
+                    status: 'pending',
+                    strategy,
+                    term: strategy === 'raft' ? term : undefined,
+                    quorumPreset: strategy === 'quorum' ? quorumPreset : undefined,
+                    byzantineVoters: strategy === 'bft' ? [] : undefined,
+                });
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'proposed',
+                    proposalId,
+                    proposal: input.proposal,
+                    strategy,
+                    status: 'pending',
+                    required,
+                    totalNodes: nodeCount,
+                    term: strategy === 'raft' ? term : undefined,
+                };
+            }
+            if (action === 'vote') {
+                const p = consensus.pending.find(x => x.proposalId === input.proposalId);
+                if (!p)
+                    return { success: false, error: 'Proposal not found or already resolved' };
+                const voterId = input.voterId;
+                if (!voterId)
+                    return { success: false, error: 'voterId is required' };
+                const voteValue = input.vote === 'accept';
+                const pStrategy = p.strategy || 'raft';
+                const required = calcRequired(pStrategy, nodeCount, p.quorumPreset);
+                // Double-vote prevention
+                if (voterId in p.votes) {
+                    if (pStrategy === 'bft' && p.votes[voterId] !== voteValue) {
+                        if (!p.byzantineVoters)
+                            p.byzantineVoters = [];
+                        if (!p.byzantineVoters.includes(voterId))
+                            p.byzantineVoters.push(voterId);
+                        delete p.votes[voterId];
+                        saveCoordStore(store);
+                        return {
+                            success: false,
+                            byzantineDetected: true,
+                            message: `Byzantine behavior: voter ${voterId} attempted conflicting vote. Vote invalidated.`,
+                            byzantineVoters: p.byzantineVoters,
+                        };
                     }
-                    consensus.pending.push({
-                        proposalId: proposalId,
-                        type: 'coordination',
-                        proposal: input.proposal,
-                        proposedBy: input.voterId || 'system',
-                        proposedAt: new Date().toISOString(),
-                        votes: {},
-                        status: 'pending',
-                        strategy: strategy,
-                        term: strategy === 'raft' ? term_1 : undefined,
-                        quorumPreset: strategy === 'quorum' ? quorumPreset : undefined,
-                        byzantineVoters: strategy === 'bft' ? [] : undefined
-                    });
-                    saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'proposed',
-                            proposalId: proposalId,
-                            proposal: input.proposal,
-                            strategy: strategy,
-                            status: 'pending',
-                            required: required,
-                            totalNodes: nodeCount,
-                            term: strategy === 'raft' ? term_1 : undefined
-                        }];
+                    return { success: false, error: `Voter ${voterId} has already voted on this proposal` };
                 }
-                if (action === 'vote') {
-                    p_1 = consensus.pending.find(function (x) { return x.proposalId === input.proposalId; });
-                    if (!p_1)
-                        return [2 /*return*/, { success: false, error: 'Proposal not found or already resolved' }];
-                    voterId = input.voterId;
-                    if (!voterId)
-                        return [2 /*return*/, { success: false, error: 'voterId is required' }];
-                    voteValue = input.vote === 'accept';
-                    pStrategy = p_1.strategy || 'raft';
-                    required = calcRequired(pStrategy, nodeCount, p_1.quorumPreset);
-                    // Double-vote prevention
-                    if (voterId in p_1.votes) {
-                        if (pStrategy === 'bft' && p_1.votes[voterId] !== voteValue) {
-                            if (!p_1.byzantineVoters)
-                                p_1.byzantineVoters = [];
-                            if (!p_1.byzantineVoters.includes(voterId))
-                                p_1.byzantineVoters.push(voterId);
-                            delete p_1.votes[voterId];
+                // BFT cross-proposal conflict check
+                if (pStrategy === 'bft') {
+                    for (const other of consensus.pending) {
+                        if (other.proposalId === p.proposalId)
+                            continue;
+                        if (voterId in other.votes && other.votes[voterId] !== voteValue) {
+                            if (!p.byzantineVoters)
+                                p.byzantineVoters = [];
+                            if (!p.byzantineVoters.includes(voterId))
+                                p.byzantineVoters.push(voterId);
                             saveCoordStore(store);
-                            return [2 /*return*/, {
-                                    success: false,
-                                    byzantineDetected: true,
-                                    message: "Byzantine behavior: voter " + voterId + " attempted conflicting vote. Vote invalidated.",
-                                    byzantineVoters: p_1.byzantineVoters
-                                }];
-                        }
-                        return [2 /*return*/, { success: false, error: "Voter " + voterId + " has already voted on this proposal" }];
-                    }
-                    // BFT cross-proposal conflict check
-                    if (pStrategy === 'bft') {
-                        for (_i = 0, _a = consensus.pending; _i < _a.length; _i++) {
-                            other = _a[_i];
-                            if (other.proposalId === p_1.proposalId)
-                                continue;
-                            if (voterId in other.votes && other.votes[voterId] !== voteValue) {
-                                if (!p_1.byzantineVoters)
-                                    p_1.byzantineVoters = [];
-                                if (!p_1.byzantineVoters.includes(voterId))
-                                    p_1.byzantineVoters.push(voterId);
-                                saveCoordStore(store);
-                                return [2 /*return*/, {
-                                        success: false,
-                                        byzantineDetected: true,
-                                        message: "Byzantine behavior: voter " + voterId + " cast conflicting votes across proposals.",
-                                        byzantineVoters: p_1.byzantineVoters
-                                    }];
-                            }
+                            return {
+                                success: false,
+                                byzantineDetected: true,
+                                message: `Byzantine behavior: voter ${voterId} cast conflicting votes across proposals.`,
+                                byzantineVoters: p.byzantineVoters,
+                            };
                         }
                     }
-                    p_1.votes[voterId] = voteValue;
-                    votesFor = Object.values(p_1.votes).filter(function (v) { return v; }).length;
-                    votesAgainst = Object.values(p_1.votes).filter(function (v) { return !v; }).length;
-                    resolved = false;
-                    result = void 0;
-                    if (votesFor >= required) {
-                        resolved = true;
-                        result = 'approved';
-                    }
-                    else if (votesAgainst >= required) {
-                        resolved = true;
-                        result = 'rejected';
-                    }
-                    else if (pStrategy === 'quorum' && p_1.quorumPreset === 'unanimous' && votesAgainst > 0) {
-                        resolved = true;
-                        result = 'rejected';
-                    }
-                    if (resolved && result) {
-                        p_1.status = result;
-                        consensus.history.push({
-                            proposalId: p_1.proposalId,
-                            result: result,
-                            votes: { "for": votesFor, against: votesAgainst },
-                            decidedAt: new Date().toISOString(),
-                            strategy: pStrategy,
-                            term: p_1.term,
-                            byzantineDetected: ((_b = p_1.byzantineVoters) === null || _b === void 0 ? void 0 : _b.length) ? p_1.byzantineVoters : undefined
-                        });
-                        consensus.pending = consensus.pending.filter(function (x) { return x.proposalId !== p_1.proposalId; });
-                    }
-                    saveCoordStore(store);
-                    return [2 /*return*/, {
-                            success: true,
-                            action: 'voted',
-                            proposalId: p_1.proposalId,
-                            voterId: voterId,
-                            vote: input.vote,
-                            strategy: pStrategy,
-                            votesFor: votesFor,
-                            votesAgainst: votesAgainst,
-                            required: required,
-                            totalNodes: nodeCount,
-                            resolved: resolved,
-                            result: resolved ? result : undefined,
-                            status: p_1.status
-                        }];
                 }
-                if (action === 'commit') {
-                    // Commit is a no-op confirmation for already-resolved proposals
-                    if (input.proposalId) {
-                        h = consensus.history.find(function (x) { return x.proposalId === input.proposalId; });
-                        if (h) {
-                            return [2 /*return*/, {
-                                    success: true,
-                                    action: 'committed',
-                                    proposalId: input.proposalId,
-                                    result: h.result,
-                                    committedAt: new Date().toISOString()
-                                }];
-                        }
-                        return [2 /*return*/, { success: false, error: 'Proposal not found in resolved history. Vote must reach quorum first.' }];
+                p.votes[voterId] = voteValue;
+                const votesFor = Object.values(p.votes).filter(v => v).length;
+                const votesAgainst = Object.values(p.votes).filter(v => !v).length;
+                // Resolution check
+                let resolved = false;
+                let result;
+                if (votesFor >= required) {
+                    resolved = true;
+                    result = 'approved';
+                }
+                else if (votesAgainst >= required) {
+                    resolved = true;
+                    result = 'rejected';
+                }
+                else if (pStrategy === 'quorum' && p.quorumPreset === 'unanimous' && votesAgainst > 0) {
+                    resolved = true;
+                    result = 'rejected';
+                }
+                if (resolved && result) {
+                    p.status = result;
+                    consensus.history.push({
+                        proposalId: p.proposalId,
+                        result,
+                        votes: { for: votesFor, against: votesAgainst },
+                        decidedAt: new Date().toISOString(),
+                        strategy: pStrategy,
+                        term: p.term,
+                        byzantineDetected: p.byzantineVoters?.length ? p.byzantineVoters : undefined,
+                    });
+                    consensus.pending = consensus.pending.filter(x => x.proposalId !== p.proposalId);
+                }
+                saveCoordStore(store);
+                return {
+                    success: true,
+                    action: 'voted',
+                    proposalId: p.proposalId,
+                    voterId,
+                    vote: input.vote,
+                    strategy: pStrategy,
+                    votesFor,
+                    votesAgainst,
+                    required,
+                    totalNodes: nodeCount,
+                    resolved,
+                    result: resolved ? result : undefined,
+                    status: p.status,
+                };
+            }
+            if (action === 'commit') {
+                // Commit is a no-op confirmation for already-resolved proposals
+                if (input.proposalId) {
+                    const h = consensus.history.find(x => x.proposalId === input.proposalId);
+                    if (h) {
+                        return {
+                            success: true,
+                            action: 'committed',
+                            proposalId: input.proposalId,
+                            result: h.result,
+                            committedAt: new Date().toISOString(),
+                        };
                     }
-                    return [2 /*return*/, { success: false, error: 'proposalId is required for commit' }];
+                    return { success: false, error: 'Proposal not found in resolved history. Vote must reach quorum first.' };
                 }
-                return [2 /*return*/, { success: false, error: 'Unknown action' }];
-            });
-        }); }
+                return { success: false, error: 'proposalId is required for commit' };
+            }
+            return { success: false, error: 'Unknown action' };
+        },
     },
     {
         name: 'coordination_orchestrate',
@@ -657,31 +591,28 @@ export var coordinationTools = [
             properties: {
                 task: { type: 'string', description: 'Task to orchestrate' },
                 agents: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to coordinate' },
-                strategy: { type: 'string', "enum": ['parallel', 'sequential', 'pipeline', 'broadcast'], description: 'Orchestration strategy' },
-                timeout: { type: 'number', description: 'Timeout in ms' }
+                strategy: { type: 'string', enum: ['parallel', 'sequential', 'pipeline', 'broadcast'], description: 'Orchestration strategy' },
+                timeout: { type: 'number', description: 'Timeout in ms' },
             },
-            required: ['task']
+            required: ['task'],
+        },
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const task = input.task;
+            const agents = input.agents || Object.keys(store.nodes);
+            const strategy = input.strategy || 'parallel';
+            const orchestrationId = `orch-${Date.now()}`;
+            return {
+                success: true,
+                orchestrationId,
+                task,
+                strategy,
+                agents,
+                status: 'initiated',
+                topology: store.topology.type,
+                estimatedCompletion: `${agents.length * (strategy === 'sequential' ? 100 : 50)}ms`,
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, task, agents, strategy, orchestrationId;
-            return __generator(this, function (_a) {
-                store = loadCoordStore();
-                task = input.task;
-                agents = input.agents || Object.keys(store.nodes);
-                strategy = input.strategy || 'parallel';
-                orchestrationId = "orch-" + Date.now();
-                return [2 /*return*/, {
-                        success: true,
-                        orchestrationId: orchestrationId,
-                        task: task,
-                        strategy: strategy,
-                        agents: agents,
-                        status: 'initiated',
-                        topology: store.topology.type,
-                        estimatedCompletion: agents.length * (strategy === 'sequential' ? 100 : 50) + "ms"
-                    }];
-            });
-        }); }
     },
     {
         name: 'coordination_metrics',
@@ -690,48 +621,45 @@ export var coordinationTools = [
         inputSchema: {
             type: 'object',
             properties: {
-                metric: { type: 'string', "enum": ['all', 'latency', 'throughput', 'availability'], description: 'Metric type' },
-                timeRange: { type: 'string', description: 'Time range' }
+                metric: { type: 'string', enum: ['all', 'latency', 'throughput', 'availability'], description: 'Metric type' },
+                timeRange: { type: 'string', description: 'Time range' },
+            },
+        },
+        handler: async (input) => {
+            const store = loadCoordStore();
+            const metric = input.metric || 'all';
+            const nodes = Object.values(store.nodes);
+            const activeNodes = nodes.filter(n => n.status === 'active');
+            const metrics = {
+                latency: {
+                    avg: 25 + Math.random() * 20,
+                    p50: 20 + Math.random() * 15,
+                    p95: 50 + Math.random() * 30,
+                    p99: 100 + Math.random() * 50,
+                    unit: 'ms',
+                },
+                throughput: {
+                    current: Math.floor(Math.random() * 1000) + 500,
+                    peak: Math.floor(Math.random() * 2000) + 1000,
+                    avg: Math.floor(Math.random() * 800) + 400,
+                    unit: 'ops/s',
+                },
+                availability: {
+                    uptime: 99.9 + Math.random() * 0.09,
+                    activeNodes: activeNodes.length,
+                    totalNodes: nodes.length,
+                    syncStatus: store.sync.conflicts === 0 ? 'healthy' : 'conflicts',
+                },
+            };
+            if (metric === 'all') {
+                return { success: true, metrics };
             }
+            return {
+                success: true,
+                metric,
+                data: metrics[metric],
+            };
         },
-        handler: function (input) { return __awaiter(void 0, void 0, void 0, function () {
-            var store, metric, nodes, activeNodes, metrics;
-            return __generator(this, function (_a) {
-                store = loadCoordStore();
-                metric = input.metric || 'all';
-                nodes = Object.values(store.nodes);
-                activeNodes = nodes.filter(function (n) { return n.status === 'active'; });
-                metrics = {
-                    latency: {
-                        avg: 25 + Math.random() * 20,
-                        p50: 20 + Math.random() * 15,
-                        p95: 50 + Math.random() * 30,
-                        p99: 100 + Math.random() * 50,
-                        unit: 'ms'
-                    },
-                    throughput: {
-                        current: Math.floor(Math.random() * 1000) + 500,
-                        peak: Math.floor(Math.random() * 2000) + 1000,
-                        avg: Math.floor(Math.random() * 800) + 400,
-                        unit: 'ops/s'
-                    },
-                    availability: {
-                        uptime: 99.9 + Math.random() * 0.09,
-                        activeNodes: activeNodes.length,
-                        totalNodes: nodes.length,
-                        syncStatus: store.sync.conflicts === 0 ? 'healthy' : 'conflicts'
-                    }
-                };
-                if (metric === 'all') {
-                    return [2 /*return*/, { success: true, metrics: metrics }];
-                }
-                return [2 /*return*/, {
-                        success: true,
-                        metric: metric,
-                        data: metrics[metric]
-                    }];
-            });
-        }); }
     },
 ];
 //# sourceMappingURL=coordination-tools.js.map