kynjal-cli 3.1.3 → 4.0.0

package/dist/src/index.js

@@ -1,9 +1,54 @@
 /**
  * V3 CLI Main Entry Point
- * Modernized CLI for KynjalFlow V3
+ * Modernized CLI for RuFlo V3
  *
  * 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';
@@ -15,267 +60,285 @@ import { runStartupUpdateCheck } from './update/index.js';
 // Read version from package.json at runtime
 function getPackageVersion() {
     try {
-        const __filename = fileURLToPath(import.meta.url);
-        const __dirname = dirname(__filename);
+        var __filename = fileURLToPath(import.meta.url);
+        var __dirname = dirname(__filename);
         // Navigate from dist/src to package root
-        const pkgPath = join(__dirname, '..', '..', 'package.json');
-        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        var pkgPath = join(__dirname, '..', '..', 'package.json');
+        var pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
         return pkg.version || '3.0.0';
     }
-    catch {
+    catch (_a) {
         return '3.0.0';
     }
 }
-export const VERSION = getPackageVersion();
+export var VERSION = getPackageVersion();
 /**
  * V3 CLI Application
  */
-export class CLI {
-    name;
-    description;
-    version;
-    parser;
-    output;
-    interactive;
-    constructor(options = {}) {
-        this.name = options.name || 'kynjalflow';
-        this.description = options.description || 'KynjalFlow V3 - AI Agent Orchestration Platform';
+var CLI = /** @class */ (function () {
+    function CLI(options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b;
+        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 = options.interactive ?? process.stdin.isTTY ?? false;
+        this.interactive = (_b = (_a = options.interactive) !== null && _a !== void 0 ? _a : process.stdin.isTTY) !== null && _b !== void 0 ? _b : false;
         // Register all commands
-        for (const cmd of commands) {
+        for (var _i = 0, commands_1 = commands; _i < commands_1.length; _i++) {
+            var cmd = commands_1[_i];
             this.parser.registerCommand(cmd);
         }
     }
     /**
      * Run the CLI with given arguments
      */
-    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;
+    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*/];
                         }
-                    }
-                }
-            }
-            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);
+                        if (flags.noColor) {
+                            this.output.setColorEnabled(false);
                         }
-                    }
-                }
-            }
-            // 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);
+                        // 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);
+                        }
+                        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
+                        }
+                        this.handleError(error_1);
+                        return [3 /*break*/, 12];
+                    case 12: return [2 /*return*/];
                 }
-            }
-            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
      */
-    showHelp() {
+    CLI.prototype.showHelp = function () {
         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 (const cmd of commandsByCategory.primary) {
+        for (var _i = 0, _a = commandsByCategory.primary; _i < _a.length; _i++) {
+            var cmd = _a[_i];
             if (cmd.hidden)
                 continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            var 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 (const cmd of commandsByCategory.advanced) {
+        for (var _b = 0, _c = commandsByCategory.advanced; _b < _c.length; _b++) {
+            var cmd = _c[_b];
             if (cmd.hidden)
                 continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            var 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 (const cmd of commandsByCategory.utility) {
+        for (var _d = 0, _e = commandsByCategory.utility; _d < _e.length; _d++) {
+            var cmd = _e[_d];
             if (cmd.hidden)
                 continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            var 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 (const cmd of commandsByCategory.analysis) {
+        for (var _f = 0, _g = commandsByCategory.analysis; _f < _g.length; _f++) {
+            var cmd = _g[_f];
             if (cmd.hidden)
                 continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            var 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 (const cmd of commandsByCategory.management) {
+        for (var _h = 0, _j = commandsByCategory.management; _h < _j.length; _h++) {
+            var cmd = _j[_h];
             if (cmd.hidden)
                 continue;
-            const name = cmd.name.padEnd(12);
-            this.output.writeln(`  ${this.output.highlight(name)} ${cmd.description}`);
+            var 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 (const opt of this.parser.getGlobalOptions()) {
-            const flags = opt.short ? `-${opt.short}, --${opt.name}` : `    --${opt.name}`;
-            this.output.writeln(`  ${flags.padEnd(25)} ${opt.description}`);
+        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);
         }
         this.output.writeln();
         this.output.writeln(this.output.bold('V3 FEATURES:'));
@@ -289,133 +352,170 @@ export class CLI {
         ]);
         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
      */
-    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();
-        }
-    }
+    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*/];
+                }
+            });
+        });
+    };
     /**
      * Show version
      */
-    showVersion() {
-        this.output.writeln(`${this.name} v${this.version}`);
-    }
+    CLI.prototype.showVersion = function () {
+        this.output.writeln(this.name + " v" + this.version);
+    };
     /**
      * Check for updates on startup (non-blocking)
      * Shows notification if updates are available
      */
-    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`));
+    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*/];
                 }
-            }
-        }
-        catch {
-            // Silently fail - don't interrupt CLI usage
-        }
-    }
+            });
+        });
+    };
     /**
      * Load configuration file
      */
-    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);
+    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*/];
                 }
-            }
-            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
      */
-    handleError(error) {
+    CLI.prototype.handleError = function (error) {
         if ('code' in error) {
             // CLIError
-            const cliError = error;
+            var cliError = error;
             this.output.printError(cliError.message);
             if (cliError.details) {
                 this.output.writeln(this.output.dim(JSON.stringify(cliError.details, null, 2)));
@@ -431,8 +531,10 @@ export class CLI {
             }
             process.exit(1);
         }
-    }
-}
+    };
+    return CLI;
+}());
+export { CLI };
 // =============================================================================
 // Module Exports
 // =============================================================================
@@ -441,24 +543,26 @@ export * from './types.js';
 // Parser
 export { CommandParser, commandParser } from './parser.js';
 // Output
-export { OutputFormatter, output, Progress, Spinner } from './output.js';
+export { OutputFormatter, output, Progress, Spinner, type } 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, } from './mcp-server.js';
+export { MCPServerManager, createMCPServerManager, getServerManager, startMCPServer, stopMCPServer, getMCPServerStatus, type, type, } 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, } from './memory/memory-initializer.js';
+batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, type, } 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, } from './memory/intelligence.js';
+getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, type, type, type, type, } from './memory/intelligence.js';
 // EWC++ Consolidation (Prevents Catastrophic Forgetting)
-export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, } from './memory/ewc-consolidation.js';
+export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, type, type, type, type, } from './memory/ewc-consolidation.js';
 // SONA Optimizer (Adaptive Routing via Trajectory Learning)
-export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, } from './memory/sona-optimizer.js';
+export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, type, type, type, type, } from './memory/sona-optimizer.js';
 // Production Hardening
 export { ErrorHandler, withErrorHandling, } from './production/error-handler.js';
 export { RateLimiter, createRateLimiter, } from './production/rate-limiter.js';