kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/swarm.js

@@ -2,42 +2,6 @@
  * 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';
@@ -45,85 +9,81 @@ import * as fs from 'fs';
 import * as path from 'path';
 // Get dynamic swarm status from memory/session files
 function getSwarmStatus(swarmId) {
-    var _a, _b, _c, _d;
-    var swarmDir = path.join(process.cwd(), '.swarm');
-    var sessionDir = path.join(process.cwd(), '.claude', 'sessions');
-    var memoryPaths = [
+    const swarmDir = path.join(process.cwd(), '.swarm');
+    const sessionDir = path.join(process.cwd(), '.claude', 'sessions');
+    const memoryPaths = [
         path.join(process.cwd(), '.swarm', 'memory.db'),
         path.join(process.cwd(), '.claude', 'memory.db'),
     ];
     // Check for active swarm state file
-    var swarmStateFile = path.join(swarmDir, 'state.json');
-    var swarmState = null;
+    const swarmStateFile = path.join(swarmDir, 'state.json');
+    let swarmState = null;
     if (fs.existsSync(swarmStateFile)) {
         try {
             swarmState = JSON.parse(fs.readFileSync(swarmStateFile, 'utf-8'));
         }
-        catch (_e) {
+        catch {
             // Ignore parse errors
         }
     }
     // Count active agents from process files
-    var activeAgents = 0;
-    var totalAgents = 0;
-    var agentsDir = path.join(swarmDir, 'agents');
+    let activeAgents = 0;
+    let totalAgents = 0;
+    const agentsDir = path.join(swarmDir, 'agents');
     if (fs.existsSync(agentsDir)) {
         try {
-            var agentFiles = fs.readdirSync(agentsDir).filter(function (f) { return f.endsWith('.json'); });
+            const agentFiles = fs.readdirSync(agentsDir).filter(f => f.endsWith('.json'));
             totalAgents = agentFiles.length;
-            for (var _i = 0, agentFiles_1 = agentFiles; _i < agentFiles_1.length; _i++) {
-                var file = agentFiles_1[_i];
+            for (const file of agentFiles) {
                 try {
-                    var agent = JSON.parse(fs.readFileSync(path.join(agentsDir, file), 'utf-8'));
+                    const agent = JSON.parse(fs.readFileSync(path.join(agentsDir, file), 'utf-8'));
                     if (agent.status === 'active' || agent.status === 'running') {
                         activeAgents++;
                     }
                 }
-                catch (_f) {
+                catch {
                     // Ignore
                 }
             }
         }
-        catch (_g) {
+        catch {
             // Ignore
         }
     }
     // Get session count
-    var sessionCount = 0;
+    let sessionCount = 0;
     if (fs.existsSync(sessionDir)) {
         try {
-            sessionCount = fs.readdirSync(sessionDir).filter(function (f) { return f.endsWith('.json'); }).length;
+            sessionCount = fs.readdirSync(sessionDir).filter(f => f.endsWith('.json')).length;
         }
-        catch (_h) {
+        catch {
             // Ignore
         }
     }
     // Get memory size as rough indicator of activity
-    var memorySize = 0;
-    for (var _j = 0, memoryPaths_1 = memoryPaths; _j < memoryPaths_1.length; _j++) {
-        var dbPath = memoryPaths_1[_j];
+    let memorySize = 0;
+    for (const dbPath of memoryPaths) {
         if (fs.existsSync(dbPath)) {
             try {
                 memorySize = fs.statSync(dbPath).size;
                 break;
             }
-            catch (_k) {
+            catch {
                 // Ignore
             }
         }
     }
     // Count task files if they exist
-    var completedTasks = 0;
-    var inProgressTasks = 0;
-    var pendingTasks = 0;
-    var tasksDir = path.join(swarmDir, 'tasks');
+    let completedTasks = 0;
+    let inProgressTasks = 0;
+    let pendingTasks = 0;
+    const tasksDir = path.join(swarmDir, 'tasks');
     if (fs.existsSync(tasksDir)) {
         try {
-            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];
+            const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.json'));
+            for (const file of taskFiles) {
                 try {
-                    var task = JSON.parse(fs.readFileSync(path.join(tasksDir, file), 'utf-8'));
+                    const task = JSON.parse(fs.readFileSync(path.join(tasksDir, file), 'utf-8'));
                     if (task.status === 'completed' || task.status === 'done') {
                         completedTasks++;
                     }
@@ -134,19 +94,19 @@ function getSwarmStatus(swarmId) {
                         pendingTasks++;
                     }
                 }
-                catch (_m) {
+                catch {
                     // Ignore
                 }
             }
         }
-        catch (_o) {
+        catch {
             // Ignore
         }
     }
     // Calculate dynamic progress based on actual state
     // If no swarm state, show 0%. Otherwise calculate from completed tasks
-    var totalTasks = completedTasks + inProgressTasks + pendingTasks;
-    var progress = 0;
+    const totalTasks = completedTasks + inProgressTasks + pendingTasks;
+    let progress = 0;
     if (totalTasks > 0) {
         progress = Math.round((completedTasks / totalTasks) * 100);
     }
@@ -155,7 +115,7 @@ function getSwarmStatus(swarmId) {
         progress = 5;
     }
     // Determine status
-    var status = 'idle';
+    let status = 'idle';
     if (inProgressTasks > 0 || activeAgents > 0) {
         status = 'running';
     }
@@ -166,18 +126,18 @@ function getSwarmStatus(swarmId) {
         status = 'ready';
     }
     return {
-        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',
+        id: swarmId || swarmState?.id || 'no-active-swarm',
+        topology: swarmState?.topology || 'none',
+        status,
+        objective: swarmState?.objective || 'No active objective',
+        strategy: swarmState?.strategy || 'none',
         agents: {
             total: totalAgents,
             active: activeAgents,
             idle: Math.max(0, totalAgents - activeAgents),
             completed: 0
         },
-        progress: progress,
+        progress,
         tasks: {
             total: totalTasks,
             completed: completedTasks,
@@ -187,7 +147,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: {
@@ -199,7 +159,7 @@ function getSwarmStatus(swarmId) {
     };
 }
 // Swarm topologies
-var TOPOLOGIES = [
+const 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' },
@@ -208,7 +168,7 @@ var TOPOLOGIES = [
     { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'V3 15-agent queen + peer communication (recommended)' }
 ];
 // Swarm strategies
-var STRATEGIES = [
+const 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' },
@@ -220,7 +180,7 @@ var STRATEGIES = [
     { value: 'analysis', label: 'Analysis', hint: 'Code analysis and documentation' }
 ];
 // Initialize swarm
-var initCommand = {
+const initCommand = {
     name: 'init',
     description: 'Initialize a new swarm',
     options: [
@@ -229,147 +189,136 @@ var initCommand = {
             short: 't',
             description: 'Swarm topology',
             type: 'string',
-            choices: TOPOLOGIES.map(function (t) { return t.value; }),
-            "default": 'hierarchical'
+            choices: TOPOLOGIES.map(t => 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(function (s) { return s.value; })
+            choices: STRATEGIES.map(s => s.value)
         },
         {
             name: 'v3-mode',
             description: 'Enable V3 15-agent hierarchical mesh mode',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
-    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*/];
+    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)}`);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    }
 };
 // Start swarm execution
-var startCommand = {
+const startCommand = {
     name: 'start',
     description: 'Start swarm execution',
     options: [
@@ -385,184 +334,170 @@ var startCommand = {
             short: 's',
             description: 'Execution strategy',
             type: 'string',
-            choices: STRATEGIES.map(function (s) { return s.value; })
+            choices: STRATEGIES.map(s => 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: 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 }];
-            }
+    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 };
+            }
+        }
+        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
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Show swarm status',
-    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();
-            // 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();
-            // 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 }
-                ]
-            });
+    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'));
             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(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();
-            // 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 }];
+            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 }
+            ]
+        });
+        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
-var stopCommand = {
+const stopCommand = {
     name: 'stop',
     description: 'Stop swarm execution',
     options: [
@@ -571,54 +506,45 @@ var 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: 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 } }];
+    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 };
             }
-        });
-    }); }
+        }
+        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
-var scaleCommand = {
+const scaleCommand = {
     name: 'scale',
     description: 'Scale swarm agent count',
     options: [
@@ -636,40 +562,38 @@ var scaleCommand = {
             type: 'string'
         }
     ],
-    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 } }];
-        });
-    }); }
+    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 } };
+    }
 };
 // Coordinate command (V3 specific)
-var coordinateCommand = {
+const coordinateCommand = {
     name: 'coordinate',
     description: 'Execute V3 15-agent hierarchical mesh coordination',
     options: [
@@ -677,7 +601,7 @@ var coordinateCommand = {
             name: 'agents',
             description: 'Number of agents',
             type: 'number',
-            "default": 15
+            default: 15
         },
         {
             name: 'domains',
@@ -685,59 +609,57 @@ var coordinateCommand = {
             type: 'array'
         }
     ],
-    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 } }];
+    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
         });
-    }); }
+        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 var swarmCommand = {
+export const swarmCommand = {
     name: 'swarm',
     description: 'Swarm coordination commands',
     subcommands: [initCommand, startCommand, statusCommand, stopCommand, scaleCommand, coordinateCommand],
@@ -747,29 +669,27 @@ export var 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: 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 }];
-        });
-    }); }
+    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 };
+    }
 };
 // Helper function
 function getAgentPlan(strategy) {
-    var plans = {
+    const plans = {
         specialized: [
             { role: 'Coordinator', type: 'coordinator', count: 1, purpose: 'Central orchestration (anti-drift)' },
             { role: 'Researcher', type: 'researcher', count: 1, purpose: 'Requirements analysis' },