kynjal-cli 4.0.0 → 4.0.1

package/dist/src/index.js

@@ -4,51 +4,6 @@
  *
  * Created with ❤️ by ruv.io
  */
-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 };
-    }
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
@@ -60,285 +15,267 @@ import { runStartupUpdateCheck } from './update/index.js';
 // Read version from package.json at runtime
 function getPackageVersion() {
     try {
-        var __filename = fileURLToPath(import.meta.url);
-        var __dirname = dirname(__filename);
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
         // Navigate from dist/src to package root
-        var pkgPath = join(__dirname, '..', '..', 'package.json');
-        var pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const pkgPath = join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
         return pkg.version || '3.0.0';
     }
-    catch (_a) {
+    catch {
         return '3.0.0';
     }
 }
-export var VERSION = getPackageVersion();
+export const VERSION = getPackageVersion();
 /**
  * V3 CLI Application
  */
-var CLI = /** @class */ (function () {
-    function CLI(options) {
-        if (options === void 0) { options = {}; }
-        var _a, _b;
+export class CLI {
+    name;
+    description;
+    version;
+    parser;
+    output;
+    interactive;
+    constructor(options = {}) {
         this.name = options.name || 'ruflo';
         this.description = options.description || 'RuFlo V3 - AI Agent Orchestration Platform';
         this.version = options.version || VERSION;
         this.parser = commandParser;
         this.output = output;
-        this.interactive = (_b = (_a = options.interactive) !== null && _a !== void 0 ? _a : process.stdin.isTTY) !== null && _b !== void 0 ? _b : false;
+        this.interactive = options.interactive ?? process.stdin.isTTY ?? false;
         // Register all commands
-        for (var _i = 0, commands_1 = commands; _i < commands_1.length; _i++) {
-            var cmd = commands_1[_i];
+        for (const cmd of commands) {
             this.parser.registerCommand(cmd);
         }
     }
     /**
      * Run the CLI with given arguments
      */
-    CLI.prototype.run = function (args) {
-        if (args === void 0) { args = process.argv.slice(2); }
-        return __awaiter(this, void 0, Promise, function () {
-            var parseResult, commandPath, flags, positional, potentialCommand, attemptedCommand, availableCommands, message, commandName, command, availableCommands, message, targetCommand, subcommandArgs, subcommandName_1, subcommand, nestedName_1, nestedSubcommand, subcommandName_2, subcommand, nestedName_2, nestedSubcommand, validationErrors, _i, validationErrors_1, error, ctx, startTime, result, error_1, errorMessage;
-            var _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 11, , 12]);
-                        parseResult = this.parser.parse(args);
-                        commandPath = parseResult.command, flags = parseResult.flags, positional = parseResult.positional;
-                        // Handle global flags
-                        if (flags.version || flags.V) {
-                            this.showVersion();
-                            return [2 /*return*/];
-                        }
-                        if (flags.noColor) {
-                            this.output.setColorEnabled(false);
-                        }
-                        // Set verbosity level based on flags
-                        if (flags.quiet) {
-                            this.output.setVerbosity('quiet');
-                        }
-                        else if (flags.verbose) {
-                            this.output.setVerbosity(process.env.DEBUG ? 'debug' : 'verbose');
-                        }
-                        // Verbose mode: show parsed arguments
-                        if (this.output.isVerbose()) {
-                            this.output.printDebug("Command: " + (commandPath.join(' ') || '(none)'));
-                            this.output.printDebug("Positional: [" + positional.join(', ') + "]");
-                            this.output.printDebug("Flags: " + JSON.stringify(Object.fromEntries(Object.entries(flags).filter(function (_a) {
-                                var k = _a[0];
-                                return k !== '_';
-                            }))));
-                            this.output.printDebug("CWD: " + process.cwd());
-                        }
-                        // Run startup update check (non-blocking, silent on skip)
-                        if (!flags.noUpdate && commandPath[0] !== 'update') {
-                            this.checkForUpdatesOnStartup()["catch"](function () { });
-                        }
-                        // Handle lazy-loaded commands that weren't recognized by the parser
-                        // If commandPath is empty but positional has a command name, check if it's lazy-loadable
-                        if (commandPath.length === 0 && positional.length > 0 && !positional[0].startsWith('-')) {
-                            potentialCommand = positional[0];
-                            if (hasCommand(potentialCommand)) {
-                                // This is a lazy-loaded command, treat it as the command
-                                commandPath.push(potentialCommand);
-                                positional.shift();
-                            }
-                        }
-                        if (!(commandPath.length === 0 || flags.help || flags.h)) return [3 /*break*/, 4];
-                        if (!(commandPath.length > 0)) return [3 /*break*/, 2];
-                        // Show command-specific help
-                        return [4 /*yield*/, this.showCommandHelp(commandPath[0])];
-                    case 1:
-                        // Show command-specific help
-                        _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        if (positional.length > 0 && !positional[0].startsWith('-')) {
-                            attemptedCommand = positional[0];
-                            this.output.printError("Unknown command: " + attemptedCommand);
-                            availableCommands = Array.from(new Set(__spreadArray(__spreadArray([], commands.map(function (c) { return c.name; }), true), getCommandNames(), true)));
-                            message = suggestCommand(attemptedCommand, availableCommands).message;
-                            this.output.writeln(this.output.dim("  " + message));
-                            process.exit(1);
-                        }
-                        else {
-                            this.showHelp();
-                        }
-                        _b.label = 3;
-                    case 3: return [2 /*return*/];
-                    case 4:
-                        commandName = commandPath[0];
-                        command = this.parser.getCommand(commandName) || getCommand(commandName);
-                        if (!(!command && hasCommand(commandName))) return [3 /*break*/, 6];
-                        return [4 /*yield*/, getCommandAsync(commandName)];
-                    case 5:
-                        command = _b.sent();
-                        _b.label = 6;
-                    case 6:
-                        if (!command) {
-                            this.output.printError("Unknown command: " + commandName);
-                            availableCommands = Array.from(new Set(__spreadArray(__spreadArray([], commands.map(function (c) { return c.name; }), true), getCommandNames(), true)));
-                            message = suggestCommand(commandName, availableCommands).message;
-                            this.output.writeln(this.output.dim("  " + message));
-                            process.exit(1);
-                        }
-                        targetCommand = command;
-                        subcommandArgs = positional;
-                        // Process command path (e.g., ['hooks', 'worker', 'list'])
-                        // Note: When parser includes subcommand in commandPath, positional already excludes it
-                        if (commandPath.length > 1 && command.subcommands) {
-                            subcommandName_1 = commandPath[1];
-                            subcommand = command.subcommands.find(function (sc) { var _a; return sc.name === subcommandName_1 || ((_a = sc.aliases) === null || _a === void 0 ? void 0 : _a.includes(subcommandName_1)); });
-                            if (subcommand) {
-                                targetCommand = subcommand;
-                                // Parser already extracted subcommand from positional, so use as-is
-                                subcommandArgs = positional;
-                                // Check for nested subcommand (level 2)
-                                if (commandPath.length > 2 && subcommand.subcommands) {
-                                    nestedName_1 = commandPath[2];
-                                    nestedSubcommand = subcommand.subcommands.find(function (sc) { var _a; return sc.name === nestedName_1 || ((_a = sc.aliases) === null || _a === void 0 ? void 0 : _a.includes(nestedName_1)); });
-                                    if (nestedSubcommand) {
-                                        targetCommand = nestedSubcommand;
-                                        // Parser already extracted nested subcommand too
-                                        subcommandArgs = positional;
-                                    }
-                                }
-                            }
-                        }
-                        else if (positional.length > 0 && command.subcommands) {
-                            subcommandName_2 = positional[0];
-                            subcommand = command.subcommands.find(function (sc) { var _a; return sc.name === subcommandName_2 || ((_a = sc.aliases) === null || _a === void 0 ? void 0 : _a.includes(subcommandName_2)); });
-                            if (subcommand) {
-                                targetCommand = subcommand;
-                                subcommandArgs = positional.slice(1);
-                                // Check for nested subcommand (level 2 from positional)
-                                if (subcommandArgs.length > 0 && subcommand.subcommands) {
-                                    nestedName_2 = subcommandArgs[0];
-                                    nestedSubcommand = subcommand.subcommands.find(function (sc) { var _a; return sc.name === nestedName_2 || ((_a = sc.aliases) === null || _a === void 0 ? void 0 : _a.includes(nestedName_2)); });
-                                    if (nestedSubcommand) {
-                                        targetCommand = nestedSubcommand;
-                                        subcommandArgs = subcommandArgs.slice(1);
-                                    }
-                                }
-                            }
-                        }
-                        validationErrors = this.parser.validateFlags(flags, targetCommand);
-                        if (validationErrors.length > 0) {
-                            for (_i = 0, validationErrors_1 = validationErrors; _i < validationErrors_1.length; _i++) {
-                                error = validationErrors_1[_i];
-                                this.output.printError(error);
-                            }
-                            process.exit(1);
-                        }
-                        _a = {
-                            args: subcommandArgs,
-                            flags: flags
-                        };
-                        return [4 /*yield*/, this.loadConfig(flags.config)];
-                    case 7:
-                        ctx = (_a.config = _b.sent(),
-                            _a.cwd = process.cwd(),
-                            _a.interactive = this.interactive && !flags.quiet,
-                            _a);
-                        if (!targetCommand.action) return [3 /*break*/, 9];
-                        if (this.output.isVerbose()) {
-                            this.output.printDebug("Executing: " + targetCommand.name);
-                        }
-                        startTime = Date.now();
-                        return [4 /*yield*/, targetCommand.action(ctx)];
-                    case 8:
-                        result = _b.sent();
-                        if (this.output.isVerbose()) {
-                            this.output.printDebug("Completed in " + (Date.now() - startTime) + "ms");
-                        }
-                        if (result && !result.success) {
-                            process.exit(result.exitCode || 1);
+    async run(args = process.argv.slice(2)) {
+        try {
+            // Parse arguments
+            const parseResult = this.parser.parse(args);
+            const { command: commandPath, flags, positional } = parseResult;
+            // Handle global flags
+            if (flags.version || flags.V) {
+                this.showVersion();
+                return;
+            }
+            if (flags.noColor) {
+                this.output.setColorEnabled(false);
+            }
+            // Set verbosity level based on flags
+            if (flags.quiet) {
+                this.output.setVerbosity('quiet');
+            }
+            else if (flags.verbose) {
+                this.output.setVerbosity(process.env.DEBUG ? 'debug' : 'verbose');
+            }
+            // Verbose mode: show parsed arguments
+            if (this.output.isVerbose()) {
+                this.output.printDebug(`Command: ${commandPath.join(' ') || '(none)'}`);
+                this.output.printDebug(`Positional: [${positional.join(', ')}]`);
+                this.output.printDebug(`Flags: ${JSON.stringify(Object.fromEntries(Object.entries(flags).filter(([k]) => k !== '_')))}`);
+                this.output.printDebug(`CWD: ${process.cwd()}`);
+            }
+            // Run startup update check (non-blocking, silent on skip)
+            if (!flags.noUpdate && commandPath[0] !== 'update') {
+                this.checkForUpdatesOnStartup().catch(() => { });
+            }
+            // Handle lazy-loaded commands that weren't recognized by the parser
+            // If commandPath is empty but positional has a command name, check if it's lazy-loadable
+            if (commandPath.length === 0 && positional.length > 0 && !positional[0].startsWith('-')) {
+                const potentialCommand = positional[0];
+                if (hasCommand(potentialCommand)) {
+                    // This is a lazy-loaded command, treat it as the command
+                    commandPath.push(potentialCommand);
+                    positional.shift();
+                }
+            }
+            // No command - show help or suggest correction
+            if (commandPath.length === 0 || flags.help || flags.h) {
+                if (commandPath.length > 0) {
+                    // Show command-specific help
+                    await this.showCommandHelp(commandPath[0]);
+                }
+                else if (positional.length > 0 && !positional[0].startsWith('-')) {
+                    // First positional looks like an attempted command - suggest correction
+                    const attemptedCommand = positional[0];
+                    this.output.printError(`Unknown command: ${attemptedCommand}`);
+                    const availableCommands = Array.from(new Set([...commands.map(c => c.name), ...getCommandNames()]));
+                    const { message } = suggestCommand(attemptedCommand, availableCommands);
+                    this.output.writeln(this.output.dim(`  ${message}`));
+                    process.exit(1);
+                }
+                else {
+                    this.showHelp();
+                }
+                return;
+            }
+            // Find and execute command
+            const commandName = commandPath[0];
+            // First check the parser's registry (for dynamically registered commands)
+            // Then fall back to the static registry, then try lazy loading
+            let command = this.parser.getCommand(commandName) || getCommand(commandName);
+            // If not found in sync registry, try lazy loading
+            if (!command && hasCommand(commandName)) {
+                command = await getCommandAsync(commandName);
+            }
+            if (!command) {
+                this.output.printError(`Unknown command: ${commandName}`);
+                // Smart suggestions - include lazy-loadable commands in suggestions
+                const availableCommands = Array.from(new Set([...commands.map(c => c.name), ...getCommandNames()]));
+                const { message } = suggestCommand(commandName, availableCommands);
+                this.output.writeln(this.output.dim(`  ${message}`));
+                process.exit(1);
+            }
+            // Handle subcommand (supports nested subcommands)
+            let targetCommand = command;
+            let subcommandArgs = positional;
+            // Process command path (e.g., ['hooks', 'worker', 'list'])
+            // Note: When parser includes subcommand in commandPath, positional already excludes it
+            if (commandPath.length > 1 && command.subcommands) {
+                const subcommandName = commandPath[1];
+                const subcommand = command.subcommands.find(sc => sc.name === subcommandName || sc.aliases?.includes(subcommandName));
+                if (subcommand) {
+                    targetCommand = subcommand;
+                    // Parser already extracted subcommand from positional, so use as-is
+                    subcommandArgs = positional;
+                    // Check for nested subcommand (level 2)
+                    if (commandPath.length > 2 && subcommand.subcommands) {
+                        const nestedName = commandPath[2];
+                        const nestedSubcommand = subcommand.subcommands.find(sc => sc.name === nestedName || sc.aliases?.includes(nestedName));
+                        if (nestedSubcommand) {
+                            targetCommand = nestedSubcommand;
+                            // Parser already extracted nested subcommand too
+                            subcommandArgs = positional;
                         }
-                        return [3 /*break*/, 10];
-                    case 9:
-                        // No action - show command help
-                        this.showCommandHelp(commandName);
-                        _b.label = 10;
-                    case 10: return [3 /*break*/, 12];
-                    case 11:
-                        error_1 = _b.sent();
-                        errorMessage = error_1.message;
-                        if (errorMessage && errorMessage.startsWith('process.exit:')) {
-                            throw error_1; // Re-throw so tests can capture the exit code
+                    }
+                }
+            }
+            else if (positional.length > 0 && command.subcommands) {
+                // Check if first positional is a subcommand
+                const subcommandName = positional[0];
+                const subcommand = command.subcommands.find(sc => sc.name === subcommandName || sc.aliases?.includes(subcommandName));
+                if (subcommand) {
+                    targetCommand = subcommand;
+                    subcommandArgs = positional.slice(1);
+                    // Check for nested subcommand (level 2 from positional)
+                    if (subcommandArgs.length > 0 && subcommand.subcommands) {
+                        const nestedName = subcommandArgs[0];
+                        const nestedSubcommand = subcommand.subcommands.find(sc => sc.name === nestedName || sc.aliases?.includes(nestedName));
+                        if (nestedSubcommand) {
+                            targetCommand = nestedSubcommand;
+                            subcommandArgs = subcommandArgs.slice(1);
                         }
-                        this.handleError(error_1);
-                        return [3 /*break*/, 12];
-                    case 12: return [2 /*return*/];
+                    }
                 }
-            });
-        });
-    };
+            }
+            // Validate flags
+            const validationErrors = this.parser.validateFlags(flags, targetCommand);
+            if (validationErrors.length > 0) {
+                for (const error of validationErrors) {
+                    this.output.printError(error);
+                }
+                process.exit(1);
+            }
+            // Build context
+            const ctx = {
+                args: subcommandArgs,
+                flags,
+                config: await this.loadConfig(flags.config),
+                cwd: process.cwd(),
+                interactive: this.interactive && !flags.quiet
+            };
+            // Execute command
+            if (targetCommand.action) {
+                if (this.output.isVerbose()) {
+                    this.output.printDebug(`Executing: ${targetCommand.name}`);
+                }
+                const startTime = Date.now();
+                const result = await targetCommand.action(ctx);
+                if (this.output.isVerbose()) {
+                    this.output.printDebug(`Completed in ${Date.now() - startTime}ms`);
+                }
+                if (result && !result.success) {
+                    process.exit(result.exitCode || 1);
+                }
+            }
+            else {
+                // No action - show command help
+                this.showCommandHelp(commandName);
+            }
+        }
+        catch (error) {
+            // Don't re-handle if this is a process.exit error (from mocked tests)
+            const errorMessage = error.message;
+            if (errorMessage && errorMessage.startsWith('process.exit:')) {
+                throw error; // Re-throw so tests can capture the exit code
+            }
+            this.handleError(error);
+        }
+    }
     /**
      * Show main help
      */
-    CLI.prototype.showHelp = function () {
+    showHelp() {
         this.output.writeln();
-        this.output.writeln(this.output.bold(this.name + " v" + this.version));
+        this.output.writeln(this.output.bold(`${this.name} v${this.version}`));
         this.output.writeln(this.output.dim(this.description));
         this.output.writeln();
         this.output.writeln(this.output.bold('USAGE:'));
-        this.output.writeln("  " + this.name + " <command> [subcommand] [options]");
+        this.output.writeln(`  ${this.name} <command> [subcommand] [options]`);
         this.output.writeln();
         // Primary Commands
         this.output.writeln(this.output.bold('PRIMARY COMMANDS:'));
-        for (var _i = 0, _a = commandsByCategory.primary; _i < _a.length; _i++) {
-            var cmd = _a[_i];
+        for (const cmd of commandsByCategory.primary) {
             if (cmd.hidden)
                 continue;
-            var name = cmd.name.padEnd(12);
-            this.output.writeln("  " + this.output.highlight(name) + " " + cmd.description);
+            const name = cmd.name.padEnd(12);
+            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
         }
         this.output.writeln();
         // Advanced Commands
         this.output.writeln(this.output.bold('ADVANCED COMMANDS:'));
-        for (var _b = 0, _c = commandsByCategory.advanced; _b < _c.length; _b++) {
-            var cmd = _c[_b];
+        for (const cmd of commandsByCategory.advanced) {
             if (cmd.hidden)
                 continue;
-            var name = cmd.name.padEnd(12);
-            this.output.writeln("  " + this.output.highlight(name) + " " + cmd.description);
+            const name = cmd.name.padEnd(12);
+            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
         }
         this.output.writeln();
         // Utility Commands
         this.output.writeln(this.output.bold('UTILITY COMMANDS:'));
-        for (var _d = 0, _e = commandsByCategory.utility; _d < _e.length; _d++) {
-            var cmd = _e[_d];
+        for (const cmd of commandsByCategory.utility) {
             if (cmd.hidden)
                 continue;
-            var name = cmd.name.padEnd(12);
-            this.output.writeln("  " + this.output.highlight(name) + " " + cmd.description);
+            const name = cmd.name.padEnd(12);
+            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
         }
         this.output.writeln();
         // Analysis Commands
         this.output.writeln(this.output.bold('ANALYSIS COMMANDS:'));
-        for (var _f = 0, _g = commandsByCategory.analysis; _f < _g.length; _f++) {
-            var cmd = _g[_f];
+        for (const cmd of commandsByCategory.analysis) {
             if (cmd.hidden)
                 continue;
-            var name = cmd.name.padEnd(12);
-            this.output.writeln("  " + this.output.highlight(name) + " " + cmd.description);
+            const name = cmd.name.padEnd(12);
+            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
         }
         this.output.writeln();
         // Management Commands
         this.output.writeln(this.output.bold('MANAGEMENT COMMANDS:'));
-        for (var _h = 0, _j = commandsByCategory.management; _h < _j.length; _h++) {
-            var cmd = _j[_h];
+        for (const cmd of commandsByCategory.management) {
             if (cmd.hidden)
                 continue;
-            var name = cmd.name.padEnd(12);
-            this.output.writeln("  " + this.output.highlight(name) + " " + cmd.description);
+            const name = cmd.name.padEnd(12);
+            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
         }
         this.output.writeln();
         this.output.writeln(this.output.bold('GLOBAL OPTIONS:'));
-        for (var _k = 0, _l = this.parser.getGlobalOptions(); _k < _l.length; _k++) {
-            var opt = _l[_k];
-            var flags = opt.short ? "-" + opt.short + ", --" + opt.name : "    --" + opt.name;
-            this.output.writeln("  " + flags.padEnd(25) + " " + opt.description);
+        for (const opt of this.parser.getGlobalOptions()) {
+            const flags = opt.short ? `-${opt.short}, --${opt.name}` : `    --${opt.name}`;
+            this.output.writeln(`  ${flags.padEnd(25)} ${opt.description}`);
         }
         this.output.writeln();
         this.output.writeln(this.output.bold('V3 FEATURES:'));
@@ -352,170 +289,133 @@ var CLI = /** @class */ (function () {
         ]);
         this.output.writeln();
         this.output.writeln(this.output.bold('EXAMPLES:'));
-        this.output.writeln("  " + this.name + " agent spawn -t coder              # Spawn a coder agent");
-        this.output.writeln("  " + this.name + " swarm init --v3-mode              # Initialize V3 swarm");
-        this.output.writeln("  " + this.name + " memory search -q \"auth patterns\"  # Semantic search");
-        this.output.writeln("  " + this.name + " mcp start                         # Start MCP server");
+        this.output.writeln(`  ${this.name} agent spawn -t coder              # Spawn a coder agent`);
+        this.output.writeln(`  ${this.name} swarm init --v3-mode              # Initialize V3 swarm`);
+        this.output.writeln(`  ${this.name} memory search -q "auth patterns"  # Semantic search`);
+        this.output.writeln(`  ${this.name} mcp start                         # Start MCP server`);
         this.output.writeln();
-        this.output.writeln(this.output.dim("Run \"" + this.name + " <command> --help\" for command help"));
+        this.output.writeln(this.output.dim(`Run "${this.name} <command> --help" for command help`));
         this.output.writeln();
         this.output.writeln(this.output.dim('Created with ❤️ by ruv.io'));
         this.output.writeln();
-    };
+    }
     /**
      * Show command-specific help
      */
-    CLI.prototype.showCommandHelp = function (commandName) {
-        return __awaiter(this, void 0, Promise, function () {
-            var command, _i, _a, sub, name, aliases, _b, _c, opt, flags, required, defaultVal, _d, _e, example;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
-                    case 0:
-                        command = getCommand(commandName);
-                        if (!(!command && hasCommand(commandName))) return [3 /*break*/, 2];
-                        return [4 /*yield*/, getCommandAsync(commandName)];
-                    case 1:
-                        command = _f.sent();
-                        _f.label = 2;
-                    case 2:
-                        if (!command) {
-                            this.output.printError("Unknown command: " + commandName);
-                            return [2 /*return*/];
-                        }
-                        this.output.writeln();
-                        this.output.writeln(this.output.bold(this.name + " " + command.name));
-                        this.output.writeln(command.description);
-                        this.output.writeln();
-                        // Subcommands
-                        if (command.subcommands && command.subcommands.length > 0) {
-                            this.output.writeln(this.output.bold('SUBCOMMANDS:'));
-                            for (_i = 0, _a = command.subcommands; _i < _a.length; _i++) {
-                                sub = _a[_i];
-                                if (sub.hidden)
-                                    continue;
-                                name = sub.name.padEnd(15);
-                                aliases = sub.aliases ? this.output.dim(" (" + sub.aliases.join(', ') + ")") : '';
-                                this.output.writeln("  " + this.output.highlight(name) + " " + sub.description + aliases);
-                            }
-                            this.output.writeln();
-                        }
-                        // Options
-                        if (command.options && command.options.length > 0) {
-                            this.output.writeln(this.output.bold('OPTIONS:'));
-                            for (_b = 0, _c = command.options; _b < _c.length; _b++) {
-                                opt = _c[_b];
-                                flags = opt.short ? "-" + opt.short + ", --" + opt.name : "    --" + opt.name;
-                                required = opt.required ? this.output.error(' (required)') : '';
-                                defaultVal = opt["default"] !== undefined ? this.output.dim(" [default: " + opt["default"] + "]") : '';
-                                this.output.writeln("  " + flags.padEnd(25) + " " + opt.description + required + defaultVal);
-                            }
-                            this.output.writeln();
-                        }
-                        // Examples
-                        if (command.examples && command.examples.length > 0) {
-                            this.output.writeln(this.output.bold('EXAMPLES:'));
-                            for (_d = 0, _e = command.examples; _d < _e.length; _d++) {
-                                example = _e[_d];
-                                this.output.writeln("  " + this.output.dim('$') + " " + example.command);
-                                this.output.writeln("    " + this.output.dim(example.description));
-                            }
-                            this.output.writeln();
-                        }
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
+    async showCommandHelp(commandName) {
+        // Try sync first, then lazy load
+        let command = getCommand(commandName);
+        if (!command && hasCommand(commandName)) {
+            command = await getCommandAsync(commandName);
+        }
+        if (!command) {
+            this.output.printError(`Unknown command: ${commandName}`);
+            return;
+        }
+        this.output.writeln();
+        this.output.writeln(this.output.bold(`${this.name} ${command.name}`));
+        this.output.writeln(command.description);
+        this.output.writeln();
+        // Subcommands
+        if (command.subcommands && command.subcommands.length > 0) {
+            this.output.writeln(this.output.bold('SUBCOMMANDS:'));
+            for (const sub of command.subcommands) {
+                if (sub.hidden)
+                    continue;
+                const name = sub.name.padEnd(15);
+                const aliases = sub.aliases ? this.output.dim(` (${sub.aliases.join(', ')})`) : '';
+                this.output.writeln(`  ${this.output.highlight(name)} ${sub.description}${aliases}`);
+            }
+            this.output.writeln();
+        }
+        // Options
+        if (command.options && command.options.length > 0) {
+            this.output.writeln(this.output.bold('OPTIONS:'));
+            for (const opt of command.options) {
+                const flags = opt.short ? `-${opt.short}, --${opt.name}` : `    --${opt.name}`;
+                const required = opt.required ? this.output.error(' (required)') : '';
+                const defaultVal = opt.default !== undefined ? this.output.dim(` [default: ${opt.default}]`) : '';
+                this.output.writeln(`  ${flags.padEnd(25)} ${opt.description}${required}${defaultVal}`);
+            }
+            this.output.writeln();
+        }
+        // Examples
+        if (command.examples && command.examples.length > 0) {
+            this.output.writeln(this.output.bold('EXAMPLES:'));
+            for (const example of command.examples) {
+                this.output.writeln(`  ${this.output.dim('$')} ${example.command}`);
+                this.output.writeln(`    ${this.output.dim(example.description)}`);
+            }
+            this.output.writeln();
+        }
+    }
     /**
      * Show version
      */
-    CLI.prototype.showVersion = function () {
-        this.output.writeln(this.name + " v" + this.version);
-    };
+    showVersion() {
+        this.output.writeln(`${this.name} v${this.version}`);
+    }
     /**
      * Check for updates on startup (non-blocking)
      * Shows notification if updates are available
      */
-    CLI.prototype.checkForUpdatesOnStartup = function () {
-        return __awaiter(this, void 0, Promise, function () {
-            var result, nonAutoUpdates, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, runStartupUpdateCheck({ autoUpdate: true })];
-                    case 1:
-                        result = _b.sent();
-                        // Show notifications for available updates that weren't auto-applied
-                        if (result.checked && result.updatesAvailable.length > 0) {
-                            nonAutoUpdates = result.updatesAvailable.filter(function (u) { return !u.shouldAutoUpdate; });
-                            if (result.updatesApplied.length > 0) {
-                                this.output.writeln(this.output.dim("Auto-updated: " + result.updatesApplied.join(', ')));
-                            }
-                            if (nonAutoUpdates.length > 0) {
-                                this.output.writeln(this.output.dim("Updates available: " + nonAutoUpdates.map(function (u) { return u.package + "@" + u.latestVersion; }).join(', ')));
-                                this.output.writeln(this.output.dim("Run '" + this.name + " update check' for details"));
-                            }
-                        }
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _a = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+    async checkForUpdatesOnStartup() {
+        try {
+            const result = await runStartupUpdateCheck({ autoUpdate: true });
+            // Show notifications for available updates that weren't auto-applied
+            if (result.checked && result.updatesAvailable.length > 0) {
+                const nonAutoUpdates = result.updatesAvailable.filter(u => !u.shouldAutoUpdate);
+                if (result.updatesApplied.length > 0) {
+                    this.output.writeln(this.output.dim(`Auto-updated: ${result.updatesApplied.join(', ')}`));
                 }
-            });
-        });
-    };
+                if (nonAutoUpdates.length > 0) {
+                    this.output.writeln(this.output.dim(`Updates available: ${nonAutoUpdates.map(u => `${u.package}@${u.latestVersion}`).join(', ')}`));
+                    this.output.writeln(this.output.dim(`Run '${this.name} update check' for details`));
+                }
+            }
+        }
+        catch {
+            // Silently fail - don't interrupt CLI usage
+        }
+    }
     /**
      * Load configuration file
      */
-    CLI.prototype.loadConfig = function (configPath) {
-        return __awaiter(this, void 0, Promise, function () {
-            var loadSystemConfig, systemConfigToV3Config, loaded, v3Config, _i, _a, warning, error_2;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 4, , 5]);
-                        return [4 /*yield*/, import('@claude-flow/shared')];
-                    case 1:
-                        loadSystemConfig = (_b.sent()).loadConfig;
-                        return [4 /*yield*/, import('./config-adapter.js')];
-                    case 2:
-                        systemConfigToV3Config = (_b.sent()).systemConfigToV3Config;
-                        return [4 /*yield*/, loadSystemConfig({
-                                file: configPath,
-                                paths: configPath ? undefined : [process.cwd()]
-                            })];
-                    case 3:
-                        loaded = _b.sent();
-                        v3Config = systemConfigToV3Config(loaded.config);
-                        // Log warnings if any
-                        if (loaded.warnings && loaded.warnings.length > 0) {
-                            for (_i = 0, _a = loaded.warnings; _i < _a.length; _i++) {
-                                warning = _a[_i];
-                                this.output.printWarning(warning);
-                            }
-                        }
-                        return [2 /*return*/, v3Config];
-                    case 4:
-                        error_2 = _b.sent();
-                        // Config loading is optional - don't fail if it doesn't exist
-                        if (process.env.DEBUG) {
-                            this.output.writeln(this.output.dim("Config loading failed: " + error_2.message));
-                        }
-                        return [2 /*return*/, undefined];
-                    case 5: return [2 /*return*/];
-                }
+    async loadConfig(configPath) {
+        try {
+            // Import config utilities
+            const { loadConfig: loadSystemConfig } = await import('@claude-flow/shared');
+            const { systemConfigToV3Config } = await import('./config-adapter.js');
+            // Load configuration
+            const loaded = await loadSystemConfig({
+                file: configPath,
+                paths: configPath ? undefined : [process.cwd()],
             });
-        });
-    };
+            // Convert to V3Config format
+            const v3Config = systemConfigToV3Config(loaded.config);
+            // Log warnings if any
+            if (loaded.warnings && loaded.warnings.length > 0) {
+                for (const warning of loaded.warnings) {
+                    this.output.printWarning(warning);
+                }
+            }
+            return v3Config;
+        }
+        catch (error) {
+            // Config loading is optional - don't fail if it doesn't exist
+            if (process.env.DEBUG) {
+                this.output.writeln(this.output.dim(`Config loading failed: ${error.message}`));
+            }
+            return undefined;
+        }
+    }
     /**
      * Handle errors
      */
-    CLI.prototype.handleError = function (error) {
+    handleError(error) {
         if ('code' in error) {
             // CLIError
-            var cliError = error;
+            const cliError = error;
             this.output.printError(cliError.message);
             if (cliError.details) {
                 this.output.writeln(this.output.dim(JSON.stringify(cliError.details, null, 2)));
@@ -531,10 +431,8 @@ var CLI = /** @class */ (function () {
             }
             process.exit(1);
         }
-    };
-    return CLI;
-}());
-export { CLI };
+    }
+}
 // =============================================================================
 // Module Exports
 // =============================================================================
@@ -543,26 +441,26 @@ export * from './types.js';
 // Parser
 export { CommandParser, commandParser } from './parser.js';
 // Output
-export { OutputFormatter, output, Progress, Spinner, type } from './output.js';
+export { OutputFormatter, output, Progress, Spinner } from './output.js';
 // Prompt
 export * from './prompt.js';
 // Commands (internal use)
 export * from './commands/index.js';
 // MCP Server management
-export { MCPServerManager, createMCPServerManager, getServerManager, startMCPServer, stopMCPServer, getMCPServerStatus, type, type, } from './mcp-server.js';
+export { MCPServerManager, createMCPServerManager, getServerManager, startMCPServer, stopMCPServer, getMCPServerStatus, } from './mcp-server.js';
 // Memory & Intelligence (V3 Performance Features)
 export { initializeMemoryDatabase, generateEmbedding, generateBatchEmbeddings, storeEntry, searchEntries, getHNSWIndex, addToHNSWIndex, searchHNSWIndex, getHNSWStatus, clearHNSWIndex, quantizeInt8, dequantizeInt8, quantizedCosineSim, getQuantizationStats, 
 // Flash Attention-style batch operations
-batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, type, } from './memory/memory-initializer.js';
+batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, } from './memory/memory-initializer.js';
 export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatterns, getIntelligenceStats, getSonaCoordinator, getReasoningBank, clearIntelligence, benchmarkAdaptation, 
 // RL loop API
 endTrajectoryWithVerdict, distillLearning, 
 // Pattern persistence API
-getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, type, type, type, type, } from './memory/intelligence.js';
+getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, } from './memory/intelligence.js';
 // EWC++ Consolidation (Prevents Catastrophic Forgetting)
-export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, type, type, type, type, } from './memory/ewc-consolidation.js';
+export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, } from './memory/ewc-consolidation.js';
 // SONA Optimizer (Adaptive Routing via Trajectory Learning)
-export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, type, type, type, type, } from './memory/sona-optimizer.js';
+export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, } from './memory/sona-optimizer.js';
 // Production Hardening
 export { ErrorHandler, withErrorHandling, } from './production/error-handler.js';
 export { RateLimiter, createRateLimiter, } from './production/rate-limiter.js';