kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/swarm.js

@@ -2,6 +2,42 @@
  * V3 CLI Swarm Command
  * Swarm coordination and management commands
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { select, confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
@@ -9,81 +45,85 @@ import * as fs from 'fs';
 import * as path from 'path';
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
-    const swarmDir = path.join(process.cwd(), '.swarm');
-    const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
-    const memoryPaths = [
+    var _a, _b, _c, _d;
+    var swarmDir = path.join(process.cwd(), '.swarm');
+    var sessionDir = path.join(process.cwd(), '.claude', 'sessions');
+    var memoryPaths = [
         path.join(process.cwd(), '.swarm', 'memory.db'),
         path.join(process.cwd(), '.claude', 'memory.db'),
     ];
     // Check for active swarm state file
-    const swarmStateFile = path.join(swarmDir, 'state.json');
-    let swarmState = null;
+    var swarmStateFile = path.join(swarmDir, 'state.json');
+    var swarmState = null;
     if (fs.existsSync(swarmStateFile)) {
         try {
             swarmState = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
         }
-        catch {
+        catch (_e) {
             // Ignore parse errors
         }
     }
     // Count active agents from process files
-    let activeAgents = 0;
-    let totalAgents = 0;
-    const agentsDir = path.join(swarmDir, 'agents');
+    var activeAgents = 0;
+    var totalAgents = 0;
+    var agentsDir = path.join(swarmDir, 'agents');
     if (fs.existsSync(agentsDir)) {
         try {
-            const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'));
+            var agentFiles = fs.readdirSync(agentsDir).filter(function (f) { return f.endsWith('.json'); });
             totalAgents = agentFiles.length;
-            for (const file of agentFiles) {
+            for (var _i = 0, agentFiles_1 = agentFiles; _i < agentFiles_1.length; _i++) {
+                var file = agentFiles_1[_i];
                 try {
-                    const agent = JSON.parse(fs.readFileSync(path.join(agentsDir, file), 'utf-8'));
+                    var agent = JSON.parse(fs.readFileSync(path.join(agentsDir, file), 'utf-8'));
                     if (agent.status === 'active' || agent.status === 'running') {
                         activeAgents++;
                     }
                 }
-                catch {
+                catch (_f) {
                     // Ignore
                 }
             }
         }
-        catch {
+        catch (_g) {
             // Ignore
         }
     }
     // Get session count
-    let sessionCount = 0;
+    var sessionCount = 0;
     if (fs.existsSync(sessionDir)) {
         try {
-            sessionCount = fs.readdirSync(sessionDir).filter(f => f.endsWith('.json')).length;
+            sessionCount = fs.readdirSync(sessionDir).filter(function (f) { return f.endsWith('.json'); }).length;
         }
-        catch {
+        catch (_h) {
             // Ignore
         }
     }
     // Get memory size as rough indicator of activity
-    let memorySize = 0;
-    for (const dbPath of memoryPaths) {
+    var memorySize = 0;
+    for (var _j = 0, memoryPaths_1 = memoryPaths; _j < memoryPaths_1.length; _j++) {
+        var dbPath = memoryPaths_1[_j];
         if (fs.existsSync(dbPath)) {
             try {
                 memorySize = fs.statSync(dbPath).size;
                 break;
             }
-            catch {
+            catch (_k) {
                 // Ignore
             }
         }
     }
     // Count task files if they exist
-    let completedTasks = 0;
-    let inProgressTasks = 0;
-    let pendingTasks = 0;
-    const tasksDir = path.join(swarmDir, 'tasks');
+    var completedTasks = 0;
+    var inProgressTasks = 0;
+    var pendingTasks = 0;
+    var tasksDir = path.join(swarmDir, 'tasks');
     if (fs.existsSync(tasksDir)) {
         try {
-            const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
-            for (const file of taskFiles) {
+            var taskFiles = fs.readdirSync(tasksDir).filter(function (f) { return f.endsWith('.json'); });
+            for (var _l = 0, taskFiles_1 = taskFiles; _l < taskFiles_1.length; _l++) {
+                var file = taskFiles_1[_l];
                 try {
-                    const task = JSON.parse(fs.readFileSync(path.join(tasksDir, file), 'utf-8'));
+                    var task = JSON.parse(fs.readFileSync(path.join(tasksDir, file), 'utf-8'));
                     if (task.status === 'completed' || task.status === 'done') {
                         completedTasks++;
                     }
@@ -94,19 +134,19 @@ function getSwarmStatus(swarmId) {
                         pendingTasks++;
                     }
                 }
-                catch {
+                catch (_m) {
                     // Ignore
                 }
             }
         }
-        catch {
+        catch (_o) {
             // Ignore
         }
     }
     // Calculate dynamic progress based on actual state
     // If no swarm state, show 0%. Otherwise calculate from completed tasks
-    const totalTasks = completedTasks + inProgressTasks + pendingTasks;
-    let progress = 0;
+    var totalTasks = completedTasks + inProgressTasks + pendingTasks;
+    var progress = 0;
     if (totalTasks > 0) {
         progress = Math.round((completedTasks / totalTasks) * 100);
     }
@@ -115,7 +155,7 @@ function getSwarmStatus(swarmId) {
         progress = 5;
     }
     // Determine status
-    let status = 'idle';
+    var status = 'idle';
     if (inProgressTasks > 0 || activeAgents > 0) {
         status = 'running';
     }
@@ -126,18 +166,18 @@ function getSwarmStatus(swarmId) {
         status = 'ready';
     }
     return {
-        id: swarmId || swarmState?.id || 'no-active-swarm',
-        topology: swarmState?.topology || 'none',
-        status,
-        objective: swarmState?.objective || 'No active objective',
-        strategy: swarmState?.strategy || 'none',
+        id: swarmId || ((_a = swarmState) === null || _a === void 0 ? void 0 : _a.id) || 'no-active-swarm',
+        topology: ((_b = swarmState) === null || _b === void 0 ? void 0 : _b.topology) || 'none',
+        status: status,
+        objective: ((_c = swarmState) === null || _c === void 0 ? void 0 : _c.objective) || 'No active objective',
+        strategy: ((_d = swarmState) === null || _d === void 0 ? void 0 : _d.strategy) || 'none',
         agents: {
             total: totalAgents,
             active: activeAgents,
             idle: Math.max(0, totalAgents - activeAgents),
             completed: 0
         },
-        progress,
+        progress: progress,
         tasks: {
             total: totalTasks,
             completed: completedTasks,
@@ -147,7 +187,7 @@ function getSwarmStatus(swarmId) {
         metrics: {
             tokensUsed: 0,
             avgResponseTime: '--',
-            successRate: totalTasks > 0 ? `${Math.round((completedTasks / totalTasks) * 100)}%` : '--',
+            successRate: totalTasks > 0 ? Math.round((completedTasks / totalTasks) * 100) + "%" : '--',
             elapsedTime: '--'
         },
         coordination: {
@@ -159,7 +199,7 @@ function getSwarmStatus(swarmId) {
     };
 }
 // Swarm topologies
-const TOPOLOGIES = [
+var TOPOLOGIES = [
     { value: 'hierarchical', label: 'Hierarchical', hint: 'Queen-led coordination with worker agents' },
     { value: 'mesh', label: 'Mesh', hint: 'Fully connected peer-to-peer network' },
     { value: 'ring', label: 'Ring', hint: 'Circular communication pattern' },
@@ -168,7 +208,7 @@ const TOPOLOGIES = [
     { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'V3 15-agent queen + peer communication (recommended)' }
 ];
 // Swarm strategies
-const STRATEGIES = [
+var STRATEGIES = [
     { value: 'specialized', label: 'Specialized', hint: 'Clear roles, no overlap (anti-drift)' },
     { value: 'balanced', label: 'Balanced', hint: 'Even distribution of work' },
     { value: 'adaptive', label: 'Adaptive', hint: 'Dynamic strategy based on task' },
@@ -180,7 +220,7 @@ const STRATEGIES = [
     { value: 'analysis', label: 'Analysis', hint: 'Code analysis and documentation' }
 ];
 // Initialize swarm
-const initCommand = {
+var initCommand = {
     name: 'init',
     description: 'Initialize a new swarm',
     options: [
@@ -189,136 +229,147 @@ const initCommand = {
             short: 't',
             description: 'Swarm topology',
             type: 'string',
-            choices: TOPOLOGIES.map(t => t.value),
-            default: 'hierarchical'
+            choices: TOPOLOGIES.map(function (t) { return t.value; }),
+            "default": 'hierarchical'
         },
         {
             name: 'max-agents',
             short: 'm',
             description: 'Maximum number of agents',
             type: 'number',
-            default: 15
+            "default": 15
         },
         {
             name: 'auto-scale',
             description: 'Enable automatic scaling',
             type: 'boolean',
-            default: true
+            "default": true
         },
         {
             name: 'strategy',
             short: 's',
             description: 'Coordination strategy',
             type: 'string',
-            choices: STRATEGIES.map(s => s.value)
+            choices: STRATEGIES.map(function (s) { return s.value; })
         },
         {
             name: 'v3-mode',
             description: 'Enable V3 15-agent hierarchical mesh mode',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        let topology = ctx.flags.topology;
-        const maxAgents = ctx.flags.maxAgents || 15;
-        const v3Mode = ctx.flags.v3Mode;
-        // V3 mode enables hierarchical-mesh hybrid
-        if (v3Mode) {
-            topology = 'hierarchical-mesh';
-            output.printInfo('V3 Mode: Using hierarchical-mesh topology with 15-agent coordination');
-        }
-        // Interactive topology selection
-        if (!topology && ctx.interactive) {
-            topology = await select({
-                message: 'Select swarm topology:',
-                options: TOPOLOGIES,
-                default: 'hierarchical'
-            });
-        }
-        output.writeln();
-        output.printInfo('Initializing swarm...');
-        try {
-            // Call MCP tool to initialize swarm
-            const result = await callMCPTool('swarm_init', {
-                topology: topology,
-                maxAgents,
-                config: {
-                    communicationProtocol: 'message-bus',
-                    consensusMechanism: 'majority',
-                    failureHandling: 'retry',
-                    loadBalancing: true,
-                    autoScaling: ctx.flags.autoScale ?? true,
-                },
-                metadata: {
-                    v3Mode,
-                    strategy: ctx.flags.strategy || 'development',
-                },
-            });
-            // Display initialization progress
-            output.writeln(output.dim('  Creating coordination topology...'));
-            output.writeln(output.dim('  Initializing memory namespace...'));
-            output.writeln(output.dim('  Setting up communication channels...'));
-            if (v3Mode) {
-                output.writeln(output.dim('  Enabling Flash Attention (2.49x-7.47x speedup)...'));
-                output.writeln(output.dim('  Configuring AgentDB integration (150x faster)...'));
-                output.writeln(output.dim('  Initializing SONA learning system...'));
-            }
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 20 },
-                    { key: 'value', header: 'Value', width: 35 }
-                ],
-                data: [
-                    { property: 'Swarm ID', value: result.swarmId },
-                    { property: 'Topology', value: result.topology },
-                    { property: 'Max Agents', value: result.config.maxAgents },
-                    { property: 'Auto Scale', value: result.config.autoScaling ? 'Enabled' : 'Disabled' },
-                    { property: 'Protocol', value: result.config.communicationProtocol || 'N/A' },
-                    { property: 'V3 Mode', value: v3Mode ? 'Enabled' : 'Disabled' }
-                ]
-            });
-            output.writeln();
-            output.printSuccess('Swarm initialized successfully');
-            // Save swarm state locally for status command to read
-            const swarmDir = path.join(process.cwd(), '.swarm');
-            try {
-                if (!fs.existsSync(swarmDir)) {
-                    fs.mkdirSync(swarmDir, { recursive: true });
-                }
-                const stateFile = path.join(swarmDir, 'state.json');
-                fs.writeFileSync(stateFile, JSON.stringify({
-                    id: result.swarmId,
-                    topology: result.topology,
-                    maxAgents: result.config.maxAgents,
-                    strategy: ctx.flags.strategy || 'development',
-                    v3Mode,
-                    initializedAt: result.initializedAt,
-                    status: 'ready'
-                }, null, 2));
-            }
-            catch {
-                // Ignore errors writing state file
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof MCPClientError) {
-                output.printError(`Failed to initialize swarm: ${error.message}`);
-            }
-            else {
-                output.printError(`Unexpected error: ${String(error)}`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var topology, maxAgents, v3Mode, result, swarmDir, stateFile, error_1;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    topology = ctx.flags.topology;
+                    maxAgents = ctx.flags.maxAgents || 15;
+                    v3Mode = ctx.flags.v3Mode;
+                    // V3 mode enables hierarchical-mesh hybrid
+                    if (v3Mode) {
+                        topology = 'hierarchical-mesh';
+                        output.printInfo('V3 Mode: Using hierarchical-mesh topology with 15-agent coordination');
+                    }
+                    if (!(!topology && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, select({
+                            message: 'Select swarm topology:',
+                            options: TOPOLOGIES,
+                            "default": 'hierarchical'
+                        })];
+                case 1:
+                    topology = _b.sent();
+                    _b.label = 2;
+                case 2:
+                    output.writeln();
+                    output.printInfo('Initializing swarm...');
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, callMCPTool('swarm_init', {
+                            topology: topology,
+                            maxAgents: maxAgents,
+                            config: {
+                                communicationProtocol: 'message-bus',
+                                consensusMechanism: 'majority',
+                                failureHandling: 'retry',
+                                loadBalancing: true,
+                                autoScaling: (_a = ctx.flags.autoScale) !== null && _a !== void 0 ? _a : true
+                            },
+                            metadata: {
+                                v3Mode: v3Mode,
+                                strategy: ctx.flags.strategy || 'development'
+                            }
+                        })];
+                case 4:
+                    result = _b.sent();
+                    // Display initialization progress
+                    output.writeln(output.dim('  Creating coordination topology...'));
+                    output.writeln(output.dim('  Initializing memory namespace...'));
+                    output.writeln(output.dim('  Setting up communication channels...'));
+                    if (v3Mode) {
+                        output.writeln(output.dim('  Enabling Flash Attention (2.49x-7.47x speedup)...'));
+                        output.writeln(output.dim('  Configuring AgentDB integration (150x faster)...'));
+                        output.writeln(output.dim('  Initializing SONA learning system...'));
+                    }
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'property', header: 'Property', width: 20 },
+                            { key: 'value', header: 'Value', width: 35 }
+                        ],
+                        data: [
+                            { property: 'Swarm ID', value: result.swarmId },
+                            { property: 'Topology', value: result.topology },
+                            { property: 'Max Agents', value: result.config.maxAgents },
+                            { property: 'Auto Scale', value: result.config.autoScaling ? 'Enabled' : 'Disabled' },
+                            { property: 'Protocol', value: result.config.communicationProtocol || 'N/A' },
+                            { property: 'V3 Mode', value: v3Mode ? 'Enabled' : 'Disabled' }
+                        ]
+                    });
+                    output.writeln();
+                    output.printSuccess('Swarm initialized successfully');
+                    swarmDir = path.join(process.cwd(), '.swarm');
+                    try {
+                        if (!fs.existsSync(swarmDir)) {
+                            fs.mkdirSync(swarmDir, { recursive: true });
+                        }
+                        stateFile = path.join(swarmDir, 'state.json');
+                        fs.writeFileSync(stateFile, JSON.stringify({
+                            id: result.swarmId,
+                            topology: result.topology,
+                            maxAgents: result.config.maxAgents,
+                            strategy: ctx.flags.strategy || 'development',
+                            v3Mode: v3Mode,
+                            initializedAt: result.initializedAt,
+                            status: 'ready'
+                        }, null, 2));
+                    }
+                    catch (_c) {
+                        // Ignore errors writing state file
+                    }
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 5:
+                    error_1 = _b.sent();
+                    if (error_1 instanceof MCPClientError) {
+                        output.printError("Failed to initialize swarm: " + error_1.message);
+                    }
+                    else {
+                        output.printError("Unexpected error: " + String(error_1));
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 6: return [2 /*return*/];
             }
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Start swarm execution
-const startCommand = {
+var startCommand = {
     name: 'start',
     description: 'Start swarm execution',
     options: [
@@ -334,170 +385,184 @@ const startCommand = {
             short: 's',
             description: 'Execution strategy',
             type: 'string',
-            choices: STRATEGIES.map(s => s.value)
+            choices: STRATEGIES.map(function (s) { return s.value; })
         },
         {
             name: 'parallel',
             short: 'p',
             description: 'Enable parallel execution',
             type: 'boolean',
-            default: true
+            "default": true
         },
         {
             name: 'monitor',
             description: 'Enable real-time monitoring',
             type: 'boolean',
-            default: true
+            "default": true
         }
     ],
     examples: [
         { command: 'claude-flow swarm start -o "Build REST API" -s development', description: 'Start development swarm' },
         { command: 'claude-flow swarm start -o "Analyze codebase" --parallel', description: 'Parallel analysis' }
     ],
-    action: async (ctx) => {
-        const objective = ctx.args[0] || ctx.flags.objective;
-        let strategy = ctx.flags.strategy;
-        if (!objective) {
-            output.printError('Objective is required. Use -o or provide as argument.');
-            return { success: false, exitCode: 1 };
-        }
-        // Interactive strategy selection
-        if (!strategy && ctx.interactive) {
-            strategy = await select({
-                message: 'Select execution strategy:',
-                options: STRATEGIES,
-                default: 'development'
-            });
-        }
-        strategy = strategy || 'development';
-        output.writeln();
-        output.printInfo(`Starting swarm with objective: ${output.highlight(objective)}`);
-        output.writeln();
-        // Compute agent deployment plan based on strategy
-        const agentPlan = getAgentPlan(strategy);
-        output.writeln(output.bold('Agent Deployment Plan'));
-        output.printTable({
-            columns: [
-                { key: 'role', header: 'Role', width: 20 },
-                { key: 'type', header: 'Type', width: 15 },
-                { key: 'count', header: 'Count', width: 8, align: 'right' },
-                { key: 'purpose', header: 'Purpose', width: 30 }
-            ],
-            data: agentPlan
-        });
-        // Confirm execution
-        if (ctx.interactive) {
-            const confirmed = await confirm({
-                message: `Deploy ${agentPlan.reduce((sum, a) => sum + a.count, 0)} agents?`,
-                default: true
-            });
-            if (!confirmed) {
-                output.printInfo('Swarm execution cancelled');
-                return { success: true };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var objective, strategy, agentPlan, confirmed, spinner, executionState;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    objective = ctx.args[0] || ctx.flags.objective;
+                    strategy = ctx.flags.strategy;
+                    if (!objective) {
+                        output.printError('Objective is required. Use -o or provide as argument.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(!strategy && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, select({
+                            message: 'Select execution strategy:',
+                            options: STRATEGIES,
+                            "default": 'development'
+                        })];
+                case 1:
+                    strategy = _b.sent();
+                    _b.label = 2;
+                case 2:
+                    strategy = strategy || 'development';
+                    output.writeln();
+                    output.printInfo("Starting swarm with objective: " + output.highlight(objective));
+                    output.writeln();
+                    agentPlan = getAgentPlan(strategy);
+                    output.writeln(output.bold('Agent Deployment Plan'));
+                    output.printTable({
+                        columns: [
+                            { key: 'role', header: 'Role', width: 20 },
+                            { key: 'type', header: 'Type', width: 15 },
+                            { key: 'count', header: 'Count', width: 8, align: 'right' },
+                            { key: 'purpose', header: 'Purpose', width: 30 }
+                        ],
+                        data: agentPlan
+                    });
+                    if (!ctx.interactive) return [3 /*break*/, 4];
+                    return [4 /*yield*/, confirm({
+                            message: "Deploy " + agentPlan.reduce(function (sum, a) { return sum + a.count; }, 0) + " agents?",
+                            "default": true
+                        })];
+                case 3:
+                    confirmed = _b.sent();
+                    if (!confirmed) {
+                        output.printInfo('Swarm execution cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _b.label = 4;
+                case 4:
+                    output.writeln();
+                    output.printInfo('Deploying agents...');
+                    spinner = output.createSpinner({ text: 'Initializing agents...', spinner: 'dots' });
+                    spinner.start();
+                    // Brief delay for spinner animation
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 500); })];
+                case 5:
+                    // Brief delay for spinner animation
+                    _b.sent();
+                    spinner.succeed('All agents deployed');
+                    executionState = {
+                        swarmId: "swarm-" + Date.now().toString(36),
+                        objective: objective,
+                        strategy: strategy,
+                        status: 'running',
+                        agents: agentPlan.reduce(function (sum, a) { return sum + a.count; }, 0),
+                        startedAt: new Date().toISOString(),
+                        parallel: (_a = ctx.flags.parallel) !== null && _a !== void 0 ? _a : true
+                    };
+                    output.writeln();
+                    output.printSuccess('Swarm execution started');
+                    output.writeln(output.dim("  Monitor: claude-flow swarm status " + executionState.swarmId));
+                    return [2 /*return*/, { success: true, data: executionState }];
             }
-        }
-        output.writeln();
-        output.printInfo('Deploying agents...');
-        // Show deployment progress
-        const spinner = output.createSpinner({ text: 'Initializing agents...', spinner: 'dots' });
-        spinner.start();
-        // Brief delay for spinner animation
-        await new Promise(resolve => setTimeout(resolve, 500));
-        spinner.succeed('All agents deployed');
-        const executionState = {
-            swarmId: `swarm-${Date.now().toString(36)}`,
-            objective,
-            strategy,
-            status: 'running',
-            agents: agentPlan.reduce((sum, a) => sum + a.count, 0),
-            startedAt: new Date().toISOString(),
-            parallel: ctx.flags.parallel ?? true
-        };
-        output.writeln();
-        output.printSuccess('Swarm execution started');
-        output.writeln(output.dim(`  Monitor: claude-flow swarm status ${executionState.swarmId}`));
-        return { success: true, data: executionState };
-    }
+        });
+    }); }
 };
 // Swarm status
-const statusCommand = {
+var statusCommand = {
     name: 'status',
     description: 'Show swarm status',
-    action: async (ctx) => {
-        const swarmId = ctx.args[0];
-        // Get dynamic status from actual swarm state files
-        const status = getSwarmStatus(swarmId);
-        if (ctx.flags.format === 'json') {
-            output.printJson(status);
-            return { success: true, data: status };
-        }
-        output.writeln();
-        // Show different message if no active swarm
-        if (!status.hasActiveSwarm) {
-            output.writeln(output.warning('No active swarm'));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var swarmId, status;
+        return __generator(this, function (_a) {
+            swarmId = ctx.args[0];
+            status = getSwarmStatus(swarmId);
+            if (ctx.flags.format === 'json') {
+                output.printJson(status);
+                return [2 /*return*/, { success: true, data: status }];
+            }
             output.writeln();
-            output.writeln(output.dim('Start a swarm with:'));
-            output.writeln(output.dim('  npx @kynjal/cli@latest swarm init'));
-            output.writeln(output.dim('  npx @kynjal/cli@latest swarm start'));
+            // Show different message if no active swarm
+            if (!status.hasActiveSwarm) {
+                output.writeln(output.warning('No active swarm'));
+                output.writeln();
+                output.writeln(output.dim('Start a swarm with:'));
+                output.writeln(output.dim('  npx @claude-flow/cli@latest swarm init'));
+                output.writeln(output.dim('  npx @claude-flow/cli@latest swarm start'));
+                output.writeln();
+                return [2 /*return*/, { success: true, data: status }];
+            }
+            output.writeln(output.bold("Swarm Status: " + status.id));
             output.writeln();
-            return { success: true, data: status };
-        }
-        output.writeln(output.bold(`Swarm Status: ${status.id}`));
-        output.writeln();
-        // Progress bar
-        output.writeln(`Overall Progress: ${output.progressBar(status.progress, 100, 40)}`);
-        output.writeln();
-        // Agent status
-        output.writeln(output.bold('Agents'));
-        output.printTable({
-            columns: [
-                { key: 'status', header: 'Status', width: 12 },
-                { key: 'count', header: 'Count', width: 10, align: 'right' }
-            ],
-            data: [
-                { status: output.success('Active'), count: status.agents.active },
-                { status: output.warning('Idle'), count: status.agents.idle },
-                { status: output.dim('Completed'), count: status.agents.completed },
-                { status: 'Total', count: status.agents.total }
-            ]
-        });
-        output.writeln();
-        // Task status
-        output.writeln(output.bold('Tasks'));
-        output.printTable({
-            columns: [
-                { key: 'status', header: 'Status', width: 12 },
-                { key: 'count', header: 'Count', width: 10, align: 'right' }
-            ],
-            data: [
-                { status: output.success('Completed'), count: status.tasks.completed },
-                { status: output.info('In Progress'), count: status.tasks.inProgress },
-                { status: output.dim('Pending'), count: status.tasks.pending },
-                { status: 'Total', count: status.tasks.total }
-            ]
+            // Progress bar
+            output.writeln("Overall Progress: " + output.progressBar(status.progress, 100, 40));
+            output.writeln();
+            // Agent status
+            output.writeln(output.bold('Agents'));
+            output.printTable({
+                columns: [
+                    { key: 'status', header: 'Status', width: 12 },
+                    { key: 'count', header: 'Count', width: 10, align: 'right' }
+                ],
+                data: [
+                    { status: output.success('Active'), count: status.agents.active },
+                    { status: output.warning('Idle'), count: status.agents.idle },
+                    { status: output.dim('Completed'), count: status.agents.completed },
+                    { status: 'Total', count: status.agents.total }
+                ]
+            });
+            output.writeln();
+            // Task status
+            output.writeln(output.bold('Tasks'));
+            output.printTable({
+                columns: [
+                    { key: 'status', header: 'Status', width: 12 },
+                    { key: 'count', header: 'Count', width: 10, align: 'right' }
+                ],
+                data: [
+                    { status: output.success('Completed'), count: status.tasks.completed },
+                    { status: output.info('In Progress'), count: status.tasks.inProgress },
+                    { status: output.dim('Pending'), count: status.tasks.pending },
+                    { status: 'Total', count: status.tasks.total }
+                ]
+            });
+            output.writeln();
+            // Metrics
+            output.writeln(output.bold('Performance Metrics'));
+            output.printList([
+                "Tokens Used: " + status.metrics.tokensUsed.toLocaleString(),
+                "Avg Response Time: " + status.metrics.avgResponseTime,
+                "Success Rate: " + status.metrics.successRate,
+                "Elapsed Time: " + status.metrics.elapsedTime
+            ]);
+            output.writeln();
+            // Coordination stats
+            output.writeln(output.bold('Coordination'));
+            output.printList([
+                "Consensus Rounds: " + status.coordination.consensusRounds,
+                "Messages Sent: " + status.coordination.messagesSent,
+                "Conflicts Resolved: " + status.coordination.conflictsResolved
+            ]);
+            return [2 /*return*/, { success: true, data: status }];
         });
-        output.writeln();
-        // Metrics
-        output.writeln(output.bold('Performance Metrics'));
-        output.printList([
-            `Tokens Used: ${status.metrics.tokensUsed.toLocaleString()}`,
-            `Avg Response Time: ${status.metrics.avgResponseTime}`,
-            `Success Rate: ${status.metrics.successRate}`,
-            `Elapsed Time: ${status.metrics.elapsedTime}`
-        ]);
-        output.writeln();
-        // Coordination stats
-        output.writeln(output.bold('Coordination'));
-        output.printList([
-            `Consensus Rounds: ${status.coordination.consensusRounds}`,
-            `Messages Sent: ${status.coordination.messagesSent}`,
-            `Conflicts Resolved: ${status.coordination.conflictsResolved}`
-        ]);
-        return { success: true, data: status };
-    }
+    }); }
 };
 // Stop swarm
-const stopCommand = {
+var stopCommand = {
     name: 'stop',
     description: 'Stop swarm execution',
     options: [
@@ -506,45 +571,54 @@ const stopCommand = {
             short: 'f',
             description: 'Force immediate stop',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'save-state',
             description: 'Save current state for resume',
             type: 'boolean',
-            default: true
+            "default": true
         }
     ],
-    action: async (ctx) => {
-        const swarmId = ctx.args[0];
-        const force = ctx.flags.force;
-        if (!swarmId) {
-            output.printError('Swarm ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        if (ctx.interactive && !force) {
-            const confirmed = await confirm({
-                message: `Stop swarm ${swarmId}? Progress will be saved.`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var swarmId, force, confirmed;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    swarmId = ctx.args[0];
+                    force = ctx.flags.force;
+                    if (!swarmId) {
+                        output.printError('Swarm ID is required');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    if (!(ctx.interactive && !force)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirm({
+                            message: "Stop swarm " + swarmId + "? Progress will be saved.",
+                            "default": false
+                        })];
+                case 1:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 2;
+                case 2:
+                    output.printInfo("Stopping swarm " + swarmId + "...");
+                    if (!force) {
+                        output.writeln(output.dim('  Completing in-progress tasks...'));
+                        output.writeln(output.dim('  Saving coordination state...'));
+                        output.writeln(output.dim('  Notifying agents...'));
+                        output.writeln(output.dim('  Saving memory state...'));
+                    }
+                    output.printSuccess("Swarm " + swarmId + " stopped");
+                    return [2 /*return*/, { success: true, data: { swarmId: swarmId, stopped: true, force: force } }];
             }
-        }
-        output.printInfo(`Stopping swarm ${swarmId}...`);
-        if (!force) {
-            output.writeln(output.dim('  Completing in-progress tasks...'));
-            output.writeln(output.dim('  Saving coordination state...'));
-            output.writeln(output.dim('  Notifying agents...'));
-            output.writeln(output.dim('  Saving memory state...'));
-        }
-        output.printSuccess(`Swarm ${swarmId} stopped`);
-        return { success: true, data: { swarmId, stopped: true, force } };
-    }
+        });
+    }); }
 };
 // Scale swarm
-const scaleCommand = {
+var scaleCommand = {
     name: 'scale',
     description: 'Scale swarm agent count',
     options: [
@@ -562,38 +636,40 @@ const scaleCommand = {
             type: 'string'
         }
     ],
-    action: async (ctx) => {
-        const swarmId = ctx.args[0];
-        const targetAgents = ctx.flags.agents;
-        const agentType = ctx.flags.type;
-        if (!swarmId) {
-            output.printError('Swarm ID is required');
-            return { success: false, exitCode: 1 };
-        }
-        if (!targetAgents) {
-            output.printError('Target agent count required. Use --agents or -a');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Scaling swarm ${swarmId} to ${targetAgents} agents...`);
-        // Calculate scaling delta
-        const currentAgents = 8;
-        const delta = targetAgents - currentAgents;
-        if (delta > 0) {
-            output.writeln(output.dim(`  Spawning ${delta} new agents...`));
-        }
-        else if (delta < 0) {
-            output.writeln(output.dim(`  Gracefully stopping ${-delta} agents...`));
-        }
-        else {
-            output.printInfo('Swarm already at target size');
-            return { success: true };
-        }
-        output.printSuccess(`Swarm scaled to ${targetAgents} agents`);
-        return { success: true, data: { swarmId, agents: targetAgents, delta } };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var swarmId, targetAgents, agentType, currentAgents, delta;
+        return __generator(this, function (_a) {
+            swarmId = ctx.args[0];
+            targetAgents = ctx.flags.agents;
+            agentType = ctx.flags.type;
+            if (!swarmId) {
+                output.printError('Swarm ID is required');
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            }
+            if (!targetAgents) {
+                output.printError('Target agent count required. Use --agents or -a');
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            }
+            output.printInfo("Scaling swarm " + swarmId + " to " + targetAgents + " agents...");
+            currentAgents = 8;
+            delta = targetAgents - currentAgents;
+            if (delta > 0) {
+                output.writeln(output.dim("  Spawning " + delta + " new agents..."));
+            }
+            else if (delta < 0) {
+                output.writeln(output.dim("  Gracefully stopping " + -delta + " agents..."));
+            }
+            else {
+                output.printInfo('Swarm already at target size');
+                return [2 /*return*/, { success: true }];
+            }
+            output.printSuccess("Swarm scaled to " + targetAgents + " agents");
+            return [2 /*return*/, { success: true, data: { swarmId: swarmId, agents: targetAgents, delta: delta } }];
+        });
+    }); }
 };
 // Coordinate command (V3 specific)
-const coordinateCommand = {
+var coordinateCommand = {
     name: 'coordinate',
     description: 'Execute V3 15-agent hierarchical mesh coordination',
     options: [
@@ -601,7 +677,7 @@ const coordinateCommand = {
             name: 'agents',
             description: 'Number of agents',
             type: 'number',
-            default: 15
+            "default": 15
         },
         {
             name: 'domains',
@@ -609,57 +685,59 @@ const coordinateCommand = {
             type: 'array'
         }
     ],
-    action: async (ctx) => {
-        const agentCount = ctx.flags.agents || 15;
-        output.writeln();
-        output.writeln(output.bold('V3 15-Agent Hierarchical Mesh Coordination'));
-        output.writeln();
-        // V3 agent structure
-        const v3Agents = [
-            { id: 1, role: 'Queen Coordinator', domain: 'Orchestration', status: 'primary' },
-            { id: 2, role: 'Security Architect', domain: 'Security', status: 'active' },
-            { id: 3, role: 'Security Auditor', domain: 'Security', status: 'active' },
-            { id: 4, role: 'Test Architect', domain: 'Security', status: 'active' },
-            { id: 5, role: 'Core Architect', domain: 'Core', status: 'active' },
-            { id: 6, role: 'Memory Specialist', domain: 'Core', status: 'active' },
-            { id: 7, role: 'Swarm Specialist', domain: 'Core', status: 'active' },
-            { id: 8, role: 'Integration Architect', domain: 'Integration', status: 'active' },
-            { id: 9, role: 'Performance Engineer', domain: 'Integration', status: 'active' },
-            { id: 10, role: 'CLI Developer', domain: 'Integration', status: 'active' },
-            { id: 11, role: 'Hooks Developer', domain: 'Integration', status: 'active' },
-            { id: 12, role: 'MCP Specialist', domain: 'Integration', status: 'active' },
-            { id: 13, role: 'Project Coordinator', domain: 'Management', status: 'active' },
-            { id: 14, role: 'Documentation Lead', domain: 'Management', status: 'standby' },
-            { id: 15, role: 'DevOps Engineer', domain: 'Management', status: 'standby' }
-        ].slice(0, agentCount);
-        output.printTable({
-            columns: [
-                { key: 'id', header: '#', width: 3, align: 'right' },
-                { key: 'role', header: 'Role', width: 22 },
-                { key: 'domain', header: 'Domain', width: 15 },
-                { key: 'status', header: 'Status', width: 10, format: (v) => {
-                        if (v === 'primary')
-                            return output.highlight(String(v));
-                        if (v === 'active')
-                            return output.success(String(v));
-                        return output.dim(String(v));
-                    } }
-            ],
-            data: v3Agents
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var agentCount, v3Agents;
+        return __generator(this, function (_a) {
+            agentCount = ctx.flags.agents || 15;
+            output.writeln();
+            output.writeln(output.bold('V3 15-Agent Hierarchical Mesh Coordination'));
+            output.writeln();
+            v3Agents = [
+                { id: 1, role: 'Queen Coordinator', domain: 'Orchestration', status: 'primary' },
+                { id: 2, role: 'Security Architect', domain: 'Security', status: 'active' },
+                { id: 3, role: 'Security Auditor', domain: 'Security', status: 'active' },
+                { id: 4, role: 'Test Architect', domain: 'Security', status: 'active' },
+                { id: 5, role: 'Core Architect', domain: 'Core', status: 'active' },
+                { id: 6, role: 'Memory Specialist', domain: 'Core', status: 'active' },
+                { id: 7, role: 'Swarm Specialist', domain: 'Core', status: 'active' },
+                { id: 8, role: 'Integration Architect', domain: 'Integration', status: 'active' },
+                { id: 9, role: 'Performance Engineer', domain: 'Integration', status: 'active' },
+                { id: 10, role: 'CLI Developer', domain: 'Integration', status: 'active' },
+                { id: 11, role: 'Hooks Developer', domain: 'Integration', status: 'active' },
+                { id: 12, role: 'MCP Specialist', domain: 'Integration', status: 'active' },
+                { id: 13, role: 'Project Coordinator', domain: 'Management', status: 'active' },
+                { id: 14, role: 'Documentation Lead', domain: 'Management', status: 'standby' },
+                { id: 15, role: 'DevOps Engineer', domain: 'Management', status: 'standby' }
+            ].slice(0, agentCount);
+            output.printTable({
+                columns: [
+                    { key: 'id', header: '#', width: 3, align: 'right' },
+                    { key: 'role', header: 'Role', width: 22 },
+                    { key: 'domain', header: 'Domain', width: 15 },
+                    { key: 'status', header: 'Status', width: 10, format: function (v) {
+                            if (v === 'primary')
+                                return output.highlight(String(v));
+                            if (v === 'active')
+                                return output.success(String(v));
+                            return output.dim(String(v));
+                        } }
+                ],
+                data: v3Agents
+            });
+            output.writeln();
+            output.printInfo('Performance Targets:');
+            output.printList([
+                "Flash Attention: " + output.success('2.49x-7.47x speedup'),
+                "AgentDB Search: " + output.success('150x-12,500x improvement'),
+                "Memory Reduction: " + output.success('50-75%'),
+                "Code Reduction: " + output.success('<5,000 lines')
+            ]);
+            return [2 /*return*/, { success: true, data: { agents: v3Agents, count: agentCount } }];
         });
-        output.writeln();
-        output.printInfo('Performance Targets:');
-        output.printList([
-            `Flash Attention: ${output.success('2.49x-7.47x speedup')}`,
-            `AgentDB Search: ${output.success('150x-12,500x improvement')}`,
-            `Memory Reduction: ${output.success('50-75%')}`,
-            `Code Reduction: ${output.success('<5,000 lines')}`
-        ]);
-        return { success: true, data: { agents: v3Agents, count: agentCount } };
-    }
+    }); }
 };
 // Main swarm command
-export const swarmCommand = {
+export var swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
     subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand],
@@ -669,27 +747,29 @@ export const swarmCommand = {
         { command: 'claude-flow swarm start -o "Build API" -s development', description: 'Start development swarm' },
         { command: 'claude-flow swarm coordinate --agents 15', description: 'V3 coordination' }
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Swarm Coordination Commands'));
-        output.writeln();
-        output.writeln('Usage: claude-flow swarm <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('init')}        - Initialize a new swarm`,
-            `${output.highlight('start')}       - Start swarm execution`,
-            `${output.highlight('status')}      - Show swarm status`,
-            `${output.highlight('stop')}        - Stop swarm execution`,
-            `${output.highlight('scale')}       - Scale swarm agent count`,
-            `${output.highlight('coordinate')}  - V3 15-agent coordination`
-        ]);
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('Swarm Coordination Commands'));
+            output.writeln();
+            output.writeln('Usage: claude-flow swarm <subcommand> [options]');
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                output.highlight('init') + "        - Initialize a new swarm",
+                output.highlight('start') + "       - Start swarm execution",
+                output.highlight('status') + "      - Show swarm status",
+                output.highlight('stop') + "        - Stop swarm execution",
+                output.highlight('scale') + "       - Scale swarm agent count",
+                output.highlight('coordinate') + "  - V3 15-agent coordination"
+            ]);
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 // Helper function
 function getAgentPlan(strategy) {
-    const plans = {
+    var plans = {
         specialized: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Central orchestration (anti-drift)' },
             { role: 'Researcher', type: 'researcher', count: 1, purpose: 'Requirements analysis' },