kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/start.js

@@ -1,38 +1,86 @@
 /**
  * V3 CLI Start Command
- * System startup for KynjalFlow orchestration
+ * System startup for Claude Flow orchestration
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { confirm } from '../prompt.js';
 import { callMCPTool, MCPClientError } from '../mcp-client.js';
 import * as fs from 'fs';
 import * as path from 'path';
 // Default configuration
-const DEFAULT_PORT = 3000;
-const DEFAULT_TOPOLOGY = 'hierarchical-mesh';
-const DEFAULT_MAX_AGENTS = 15;
+var DEFAULT_PORT = 3000;
+var DEFAULT_TOPOLOGY = 'hierarchical-mesh';
+var DEFAULT_MAX_AGENTS = 15;
 // Check if project is initialized
 function isInitialized(cwd) {
-    const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    var configPath = path.join(cwd, '.claude-flow', 'config.yaml');
     return fs.existsSync(configPath);
 }
 // Simple YAML parser for config (basic implementation)
 function parseSimpleYaml(content) {
-    const result = {};
-    const lines = content.split('\n');
-    const stack = [
+    var result = {};
+    var lines = content.split('\n');
+    var stack = [
         { indent: -1, obj: result }
     ];
-    for (const line of lines) {
+    for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+        var line = lines_1[_i];
         // Skip comments and empty lines
         if (line.trim().startsWith('#') || line.trim() === '')
             continue;
-        const match = line.match(/^(\s*)(\w+):\s*(.*)$/);
+        var match = line.match(/^(\s*)(\w+):\s*(.*)$/);
         if (!match)
             continue;
-        const indent = match[1].length;
-        const key = match[2];
-        let value = match[3].trim();
+        var indent = match[1].length;
+        var key = match[2];
+        var value = match[3].trim();
         // Parse value
         if (value === '' || value === undefined) {
             value = {};
@@ -56,10 +104,10 @@ function parseSimpleYaml(content) {
         while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
             stack.pop();
         }
-        const parent = stack[stack.length - 1].obj;
+        var parent = stack[stack.length - 1].obj;
         if (typeof value === 'object' && value !== null) {
             parent[key] = value;
-            stack.push({ indent, obj: value, key });
+            stack.push({ indent: indent, obj: value, key: key });
         }
         else {
             parent[key] = value;
@@ -69,310 +117,359 @@ function parseSimpleYaml(content) {
 }
 // Load configuration
 function loadConfig(cwd) {
-    const configPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    var configPath = path.join(cwd, '.claude-flow', 'config.yaml');
     if (!fs.existsSync(configPath))
         return null;
     try {
-        const content = fs.readFileSync(configPath, 'utf-8');
+        var content = fs.readFileSync(configPath, 'utf-8');
         return parseSimpleYaml(content);
     }
-    catch {
+    catch (_a) {
         return null;
     }
 }
 // Main start action
-const startAction = async (ctx) => {
-    const daemon = ctx.flags.daemon;
-    const port = ctx.flags.port || DEFAULT_PORT;
-    const topology = ctx.flags.topology || DEFAULT_TOPOLOGY;
-    const skipMcp = ctx.flags['skip-mcp'];
-    const cwd = ctx.cwd;
-    // Check initialization
-    if (!isInitialized(cwd)) {
-        output.printError('KynjalFlow is not initialized in this directory');
-        output.printInfo('Run "claude-flow init" first to initialize');
-        return { success: false, exitCode: 1 };
-    }
-    // Load configuration
-    const config = loadConfig(cwd);
-    const swarmConfig = config?.swarm || {};
-    const mcpConfig = config?.mcp || {};
-    const finalTopology = topology || swarmConfig.topology || DEFAULT_TOPOLOGY;
-    const maxAgents = swarmConfig.maxAgents || DEFAULT_MAX_AGENTS;
-    const autoStartMcp = mcpConfig.autoStart !== false && !skipMcp;
-    const mcpPort = port || mcpConfig.serverPort || DEFAULT_PORT;
-    output.writeln();
-    output.writeln(output.bold('Starting KynjalFlow V3'));
-    output.writeln();
-    const spinner = output.createSpinner({ text: 'Initializing system...' });
-    try {
-        // Step 1: Initialize swarm
-        spinner.start();
-        spinner.setText('Initializing V3 swarm...');
-        const swarmResult = await callMCPTool('swarm_init', {
-            topology: finalTopology,
-            maxAgents,
-            autoScaling: swarmConfig.autoScale !== false,
-            v3Mode: true
-        });
-        spinner.succeed(`Swarm initialized (${finalTopology})`);
-        // Step 2: Start MCP server if configured
-        let mcpResult = null;
-        if (autoStartMcp) {
-            spinner.setText('Starting MCP server...');
-            spinner.start();
-            try {
-                mcpResult = await callMCPTool('mcp_start', {
-                    port: mcpPort,
-                    transport: mcpConfig.transportType || 'stdio',
-                    tools: mcpConfig.tools || ['agent', 'swarm', 'memory', 'task']
-                });
-                spinner.succeed(`MCP server started on port ${mcpPort}`);
-            }
-            catch (error) {
+var startAction = function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+    var daemon, port, topology, skipMcp, cwd, config, swarmConfig, mcpConfig, finalTopology, maxAgents, autoStartMcp, mcpPort, spinner, swarmResult, mcpResult, error_1, healthResult, daemonPidPath_1, keepAlive_1, result, error_2;
+    var _a, _b, _c, _d, _e, _f;
+    return __generator(this, function (_g) {
+        switch (_g.label) {
+            case 0:
+                daemon = ctx.flags.daemon;
+                port = ctx.flags.port || DEFAULT_PORT;
+                topology = ctx.flags.topology || DEFAULT_TOPOLOGY;
+                skipMcp = ctx.flags['skip-mcp'];
+                cwd = ctx.cwd;
+                // Check initialization
+                if (!isInitialized(cwd)) {
+                    output.printError('RuFlo is not initialized in this directory');
+                    output.printInfo('Run "ruflo init" first to initialize');
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                }
+                config = loadConfig(cwd);
+                swarmConfig = (config === null || config === void 0 ? void 0 : config.swarm) || {};
+                mcpConfig = (config === null || config === void 0 ? void 0 : config.mcp) || {};
+                finalTopology = topology || swarmConfig.topology || DEFAULT_TOPOLOGY;
+                maxAgents = swarmConfig.maxAgents || DEFAULT_MAX_AGENTS;
+                autoStartMcp = mcpConfig.autoStart !== false && !skipMcp;
+                mcpPort = port || mcpConfig.serverPort || DEFAULT_PORT;
+                output.writeln();
+                output.writeln(output.bold('Starting RuFlo V3'));
+                output.writeln();
+                spinner = output.createSpinner({ text: 'Initializing system...' });
+                _g.label = 1;
+            case 1:
+                _g.trys.push([1, 8, , 9]);
+                // Step 1: Initialize swarm
+                spinner.start();
+                spinner.setText('Initializing V3 swarm...');
+                return [4 /*yield*/, callMCPTool('swarm_init', {
+                        topology: finalTopology,
+                        maxAgents: maxAgents,
+                        autoScaling: swarmConfig.autoScale !== false,
+                        v3Mode: true
+                    })];
+            case 2:
+                swarmResult = _g.sent();
+                spinner.succeed("Swarm initialized (" + finalTopology + ")");
+                mcpResult = null;
+                if (!autoStartMcp) return [3 /*break*/, 6];
+                spinner.setText('Starting MCP server...');
+                spinner.start();
+                _g.label = 3;
+            case 3:
+                _g.trys.push([3, 5, , 6]);
+                return [4 /*yield*/, callMCPTool('mcp_start', {
+                        port: mcpPort,
+                        transport: mcpConfig.transportType || 'stdio',
+                        tools: mcpConfig.tools || ['agent', 'swarm', 'memory', 'task']
+                    })];
+            case 4:
+                mcpResult = _g.sent();
+                spinner.succeed("MCP server started on port " + mcpPort);
+                return [3 /*break*/, 6];
+            case 5:
+                error_1 = _g.sent();
                 spinner.fail('MCP server failed to start');
-                output.printWarning(error instanceof MCPClientError
-                    ? error.message
-                    : String(error));
-                // Continue without MCP
-            }
-        }
-        // Step 3: Run health check
-        spinner.setText('Running health checks...');
-        spinner.start();
-        const healthResult = await callMCPTool('swarm_health', {
-            swarmId: swarmResult.swarmId
-        });
-        if (healthResult.status === 'healthy') {
-            spinner.succeed('Health checks passed');
-        }
-        else {
-            spinner.fail(`Health check: ${healthResult.status}`);
-        }
-        // Success output
-        output.writeln();
-        output.printSuccess('KynjalFlow V3 is running!');
-        output.writeln();
-        // Status display
-        output.printBox([
-            `Swarm ID:  ${swarmResult.swarmId}`,
-            `Topology:  ${finalTopology}`,
-            `Max Agents: ${maxAgents}`,
-            `MCP Server: ${autoStartMcp ? `localhost:${mcpPort}` : 'disabled'}`,
-            `Mode:      ${daemon ? 'Daemon' : 'Foreground'}`,
-            `Health:    ${healthResult.status}`
-        ].join('\n'), 'System Status');
-        output.writeln();
-        output.writeln(output.bold('Quick Commands:'));
-        output.printList([
-            `${output.highlight('claude-flow status')} - View system status`,
-            `${output.highlight('claude-flow agent spawn -t coder')} - Spawn an agent`,
-            `${output.highlight('claude-flow swarm status')} - View swarm details`,
-            `${output.highlight('claude-flow stop')} - Stop the system`
-        ]);
-        // Daemon mode
-        if (daemon) {
-            output.writeln();
-            output.printInfo('Running in daemon mode. Use "claude-flow stop" to stop.');
-            // Store PID for daemon management
-            const daemonPidPath = path.join(cwd, '.claude-flow', 'daemon.pid');
-            fs.writeFileSync(daemonPidPath, String(process.pid));
-            // Detach from parent process for true daemon behavior
-            if (process.platform !== 'win32') {
-                // Unix-like systems: create new session
-                try {
-                    process.stdin.unref?.();
-                    process.stdout.unref?.();
-                    process.stderr.unref?.();
+                output.printWarning(error_1 instanceof MCPClientError
+                    ? error_1.message
+                    : String(error_1));
+                return [3 /*break*/, 6];
+            case 6:
+                // Step 3: Run health check
+                spinner.setText('Running health checks...');
+                spinner.start();
+                return [4 /*yield*/, callMCPTool('swarm_health', {
+                        swarmId: swarmResult.swarmId
+                    })];
+            case 7:
+                healthResult = _g.sent();
+                if (healthResult.status === 'healthy') {
+                    spinner.succeed('Health checks passed');
                 }
-                catch {
-                    // Ignore errors if streams can't be unref'd
+                else {
+                    spinner.fail("Health check: " + healthResult.status);
                 }
-            }
-            // Keep process alive in daemon mode
-            const keepAlive = setInterval(() => {
-                // Heartbeat - check if we should still be running
-                if (!fs.existsSync(daemonPidPath)) {
-                    clearInterval(keepAlive);
-                    process.exit(0);
+                // Success output
+                output.writeln();
+                output.printSuccess('RuFlo V3 is running!');
+                output.writeln();
+                // Status display
+                output.printBox([
+                    "Swarm ID:  " + swarmResult.swarmId,
+                    "Topology:  " + finalTopology,
+                    "Max Agents: " + maxAgents,
+                    "MCP Server: " + (autoStartMcp ? "localhost:" + mcpPort : 'disabled'),
+                    "Mode:      " + (daemon ? 'Daemon' : 'Foreground'),
+                    "Health:    " + healthResult.status
+                ].join('\n'), 'System Status');
+                output.writeln();
+                output.writeln(output.bold('Quick Commands:'));
+                output.printList([
+                    output.highlight('claude-flow status') + " - View system status",
+                    output.highlight('claude-flow agent spawn -t coder') + " - Spawn an agent",
+                    output.highlight('claude-flow swarm status') + " - View swarm details",
+                    output.highlight('claude-flow stop') + " - Stop the system"
+                ]);
+                // Daemon mode
+                if (daemon) {
+                    output.writeln();
+                    output.printInfo('Running in daemon mode. Use "claude-flow stop" to stop.');
+                    daemonPidPath_1 = path.join(cwd, '.claude-flow', 'daemon.pid');
+                    fs.writeFileSync(daemonPidPath_1, String(process.pid));
+                    // Detach from parent process for true daemon behavior
+                    if (process.platform !== 'win32') {
+                        // Unix-like systems: create new session
+                        try {
+                            (_b = (_a = process.stdin).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+                            (_d = (_c = process.stdout).unref) === null || _d === void 0 ? void 0 : _d.call(_c);
+                            (_f = (_e = process.stderr).unref) === null || _f === void 0 ? void 0 : _f.call(_e);
+                        }
+                        catch (_h) {
+                            // Ignore errors if streams can't be unref'd
+                        }
+                    }
+                    keepAlive_1 = setInterval(function () {
+                        // Heartbeat - check if we should still be running
+                        if (!fs.existsSync(daemonPidPath_1)) {
+                            clearInterval(keepAlive_1);
+                            process.exit(0);
+                        }
+                    }, 5000);
+                    keepAlive_1.unref(); // Don't prevent process from exiting if no other work
                 }
-            }, 5000);
-            keepAlive.unref(); // Don't prevent process from exiting if no other work
-        }
-        const result = {
-            swarmId: swarmResult.swarmId,
-            topology: finalTopology,
-            maxAgents,
-            mcp: mcpResult ? {
-                port: mcpPort,
-                transport: mcpConfig.transportType || 'stdio'
-            } : null,
-            health: healthResult.status,
-            daemon,
-            startedAt: new Date().toISOString()
-        };
-        if (ctx.flags.format === 'json') {
-            output.printJson(result);
-        }
-        return { success: true, data: result };
-    }
-    catch (error) {
-        spinner.fail('Startup failed');
-        if (error instanceof MCPClientError) {
-            output.printError(`Failed to start: ${error.message}`);
-        }
-        else {
-            output.printError(`Unexpected error: ${String(error)}`);
+                result = {
+                    swarmId: swarmResult.swarmId,
+                    topology: finalTopology,
+                    maxAgents: maxAgents,
+                    mcp: mcpResult ? {
+                        port: mcpPort,
+                        transport: mcpConfig.transportType || 'stdio'
+                    } : null,
+                    health: healthResult.status,
+                    daemon: daemon,
+                    startedAt: new Date().toISOString()
+                };
+                if (ctx.flags.format === 'json') {
+                    output.printJson(result);
+                }
+                return [2 /*return*/, { success: true, data: result }];
+            case 8:
+                error_2 = _g.sent();
+                spinner.fail('Startup failed');
+                if (error_2 instanceof MCPClientError) {
+                    output.printError("Failed to start: " + error_2.message);
+                }
+                else {
+                    output.printError("Unexpected error: " + String(error_2));
+                }
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            case 9: return [2 /*return*/];
         }
-        return { success: false, exitCode: 1 };
-    }
-};
+    });
+}); };
 // Stop subcommand
-const stopCommand = {
+var stopCommand = {
     name: 'stop',
-    description: 'Stop the KynjalFlow system',
+    description: 'Stop the RuFlo system',
     options: [
         {
             name: 'force',
             short: 'f',
             description: 'Force stop without graceful shutdown',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'timeout',
             description: 'Shutdown timeout in seconds',
             type: 'number',
-            default: 30
+            "default": 30
         }
     ],
-    action: async (ctx) => {
-        const force = ctx.flags.force;
-        const timeout = ctx.flags.timeout;
-        output.writeln();
-        output.writeln(output.bold('Stopping KynjalFlow'));
-        output.writeln();
-        if (!force && ctx.interactive) {
-            const confirmed = await confirm({
-                message: 'Are you sure you want to stop KynjalFlow?',
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
-            }
-        }
-        const spinner = output.createSpinner({ text: 'Stopping system...' });
-        spinner.start();
-        try {
-            // Stop MCP server
-            spinner.setText('Stopping MCP server...');
-            try {
-                await callMCPTool('mcp_stop', { graceful: !force, timeout });
-                spinner.succeed('MCP server stopped');
-            }
-            catch {
-                spinner.fail('MCP server was not running');
-            }
-            // Stop swarm
-            spinner.setText('Stopping swarm...');
-            spinner.start();
-            try {
-                await callMCPTool('swarm_stop', {
-                    graceful: !force,
-                    timeout,
-                    saveState: true
-                });
-                spinner.succeed('Swarm stopped');
-            }
-            catch {
-                spinner.fail('Swarm was not running');
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var force, timeout, confirmed, spinner, _a, _b, daemonPidPath, error_3;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    force = ctx.flags.force;
+                    timeout = ctx.flags.timeout;
+                    output.writeln();
+                    output.writeln(output.bold('Stopping RuFlo'));
+                    output.writeln();
+                    if (!(!force && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirm({
+                            message: 'Are you sure you want to stop RuFlo?',
+                            "default": false
+                        })];
+                case 1:
+                    confirmed = _c.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _c.label = 2;
+                case 2:
+                    spinner = output.createSpinner({ text: 'Stopping system...' });
+                    spinner.start();
+                    _c.label = 3;
+                case 3:
+                    _c.trys.push([3, 12, , 13]);
+                    // Stop MCP server
+                    spinner.setText('Stopping MCP server...');
+                    _c.label = 4;
+                case 4:
+                    _c.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, callMCPTool('mcp_stop', { graceful: !force, timeout: timeout })];
+                case 5:
+                    _c.sent();
+                    spinner.succeed('MCP server stopped');
+                    return [3 /*break*/, 7];
+                case 6:
+                    _a = _c.sent();
+                    spinner.fail('MCP server was not running');
+                    return [3 /*break*/, 7];
+                case 7:
+                    // Stop swarm
+                    spinner.setText('Stopping swarm...');
+                    spinner.start();
+                    _c.label = 8;
+                case 8:
+                    _c.trys.push([8, 10, , 11]);
+                    return [4 /*yield*/, callMCPTool('swarm_stop', {
+                            graceful: !force,
+                            timeout: timeout,
+                            saveState: true
+                        })];
+                case 9:
+                    _c.sent();
+                    spinner.succeed('Swarm stopped');
+                    return [3 /*break*/, 11];
+                case 10:
+                    _b = _c.sent();
+                    spinner.fail('Swarm was not running');
+                    return [3 /*break*/, 11];
+                case 11:
+                    daemonPidPath = path.join(ctx.cwd, '.claude-flow', 'daemon.pid');
+                    if (fs.existsSync(daemonPidPath)) {
+                        fs.unlinkSync(daemonPidPath);
+                    }
+                    output.writeln();
+                    output.printSuccess('RuFlo stopped successfully');
+                    return [2 /*return*/, {
+                            success: true,
+                            data: { stopped: true, force: force, stoppedAt: new Date().toISOString() }
+                        }];
+                case 12:
+                    error_3 = _c.sent();
+                    spinner.fail('Stop failed');
+                    output.printError("Failed to stop: " + (error_3 instanceof Error ? error_3.message : String(error_3)));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 13: return [2 /*return*/];
             }
-            // Clean up daemon PID
-            const daemonPidPath = path.join(ctx.cwd, '.claude-flow', 'daemon.pid');
-            if (fs.existsSync(daemonPidPath)) {
-                fs.unlinkSync(daemonPidPath);
-            }
-            output.writeln();
-            output.printSuccess('KynjalFlow stopped successfully');
-            return {
-                success: true,
-                data: { stopped: true, force, stoppedAt: new Date().toISOString() }
-            };
-        }
-        catch (error) {
-            spinner.fail('Stop failed');
-            output.printError(`Failed to stop: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    }
+        });
+    }); }
 };
 // Restart subcommand
-const restartCommand = {
+var restartCommand = {
     name: 'restart',
-    description: 'Restart the KynjalFlow system',
+    description: 'Restart the RuFlo system',
     options: [
         {
             name: 'force',
             short: 'f',
             description: 'Force restart',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('Restarting KynjalFlow'));
-        output.writeln();
-        // Stop first
-        const stopCtx = { ...ctx, flags: { ...ctx.flags } };
-        const stopResult = await stopCommand.action(stopCtx);
-        if (stopResult && !stopResult.success) {
-            output.printWarning('Stop failed, attempting to start anyway...');
-        }
-        // Wait briefly
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        // Start again
-        const startResult = await startAction(ctx);
-        return {
-            success: startResult.success,
-            data: {
-                restarted: startResult.success,
-                restartedAt: new Date().toISOString()
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var stopCtx, stopResult, startResult;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    output.writeln();
+                    output.writeln(output.bold('Restarting RuFlo'));
+                    output.writeln();
+                    stopCtx = __assign(__assign({}, ctx), { flags: __assign({}, ctx.flags) });
+                    return [4 /*yield*/, stopCommand.action(stopCtx)];
+                case 1:
+                    stopResult = _a.sent();
+                    if (stopResult && !stopResult.success) {
+                        output.printWarning('Stop failed, attempting to start anyway...');
+                    }
+                    // Wait briefly
+                    return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 1000); })];
+                case 2:
+                    // Wait briefly
+                    _a.sent();
+                    return [4 /*yield*/, startAction(ctx)];
+                case 3:
+                    startResult = _a.sent();
+                    return [2 /*return*/, {
+                            success: startResult.success,
+                            data: {
+                                restarted: startResult.success,
+                                restartedAt: new Date().toISOString()
+                            }
+                        }];
             }
-        };
-    }
+        });
+    }); }
 };
 // Quick start subcommand
-const quickCommand = {
+var quickCommand = {
     name: 'quick',
     aliases: ['q'],
     description: 'Quick start with default settings',
-    action: async (ctx) => {
-        // Initialize if needed
-        if (!isInitialized(ctx.cwd)) {
-            output.printInfo('Project not initialized, running init first...');
-            output.writeln();
-            // Call init with minimal settings
-            const { initCommand } = await import('./init.js');
-            const initCtx = {
-                ...ctx,
-                flags: { ...ctx.flags, minimal: true }
-            };
-            await initCommand.action(initCtx);
-            output.writeln();
-        }
-        // Start with defaults
-        return startAction({
-            ...ctx,
-            flags: { ...ctx.flags, topology: 'mesh' }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var initCommand, initCtx;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (!!isInitialized(ctx.cwd)) return [3 /*break*/, 3];
+                    output.printInfo('Project not initialized, running init first...');
+                    output.writeln();
+                    return [4 /*yield*/, import('./init.js')];
+                case 1:
+                    initCommand = (_a.sent()).initCommand;
+                    initCtx = __assign(__assign({}, ctx), { flags: __assign(__assign({}, ctx.flags), { minimal: true }) });
+                    return [4 /*yield*/, initCommand.action(initCtx)];
+                case 2:
+                    _a.sent();
+                    output.writeln();
+                    _a.label = 3;
+                case 3: 
+                // Start with defaults
+                return [2 /*return*/, startAction(__assign(__assign({}, ctx), { flags: __assign(__assign({}, ctx.flags), { topology: 'mesh' }) }))];
+            }
         });
-    }
+    }); }
 };
 // Main start command
-export const startCommand = {
+export var startCommand = {
     name: 'start',
-    description: 'Start the KynjalFlow orchestration system',
+    description: 'Start the RuFlo orchestration system',
     subcommands: [stopCommand, restartCommand, quickCommand],
     options: [
         {
@@ -380,14 +477,14 @@ export const startCommand = {
             short: 'd',
             description: 'Run as daemon in background',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'port',
             short: 'p',
             description: 'MCP server port',
             type: 'number',
-            default: DEFAULT_PORT
+            "default": DEFAULT_PORT
         },
         {
             name: 'topology',
@@ -400,7 +497,7 @@ export const startCommand = {
             name: 'skip-mcp',
             description: 'Skip starting MCP server',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
     examples: [