kynjal-cli 3.1.4 → 4.0.0

package/dist/src/commands/init.js

@@ -1,741 +1,879 @@
 /**
  * V3 CLI Init Command
- * Comprehensive initialization for KynjalFlow with Claude Code integration
+ * Comprehensive initialization for Claude Flow with Claude Code integration
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { confirm, select, multiSelect, input } from '../prompt.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { executeInit, executeUpgrade, executeUpgradeWithMissing, DEFAULT_INIT_OPTIONS, MINIMAL_INIT_OPTIONS, FULL_INIT_OPTIONS, } from '../init/index.js';
 // Codex initialization action
-async function initCodexAction(ctx, options) {
-    const { force, minimal, full, dualMode } = options;
-    output.writeln();
-    output.writeln(output.bold('Initializing KynjalFlow V3 for OpenAI Codex'));
-    output.writeln();
-    // Determine template
-    const template = minimal ? 'minimal' : full ? 'full' : 'default';
-    const spinner = output.createSpinner({ text: 'Initializing Codex project...' });
-    spinner.start();
-    try {
-        // Dynamic import of the Codex initializer with lazy loading fallback
-        let CodexInitializer;
-        // Try multiple resolution strategies for the @claude-flow/codex package
-        const resolutionStrategies = [
-            // Strategy 1: Direct import (works if installed as CLI dependency)
-            async () => (await import('@claude-flow/codex')).CodexInitializer,
-            // Strategy 2: Project node_modules (works if installed in user's project)
-            async () => {
-                const projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(projectPath)) {
-                    const mod = await import(`file://${projectPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found in project');
-            },
-            // Strategy 3: Global node_modules
-            async () => {
-                const { execSync } = await import('child_process');
-                const globalPath = execSync('npm root -g', { encoding: 'utf-8' }).trim();
-                const codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
-                if (fs.existsSync(codexPath)) {
-                    const mod = await import(`file://${codexPath}`);
-                    return mod.CodexInitializer;
-                }
-                throw new Error('Not found globally');
-            },
-        ];
-        for (const strategy of resolutionStrategies) {
-            try {
-                CodexInitializer = await strategy();
-                if (CodexInitializer)
-                    break;
+function initCodexAction(ctx, options) {
+    return __awaiter(this, void 0, Promise, function () {
+        var force, minimal, full, dualMode, template, spinner, CodexInitializer, codexModuleId_1, resolutionStrategies, _i, resolutionStrategies_1, strategy, _a, initializer, result, _b, _c, error, summary, _d, _e, warning, error_1, errorMessage;
+        var _this = this;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    force = options.force, minimal = options.minimal, full = options.full, dualMode = options.dualMode;
+                    output.writeln();
+                    output.writeln(output.bold('Initializing RuFlo V3 for OpenAI Codex'));
+                    output.writeln();
+                    template = minimal ? 'minimal' : full ? 'full' : 'default';
+                    spinner = output.createSpinner({ text: 'Initializing Codex project...' });
+                    spinner.start();
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 9, , 10]);
+                    CodexInitializer = void 0;
+                    codexModuleId_1 = '@claude-flow/codex';
+                    resolutionStrategies = [
+                        // Strategy 1: Direct import (works if installed as CLI dependency)
+                        function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) {
+                            switch (_a.label) {
+                                case 0: return [4 /*yield*/, import(codexModuleId_1)];
+                                case 1: return [2 /*return*/, (_a.sent()).CodexInitializer];
+                            }
+                        }); }); },
+                        // Strategy 2: Project node_modules (works if installed in user's project)
+                        function () { return __awaiter(_this, void 0, void 0, function () {
+                            var projectPath, mod;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        projectPath = path.join(ctx.cwd, 'node_modules', '@claude-flow', 'codex', 'dist', 'index.js');
+                                        if (!fs.existsSync(projectPath)) return [3 /*break*/, 2];
+                                        return [4 /*yield*/, import("file://" + projectPath)];
+                                    case 1:
+                                        mod = _a.sent();
+                                        return [2 /*return*/, mod.CodexInitializer];
+                                    case 2: throw new Error('Not found in project');
+                                }
+                            });
+                        }); },
+                        // Strategy 3: Global node_modules
+                        function () { return __awaiter(_this, void 0, void 0, function () {
+                            var execSync, globalPath, codexPath, mod;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, import('child_process')];
+                                    case 1:
+                                        execSync = (_a.sent()).execSync;
+                                        globalPath = execSync('npm root -g', { encoding: 'utf-8' }).trim();
+                                        codexPath = path.join(globalPath, '@claude-flow', 'codex', 'dist', 'index.js');
+                                        if (!fs.existsSync(codexPath)) return [3 /*break*/, 3];
+                                        return [4 /*yield*/, import("file://" + codexPath)];
+                                    case 2:
+                                        mod = _a.sent();
+                                        return [2 /*return*/, mod.CodexInitializer];
+                                    case 3: throw new Error('Not found globally');
+                                }
+                            });
+                        }); },
+                    ];
+                    _i = 0, resolutionStrategies_1 = resolutionStrategies;
+                    _f.label = 2;
+                case 2:
+                    if (!(_i < resolutionStrategies_1.length)) return [3 /*break*/, 7];
+                    strategy = resolutionStrategies_1[_i];
+                    _f.label = 3;
+                case 3:
+                    _f.trys.push([3, 5, , 6]);
+                    return [4 /*yield*/, strategy()];
+                case 4:
+                    CodexInitializer = _f.sent();
+                    if (CodexInitializer)
+                        return [3 /*break*/, 7];
+                    return [3 /*break*/, 6];
+                case 5:
+                    _a = _f.sent();
+                    return [3 /*break*/, 6];
+                case 6:
+                    _i++;
+                    return [3 /*break*/, 2];
+                case 7:
+                    if (!CodexInitializer) {
+                        throw new Error('Cannot find module @claude-flow/codex');
+                    }
+                    initializer = new CodexInitializer();
+                    return [4 /*yield*/, initializer.initialize({
+                            projectPath: ctx.cwd,
+                            template: template,
+                            force: force,
+                            dual: dualMode
+                        })];
+                case 8:
+                    result = _f.sent();
+                    if (!result.success) {
+                        spinner.fail('Codex initialization failed');
+                        if (result.errors) {
+                            for (_b = 0, _c = result.errors; _b < _c.length; _b++) {
+                                error = _c[_b];
+                                output.printError(error);
+                            }
+                        }
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed('Codex project initialized successfully!');
+                    output.writeln();
+                    summary = [];
+                    summary.push("Files: " + result.filesCreated.length + " created");
+                    summary.push("Skills: " + result.skillsGenerated.length + " installed");
+                    output.printBox(summary.join('\n'), 'Summary');
+                    output.writeln();
+                    // Show what was created
+                    output.printBox([
+                        "AGENTS.md:     Main project instructions",
+                        ".agents/config.toml: Project configuration",
+                        ".agents/skills/: " + result.skillsGenerated.length + " skills",
+                        ".codex/: Local overrides (gitignored)",
+                        dualMode ? "CLAUDE.md: Claude Code compatibility" : '',
+                    ].filter(Boolean).join('\n'), 'OpenAI Codex Integration');
+                    output.writeln();
+                    // Warnings
+                    if (result.warnings && result.warnings.length > 0) {
+                        output.printWarning('Warnings:');
+                        for (_d = 0, _e = result.warnings.slice(0, 5); _d < _e.length; _d++) {
+                            warning = _e[_d];
+                            output.printInfo("  \u2022 " + warning);
+                        }
+                        if (result.warnings.length > 5) {
+                            output.printInfo("  ... and " + (result.warnings.length - 5) + " more");
+                        }
+                        output.writeln();
+                    }
+                    // Next steps
+                    output.writeln(output.bold('Next steps:'));
+                    output.printList([
+                        "Review " + output.highlight('AGENTS.md') + " for project instructions",
+                        "Add skills with " + output.highlight('$skill-name') + " syntax",
+                        "Configure " + output.highlight('.agents/config.toml') + " for your project",
+                        dualMode ? "Claude Code users can use " + output.highlight('CLAUDE.md') : '',
+                    ].filter(Boolean));
+                    return [2 /*return*/, { success: true, data: result }];
+                case 9:
+                    error_1 = _f.sent();
+                    spinner.fail('Codex initialization failed');
+                    errorMessage = error_1 instanceof Error ? error_1.message : String(error_1);
+                    // Handle module not found error gracefully
+                    if (errorMessage.includes('Cannot find module') || errorMessage.includes('@claude-flow/codex')) {
+                        output.printError('The @claude-flow/codex package is not installed.');
+                        output.printInfo('Install it with: npm install @claude-flow/codex');
+                        output.writeln();
+                        output.printInfo('Alternatively, copy skills manually from .claude/skills/ to .agents/skills/');
+                    }
+                    else {
+                        output.printError("Failed to initialize: " + errorMessage);
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 10: return [2 /*return*/];
             }
-            catch {
-                // Try next strategy
-            }
-        }
-        if (!CodexInitializer) {
-            throw new Error('Cannot find module @claude-flow/codex');
-        }
-        const initializer = new CodexInitializer();
-        const result = await initializer.initialize({
-            projectPath: ctx.cwd,
-            template: template,
-            force,
-            dual: dualMode,
         });
-        if (!result.success) {
-            spinner.fail('Codex initialization failed');
-            if (result.errors) {
-                for (const error of result.errors) {
-                    output.printError(error);
-                }
-            }
-            return { success: false, exitCode: 1 };
-        }
-        spinner.succeed('Codex project initialized successfully!');
-        output.writeln();
-        // Display summary
-        const summary = [];
-        summary.push(`Files: ${result.filesCreated.length} created`);
-        summary.push(`Skills: ${result.skillsGenerated.length} installed`);
-        output.printBox(summary.join('\n'), 'Summary');
-        output.writeln();
-        // Show what was created
-        output.printBox([
-            `AGENTS.md:     Main project instructions`,
-            `.agents/config.toml: Project configuration`,
-            `.agents/skills/: ${result.skillsGenerated.length} skills`,
-            `.codex/: Local overrides (gitignored)`,
-            dualMode ? `CLAUDE.md: Claude Code compatibility` : '',
-        ].filter(Boolean).join('\n'), 'OpenAI Codex Integration');
-        output.writeln();
-        // Warnings
-        if (result.warnings && result.warnings.length > 0) {
-            output.printWarning('Warnings:');
-            for (const warning of result.warnings.slice(0, 5)) {
-                output.printInfo(`  • ${warning}`);
-            }
-            if (result.warnings.length > 5) {
-                output.printInfo(`  ... and ${result.warnings.length - 5} more`);
-            }
-            output.writeln();
-        }
-        // Next steps
-        output.writeln(output.bold('Next steps:'));
-        output.printList([
-            `Review ${output.highlight('AGENTS.md')} for project instructions`,
-            `Add skills with ${output.highlight('$skill-name')} syntax`,
-            `Configure ${output.highlight('.agents/config.toml')} for your project`,
-            dualMode ? `Claude Code users can use ${output.highlight('CLAUDE.md')}` : '',
-        ].filter(Boolean));
-        return { success: true, data: result };
-    }
-    catch (error) {
-        spinner.fail('Codex initialization failed');
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Handle module not found error gracefully
-        if (errorMessage.includes('Cannot find module') || errorMessage.includes('@claude-flow/codex')) {
-            output.printError('The @claude-flow/codex package is not installed.');
-            output.printInfo('Install it with: npm install @claude-flow/codex');
-            output.writeln();
-            output.printInfo('Alternatively, copy skills manually from .claude/skills/ to .agents/skills/');
-        }
-        else {
-            output.printError(`Failed to initialize: ${errorMessage}`);
-        }
-        return { success: false, exitCode: 1 };
-    }
+    });
 }
 // Check if project is already initialized
 function isInitialized(cwd) {
-    const claudePath = path.join(cwd, '.claude', 'settings.json');
-    const claudeFlowPath = path.join(cwd, '.claude-flow', 'config.yaml');
+    var claudePath = path.join(cwd, '.claude', 'settings.json');
+    var claudeFlowPath = path.join(cwd, '.claude-flow', 'config.yaml');
     return {
         claude: fs.existsSync(claudePath),
-        claudeFlow: fs.existsSync(claudeFlowPath),
+        claudeFlow: fs.existsSync(claudeFlowPath)
     };
 }
 // Init subcommand (default)
-const initAction = async (ctx) => {
-    const force = ctx.flags.force;
-    const minimal = ctx.flags.minimal;
-    const full = ctx.flags.full;
-    const skipClaude = ctx.flags['skip-claude'];
-    const onlyClaude = ctx.flags['only-claude'];
-    const codexMode = ctx.flags.codex;
-    const dualMode = ctx.flags.dual;
-    const cwd = ctx.cwd;
-    // If codex mode, use the Codex initializer
-    if (codexMode || dualMode) {
-        return initCodexAction(ctx, { codexMode, dualMode, force, minimal, full });
-    }
-    // Check if already initialized
-    const initialized = isInitialized(cwd);
-    const hasExisting = initialized.claude || initialized.claudeFlow;
-    if (hasExisting && !force) {
-        output.printWarning('KynjalFlow appears to be already initialized');
-        if (initialized.claude)
-            output.printInfo('  Found: .claude/settings.json');
-        if (initialized.claudeFlow)
-            output.printInfo('  Found: .claude-flow/config.yaml');
-        output.printInfo('Use --force to reinitialize');
-        if (ctx.interactive) {
-            const proceed = await confirm({
-                message: 'Do you want to reinitialize? This will overwrite existing configuration.',
-                default: false,
-            });
-            if (!proceed) {
-                return { success: true, message: 'Initialization cancelled' };
-            }
-        }
-        else {
-            return { success: false, exitCode: 1, message: 'Already initialized' };
-        }
-    }
-    output.writeln();
-    output.writeln(output.bold('Initializing KynjalFlow V3'));
-    output.writeln();
-    // Build init options based on flags
-    let options;
-    if (minimal) {
-        options = { ...MINIMAL_INIT_OPTIONS, targetDir: cwd, force };
-    }
-    else if (full) {
-        options = { ...FULL_INIT_OPTIONS, targetDir: cwd, force };
-    }
-    else {
-        options = { ...DEFAULT_INIT_OPTIONS, targetDir: cwd, force };
-    }
-    // Handle --skip-claude and --only-claude flags
-    if (skipClaude) {
-        options.components.settings = false;
-        options.components.skills = false;
-        options.components.commands = false;
-        options.components.agents = false;
-        options.components.helpers = false;
-        options.components.statusline = false;
-        options.components.mcp = false;
-        options.components.claudeMd = false;
-    }
-    if (onlyClaude) {
-        options.components.runtime = false;
-    }
-    // Create spinner
-    const spinner = output.createSpinner({ text: 'Initializing...' });
-    spinner.start();
-    try {
-        // Execute initialization
-        const result = await executeInit(options);
-        if (!result.success) {
-            spinner.fail('Initialization failed');
-            for (const error of result.errors) {
-                output.printError(error);
-            }
-            return { success: false, exitCode: 1 };
-        }
-        spinner.succeed('KynjalFlow V3 initialized successfully!');
-        output.writeln();
-        // Display summary
-        const summary = [];
-        if (result.created.directories.length > 0) {
-            summary.push(`Directories: ${result.created.directories.length} created`);
-        }
-        if (result.created.files.length > 0) {
-            summary.push(`Files: ${result.created.files.length} created`);
-        }
-        if (result.skipped.length > 0) {
-            summary.push(`Skipped: ${result.skipped.length} (already exist)`);
-        }
-        output.printBox(summary.join('\n'), 'Summary');
-        output.writeln();
-        // Show what was created
-        if (options.components.claudeMd || options.components.settings || options.components.skills || options.components.commands || options.components.agents) {
-            output.printBox([
-                options.components.claudeMd ? `CLAUDE.md:   Swarm guidance & configuration` : '',
-                options.components.settings ? `Settings:    .claude/settings.json` : '',
-                options.components.skills ? `Skills:      .claude/skills/ (${result.summary.skillsCount} skills)` : '',
-                options.components.commands ? `Commands:    .claude/commands/ (${result.summary.commandsCount} commands)` : '',
-                options.components.agents ? `Agents:      .claude/agents/ (${result.summary.agentsCount} agents)` : '',
-                options.components.helpers ? `Helpers:     .claude/helpers/` : '',
-                options.components.mcp ? `MCP:         .mcp.json` : '',
-            ].filter(Boolean).join('\n'), 'Claude Code Integration');
-            output.writeln();
-        }
-        if (options.components.runtime) {
-            output.printBox([
-                `Config:      .claude-flow/config.yaml`,
-                `Data:        .claude-flow/data/`,
-                `Logs:        .claude-flow/logs/`,
-                `Sessions:    .claude-flow/sessions/`,
-            ].join('\n'), 'V3 Runtime');
-            output.writeln();
-        }
-        // Hooks summary
-        if (result.summary.hooksEnabled > 0) {
-            output.printInfo(`Hooks: ${result.summary.hooksEnabled} hook types enabled in settings.json`);
-            output.writeln();
-        }
-        // Handle --start-all or --start-daemon
-        const startAll = ctx.flags['start-all'] || ctx.flags.startAll;
-        const startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
-        if (startDaemon || startAll) {
-            output.writeln();
-            output.printInfo('Starting services...');
-            const { execSync } = await import('child_process');
-            // Initialize memory database
-            if (startAll) {
-                try {
-                    output.writeln(output.dim('  Initializing memory database...'));
-                    execSync('npx @kynjal/cli@latest memory init 2>/dev/null', {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 30000
-                    });
-                    output.writeln(output.success('  ✓ Memory initialized'));
+var initAction = function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+    var force, minimal, full, skipClaude, onlyClaude, codexMode, dualMode, cwd, initialized, hasExisting, proceed, options, spinner, result, _i, _a, error, summary, startAll, startDaemon, execSync, withEmbeddings, embeddingModel, execSync, error_2;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                force = ctx.flags.force;
+                minimal = ctx.flags.minimal;
+                full = ctx.flags.full;
+                skipClaude = ctx.flags['skip-claude'];
+                onlyClaude = ctx.flags['only-claude'];
+                codexMode = ctx.flags.codex;
+                dualMode = ctx.flags.dual;
+                cwd = ctx.cwd;
+                // If codex mode, use the Codex initializer
+                if (codexMode || dualMode) {
+                    return [2 /*return*/, initCodexAction(ctx, { codexMode: codexMode, dualMode: dualMode, force: force, minimal: minimal, full: full })];
                 }
-                catch {
-                    output.writeln(output.dim('  Memory database already exists'));
+                initialized = isInitialized(cwd);
+                hasExisting = initialized.claude || initialized.claudeFlow;
+                if (!(hasExisting && !force)) return [3 /*break*/, 3];
+                output.printWarning('RuFlo appears to be already initialized');
+                if (initialized.claude)
+                    output.printInfo('  Found: .claude/settings.json');
+                if (initialized.claudeFlow)
+                    output.printInfo('  Found: .claude-flow/config.yaml');
+                output.printInfo('Use --force to reinitialize');
+                if (!ctx.interactive) return [3 /*break*/, 2];
+                return [4 /*yield*/, confirm({
+                        message: 'Do you want to reinitialize? This will overwrite existing configuration.',
+                        "default": false
+                    })];
+            case 1:
+                proceed = _b.sent();
+                if (!proceed) {
+                    return [2 /*return*/, { success: true, message: 'Initialization cancelled' }];
                 }
-            }
-            // Start daemon
-            if (startDaemon) {
-                try {
-                    output.writeln(output.dim('  Starting daemon...'));
-                    execSync('npx @kynjal/cli@latest daemon start 2>/dev/null &', {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 10000
-                    });
-                    output.writeln(output.success('  ✓ Daemon started'));
+                return [3 /*break*/, 3];
+            case 2: return [2 /*return*/, { success: false, exitCode: 1, message: 'Already initialized' }];
+            case 3:
+                output.writeln();
+                output.writeln(output.bold('Initializing RuFlo V3'));
+                output.writeln();
+                if (minimal) {
+                    options = __assign(__assign({}, MINIMAL_INIT_OPTIONS), { targetDir: cwd, force: force });
                 }
-                catch {
-                    output.writeln(output.warning('  Daemon may already be running'));
+                else if (full) {
+                    options = __assign(__assign({}, FULL_INIT_OPTIONS), { targetDir: cwd, force: force });
                 }
-            }
-            // Initialize swarm
-            if (startAll) {
+                else {
+                    options = __assign(__assign({}, DEFAULT_INIT_OPTIONS), { targetDir: cwd, force: force });
+                }
+                // Handle --skip-claude and --only-claude flags
+                if (skipClaude) {
+                    options.components.settings = false;
+                    options.components.skills = false;
+                    options.components.commands = false;
+                    options.components.agents = false;
+                    options.components.helpers = false;
+                    options.components.statusline = false;
+                    options.components.mcp = false;
+                    options.components.claudeMd = false;
+                }
+                if (onlyClaude) {
+                    options.components.runtime = false;
+                }
+                spinner = output.createSpinner({ text: 'Initializing...' });
+                spinner.start();
+                _b.label = 4;
+            case 4:
+                _b.trys.push([4, 10, , 11]);
+                return [4 /*yield*/, executeInit(options)];
+            case 5:
+                result = _b.sent();
+                if (!result.success) {
+                    spinner.fail('Initialization failed');
+                    for (_i = 0, _a = result.errors; _i < _a.length; _i++) {
+                        error = _a[_i];
+                        output.printError(error);
+                    }
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                }
+                spinner.succeed('RuFlo V3 initialized successfully!');
+                output.writeln();
+                summary = [];
+                if (result.created.directories.length > 0) {
+                    summary.push("Directories: " + result.created.directories.length + " created");
+                }
+                if (result.created.files.length > 0) {
+                    summary.push("Files: " + result.created.files.length + " created");
+                }
+                if (result.skipped.length > 0) {
+                    summary.push("Skipped: " + result.skipped.length + " (already exist)");
+                }
+                output.printBox(summary.join('\n'), 'Summary');
+                output.writeln();
+                // Show what was created
+                if (options.components.claudeMd || options.components.settings || options.components.skills || options.components.commands || options.components.agents) {
+                    output.printBox([
+                        options.components.claudeMd ? "CLAUDE.md:   Swarm guidance & configuration" : '',
+                        options.components.settings ? "Settings:    .claude/settings.json" : '',
+                        options.components.skills ? "Skills:      .claude/skills/ (" + result.summary.skillsCount + " skills)" : '',
+                        options.components.commands ? "Commands:    .claude/commands/ (" + result.summary.commandsCount + " commands)" : '',
+                        options.components.agents ? "Agents:      .claude/agents/ (" + result.summary.agentsCount + " agents)" : '',
+                        options.components.helpers ? "Helpers:     .claude/helpers/" : '',
+                        options.components.mcp ? "MCP:         .mcp.json" : '',
+                    ].filter(Boolean).join('\n'), 'Claude Code Integration');
+                    output.writeln();
+                }
+                if (options.components.runtime) {
+                    output.printBox([
+                        "Config:      .claude-flow/config.yaml",
+                        "Data:        .claude-flow/data/",
+                        "Logs:        .claude-flow/logs/",
+                        "Sessions:    .claude-flow/sessions/",
+                    ].join('\n'), 'V3 Runtime');
+                    output.writeln();
+                }
+                // Hooks summary
+                if (result.summary.hooksEnabled > 0) {
+                    output.printInfo("Hooks: " + result.summary.hooksEnabled + " hook types enabled in settings.json");
+                    output.writeln();
+                }
+                startAll = ctx.flags['start-all'] || ctx.flags.startAll;
+                startDaemon = ctx.flags['start-daemon'] || ctx.flags.startDaemon || startAll;
+                if (!(startDaemon || startAll)) return [3 /*break*/, 7];
+                output.writeln();
+                output.printInfo('Starting services...');
+                return [4 /*yield*/, import('child_process')];
+            case 6:
+                execSync = (_b.sent()).execSync;
+                // Initialize memory database
+                if (startAll) {
+                    try {
+                        output.writeln(output.dim('  Initializing memory database...'));
+                        execSync('npx @claude-flow/cli@latest memory init 2>/dev/null', {
+                            stdio: 'pipe',
+                            cwd: ctx.cwd,
+                            timeout: 30000
+                        });
+                        output.writeln(output.success('  ✓ Memory initialized'));
+                    }
+                    catch (_c) {
+                        output.writeln(output.dim('  Memory database already exists'));
+                    }
+                }
+                // Start daemon
+                if (startDaemon) {
+                    try {
+                        output.writeln(output.dim('  Starting daemon...'));
+                        execSync('npx @claude-flow/cli@latest daemon start 2>/dev/null &', {
+                            stdio: 'pipe',
+                            cwd: ctx.cwd,
+                            timeout: 10000
+                        });
+                        output.writeln(output.success('  ✓ Daemon started'));
+                    }
+                    catch (_d) {
+                        output.writeln(output.warning('  Daemon may already be running'));
+                    }
+                }
+                // Initialize swarm
+                if (startAll) {
+                    try {
+                        output.writeln(output.dim('  Initializing swarm...'));
+                        execSync('npx @claude-flow/cli@latest swarm init --topology hierarchical 2>/dev/null', {
+                            stdio: 'pipe',
+                            cwd: ctx.cwd,
+                            timeout: 30000
+                        });
+                        output.writeln(output.success('  ✓ Swarm initialized'));
+                    }
+                    catch (_e) {
+                        output.writeln(output.dim('  Swarm initialization skipped'));
+                    }
+                }
+                output.writeln();
+                output.printSuccess('All services started');
+                _b.label = 7;
+            case 7:
+                withEmbeddings = ctx.flags['with-embeddings'] || ctx.flags.withEmbeddings;
+                embeddingModel = (ctx.flags['embedding-model'] || ctx.flags.embeddingModel || 'all-MiniLM-L6-v2');
+                if (!withEmbeddings) return [3 /*break*/, 9];
+                output.writeln();
+                output.printInfo('Initializing ONNX embedding subsystem...');
+                return [4 /*yield*/, import('child_process')];
+            case 8:
+                execSync = (_b.sent()).execSync;
                 try {
-                    output.writeln(output.dim('  Initializing swarm...'));
-                    execSync('npx @kynjal/cli@latest swarm init --topology hierarchical 2>/dev/null', {
+                    output.writeln(output.dim("  Model: " + embeddingModel));
+                    output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
+                    execSync("npx @claude-flow/cli@latest embeddings init --model " + embeddingModel + " --no-download --force 2>/dev/null", {
                         stdio: 'pipe',
                         cwd: ctx.cwd,
                         timeout: 30000
                     });
-                    output.writeln(output.success('  ✓ Swarm initialized'));
+                    output.writeln(output.success('  ✓ Embeddings initialized'));
+                    output.writeln(output.dim('    Run "embeddings init --download" to download model'));
                 }
-                catch {
-                    output.writeln(output.dim('  Swarm initialization skipped'));
+                catch (err) {
+                    output.writeln(output.warning('  Embedding initialization skipped (run manually)'));
                 }
-            }
-            output.writeln();
-            output.printSuccess('All services started');
-        }
-        // Handle --with-embeddings
-        const withEmbeddings = ctx.flags['with-embeddings'] || ctx.flags.withEmbeddings;
-        const embeddingModel = (ctx.flags['embedding-model'] || ctx.flags.embeddingModel || 'all-MiniLM-L6-v2');
-        if (withEmbeddings) {
-            output.writeln();
-            output.printInfo('Initializing ONNX embedding subsystem...');
-            const { execSync } = await import('child_process');
-            try {
-                output.writeln(output.dim(`  Model: ${embeddingModel}`));
-                output.writeln(output.dim('  Hyperbolic: Enabled (Poincaré ball)'));
-                execSync(`npx @kynjal/cli@latest embeddings init --model ${embeddingModel} --no-download --force 2>/dev/null`, {
-                    stdio: 'pipe',
-                    cwd: ctx.cwd,
-                    timeout: 30000
-                });
-                output.writeln(output.success('  ✓ Embeddings initialized'));
-                output.writeln(output.dim('    Run "embeddings init --download" to download model'));
-            }
-            catch (err) {
-                output.writeln(output.warning('  Embedding initialization skipped (run manually)'));
-            }
-        }
-        if (!startDaemon && !startAll) {
-            // Next steps (only if not auto-starting)
-            output.writeln(output.bold('Next steps:'));
-            output.printList([
-                `Run ${output.highlight('claude-flow daemon start')} to start background workers`,
-                `Run ${output.highlight('claude-flow memory init')} to initialize memory database`,
-                `Run ${output.highlight('claude-flow swarm init')} to initialize a swarm`,
-                `Or use ${output.highlight('claude-flow init --start-all')} to do all of the above`,
-                options.components.settings ? `Review ${output.highlight('.claude/settings.json')} for hook configurations` : '',
-            ].filter(Boolean));
-        }
-        if (ctx.flags.format === 'json') {
-            output.printJson(result);
+                _b.label = 9;
+            case 9:
+                if (!startDaemon && !startAll) {
+                    // Next steps (only if not auto-starting)
+                    output.writeln(output.bold('Next steps:'));
+                    output.printList([
+                        "Run " + output.highlight('claude-flow daemon start') + " to start background workers",
+                        "Run " + output.highlight('claude-flow memory init') + " to initialize memory database",
+                        "Run " + output.highlight('claude-flow swarm init') + " to initialize a swarm",
+                        "Or use " + output.highlight('claude-flow init --start-all') + " to do all of the above",
+                        options.components.settings ? "Review " + output.highlight('.claude/settings.json') + " for hook configurations" : '',
+                    ].filter(Boolean));
+                }
+                if (ctx.flags.format === 'json') {
+                    output.printJson(result);
+                }
+                return [2 /*return*/, { success: true, data: result }];
+            case 10:
+                error_2 = _b.sent();
+                spinner.fail('Initialization failed');
+                output.printError("Failed to initialize: " + (error_2 instanceof Error ? error_2.message : String(error_2)));
+                return [2 /*return*/, { success: false, exitCode: 1 }];
+            case 11: return [2 /*return*/];
         }
-        return { success: true, data: result };
-    }
-    catch (error) {
-        spinner.fail('Initialization failed');
-        output.printError(`Failed to initialize: ${error instanceof Error ? error.message : String(error)}`);
-        return { success: false, exitCode: 1 };
-    }
-};
+    });
+}); };
 // Wizard subcommand for interactive setup
-const wizardCommand = {
+var wizardCommand = {
     name: 'wizard',
     description: 'Interactive setup wizard for comprehensive configuration',
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('KynjalFlow V3 Setup Wizard'));
-        output.writeln(output.dim('Answer questions to configure your project'));
-        output.writeln();
-        try {
-            // Start with base options
-            const options = { ...DEFAULT_INIT_OPTIONS, targetDir: ctx.cwd };
-            // Configuration preset
-            const preset = await select({
-                message: 'Select configuration preset:',
-                options: [
-                    { value: 'default', label: 'Default', hint: 'Recommended settings for most projects' },
-                    { value: 'minimal', label: 'Minimal', hint: 'Core features only' },
-                    { value: 'full', label: 'Full', hint: 'All features enabled' },
-                    { value: 'custom', label: 'Custom', hint: 'Choose each component' },
-                ],
-            });
-            if (preset === 'minimal') {
-                Object.assign(options, MINIMAL_INIT_OPTIONS);
-                options.targetDir = ctx.cwd;
-            }
-            else if (preset === 'full') {
-                Object.assign(options, FULL_INIT_OPTIONS);
-                options.targetDir = ctx.cwd;
-            }
-            else if (preset === 'custom') {
-                // Component selection
-                const components = await multiSelect({
-                    message: 'Select components to initialize:',
-                    options: [
-                        { value: 'claudeMd', label: 'CLAUDE.md', hint: 'Swarm guidance and project configuration', selected: true },
-                        { value: 'settings', label: 'settings.json', hint: 'Claude Code hooks configuration', selected: true },
-                        { value: 'skills', label: 'Skills', hint: 'Claude Code skills in .claude/skills/', selected: true },
-                        { value: 'commands', label: 'Commands', hint: 'Claude Code commands in .claude/commands/', selected: true },
-                        { value: 'agents', label: 'Agents', hint: 'Agent definitions in .claude/agents/', selected: true },
-                        { value: 'helpers', label: 'Helpers', hint: 'Utility scripts in .claude/helpers/', selected: true },
-                        { value: 'statusline', label: 'Statusline', hint: 'Shell statusline integration', selected: false },
-                        { value: 'mcp', label: 'MCP', hint: '.mcp.json for MCP server configuration', selected: true },
-                        { value: 'runtime', label: 'Runtime', hint: '.claude-flow/ directory for V3 runtime', selected: true },
-                    ],
-                });
-                options.components.claudeMd = components.includes('claudeMd');
-                options.components.settings = components.includes('settings');
-                options.components.skills = components.includes('skills');
-                options.components.commands = components.includes('commands');
-                options.components.agents = components.includes('agents');
-                options.components.helpers = components.includes('helpers');
-                options.components.statusline = components.includes('statusline');
-                options.components.mcp = components.includes('mcp');
-                options.components.runtime = components.includes('runtime');
-                // Skills selection
-                if (options.components.skills) {
-                    const skillSets = await multiSelect({
-                        message: 'Select skill sets:',
-                        options: [
-                            { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC skills', selected: true },
-                            { value: 'agentdb', label: 'AgentDB', hint: 'Vector database skills', selected: true },
-                            { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
-                            { value: 'flowNexus', label: 'Flow Nexus', hint: 'Cloud platform skills', selected: false },
-                            { value: 'v3', label: 'V3', hint: 'V3 implementation skills', selected: true },
-                        ],
-                    });
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var options, preset, components, skillSets, hooks, topology, maxAgents, memoryBackend, enableHNSW, enableNeural, enableSelfLearning, enableEmbeddings, embeddingModel, spinner, result, _i, _a, error, embeddingsInitialized, execSync, error_3;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    output.writeln();
+                    output.writeln(output.bold('RuFlo V3 Setup Wizard'));
+                    output.writeln(output.dim('Answer questions to configure your project'));
+                    output.writeln();
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 25, , 26]);
+                    options = __assign(__assign({}, DEFAULT_INIT_OPTIONS), { targetDir: ctx.cwd });
+                    return [4 /*yield*/, select({
+                            message: 'Select configuration preset:',
+                            options: [
+                                { value: 'default', label: 'Default', hint: 'Recommended settings for most projects' },
+                                { value: 'minimal', label: 'Minimal', hint: 'Core features only' },
+                                { value: 'full', label: 'Full', hint: 'All features enabled' },
+                                { value: 'custom', label: 'Custom', hint: 'Choose each component' },
+                            ]
+                        })];
+                case 2:
+                    preset = _b.sent();
+                    if (!(preset === 'minimal')) return [3 /*break*/, 3];
+                    Object.assign(options, MINIMAL_INIT_OPTIONS);
+                    options.targetDir = ctx.cwd;
+                    return [3 /*break*/, 9];
+                case 3:
+                    if (!(preset === 'full')) return [3 /*break*/, 4];
+                    Object.assign(options, FULL_INIT_OPTIONS);
+                    options.targetDir = ctx.cwd;
+                    return [3 /*break*/, 9];
+                case 4:
+                    if (!(preset === 'custom')) return [3 /*break*/, 9];
+                    return [4 /*yield*/, multiSelect({
+                            message: 'Select components to initialize:',
+                            options: [
+                                { value: 'claudeMd', label: 'CLAUDE.md', hint: 'Swarm guidance and project configuration', selected: true },
+                                { value: 'settings', label: 'settings.json', hint: 'Claude Code hooks configuration', selected: true },
+                                { value: 'skills', label: 'Skills', hint: 'Claude Code skills in .claude/skills/', selected: true },
+                                { value: 'commands', label: 'Commands', hint: 'Claude Code commands in .claude/commands/', selected: true },
+                                { value: 'agents', label: 'Agents', hint: 'Agent definitions in .claude/agents/', selected: true },
+                                { value: 'helpers', label: 'Helpers', hint: 'Utility scripts in .claude/helpers/', selected: true },
+                                { value: 'statusline', label: 'Statusline', hint: 'Shell statusline integration', selected: false },
+                                { value: 'mcp', label: 'MCP', hint: '.mcp.json for MCP server configuration', selected: true },
+                                { value: 'runtime', label: 'Runtime', hint: '.claude-flow/ directory for V3 runtime', selected: true },
+                            ]
+                        })];
+                case 5:
+                    components = _b.sent();
+                    options.components.claudeMd = components.includes('claudeMd');
+                    options.components.settings = components.includes('settings');
+                    options.components.skills = components.includes('skills');
+                    options.components.commands = components.includes('commands');
+                    options.components.agents = components.includes('agents');
+                    options.components.helpers = components.includes('helpers');
+                    options.components.statusline = components.includes('statusline');
+                    options.components.mcp = components.includes('mcp');
+                    options.components.runtime = components.includes('runtime');
+                    if (!options.components.skills) return [3 /*break*/, 7];
+                    return [4 /*yield*/, multiSelect({
+                            message: 'Select skill sets:',
+                            options: [
+                                { value: 'core', label: 'Core', hint: 'Swarm, memory, SPARC skills', selected: true },
+                                { value: 'agentdb', label: 'AgentDB', hint: 'Vector database skills', selected: true },
+                                { value: 'github', label: 'GitHub', hint: 'GitHub integration skills', selected: true },
+                                { value: 'flowNexus', label: 'Flow Nexus', hint: 'Cloud platform skills', selected: false },
+                                { value: 'v3', label: 'V3', hint: 'V3 implementation skills', selected: true },
+                            ]
+                        })];
+                case 6:
+                    skillSets = _b.sent();
                     options.skills.core = skillSets.includes('core');
                     options.skills.agentdb = skillSets.includes('agentdb');
                     options.skills.github = skillSets.includes('github');
                     options.skills.flowNexus = skillSets.includes('flowNexus');
                     options.skills.v3 = skillSets.includes('v3');
-                }
-                // Hooks selection
-                if (options.components.settings) {
-                    const hooks = await multiSelect({
-                        message: 'Select hooks to enable:',
-                        options: [
-                            { value: 'preToolUse', label: 'PreToolUse', hint: 'Before tool execution', selected: true },
-                            { value: 'postToolUse', label: 'PostToolUse', hint: 'After tool execution', selected: true },
-                            { value: 'userPromptSubmit', label: 'UserPromptSubmit', hint: 'Task routing', selected: true },
-                            { value: 'sessionStart', label: 'SessionStart', hint: 'Session initialization', selected: true },
-                            { value: 'stop', label: 'Stop', hint: 'Task completion evaluation', selected: true },
-                            { value: 'notification', label: 'Notification', hint: 'Swarm notifications', selected: true },
-                            { value: 'permissionRequest', label: 'PermissionRequest', hint: 'Auto-allow claude-flow tools', selected: true },
-                        ],
-                    });
+                    _b.label = 7;
+                case 7:
+                    if (!options.components.settings) return [3 /*break*/, 9];
+                    return [4 /*yield*/, multiSelect({
+                            message: 'Select hooks to enable:',
+                            options: [
+                                { value: 'preToolUse', label: 'PreToolUse', hint: 'Before tool execution', selected: true },
+                                { value: 'postToolUse', label: 'PostToolUse', hint: 'After tool execution', selected: true },
+                                { value: 'userPromptSubmit', label: 'UserPromptSubmit', hint: 'Task routing', selected: true },
+                                { value: 'sessionStart', label: 'SessionStart', hint: 'Session initialization', selected: true },
+                                { value: 'stop', label: 'Stop', hint: 'Task completion evaluation', selected: true },
+                                { value: 'notification', label: 'Notification', hint: 'Swarm notifications', selected: true },
+                                { value: 'permissionRequest', label: 'PermissionRequest', hint: 'Auto-allow claude-flow tools', selected: true },
+                            ]
+                        })];
+                case 8:
+                    hooks = _b.sent();
                     options.hooks.preToolUse = hooks.includes('preToolUse');
                     options.hooks.postToolUse = hooks.includes('postToolUse');
                     options.hooks.userPromptSubmit = hooks.includes('userPromptSubmit');
                     options.hooks.sessionStart = hooks.includes('sessionStart');
                     options.hooks.stop = hooks.includes('stop');
                     options.hooks.notification = hooks.includes('notification');
-                }
-            }
-            // Swarm topology (for all presets)
-            const topology = await select({
-                message: 'Select swarm topology:',
-                options: [
-                    { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'Best for complex projects (recommended)' },
-                    { value: 'mesh', label: 'Mesh', hint: 'Peer-to-peer coordination' },
-                    { value: 'hierarchical', label: 'Hierarchical', hint: 'Tree-based coordination' },
-                    { value: 'adaptive', label: 'Adaptive', hint: 'Dynamic topology switching' },
-                ],
-            });
-            options.runtime.topology = topology;
-            // Max agents
-            const maxAgents = await input({
-                message: 'Maximum concurrent agents:',
-                default: String(options.runtime.maxAgents),
-                validate: (v) => {
-                    const n = parseInt(v);
-                    return (!isNaN(n) && n > 0 && n <= 50) || 'Enter a number between 1 and 50';
-                },
-            });
-            options.runtime.maxAgents = parseInt(maxAgents);
-            // Memory backend
-            const memoryBackend = await select({
-                message: 'Select memory backend:',
-                options: [
-                    { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
-                    { value: 'agentdb', label: 'AgentDB', hint: '150x faster vector search' },
-                    { value: 'sqlite', label: 'SQLite', hint: 'Standard SQL storage' },
-                    { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' },
-                ],
-            });
-            options.runtime.memoryBackend = memoryBackend;
-            // HNSW indexing
-            if (memoryBackend === 'agentdb' || memoryBackend === 'hybrid') {
-                const enableHNSW = await confirm({
-                    message: 'Enable HNSW indexing for faster vector search?',
-                    default: true,
-                });
-                options.runtime.enableHNSW = enableHNSW;
-            }
-            // Neural learning
-            const enableNeural = await confirm({
-                message: 'Enable neural pattern learning?',
-                default: options.runtime.enableNeural,
-            });
-            options.runtime.enableNeural = enableNeural;
-            // ADR-049: Self-Learning Memory capabilities
-            if (memoryBackend === 'agentdb' || memoryBackend === 'hybrid') {
-                const enableSelfLearning = await confirm({
-                    message: 'Enable self-learning memory? (LearningBridge + Knowledge Graph + Agent Scopes)',
-                    default: true,
-                });
-                options.runtime.enableLearningBridge = enableSelfLearning && enableNeural;
-                options.runtime.enableMemoryGraph = enableSelfLearning;
-                options.runtime.enableAgentScopes = enableSelfLearning;
-            }
-            else {
-                options.runtime.enableLearningBridge = false;
-                options.runtime.enableMemoryGraph = false;
-                options.runtime.enableAgentScopes = false;
-            }
-            // Embeddings configuration
-            const enableEmbeddings = await confirm({
-                message: 'Enable ONNX embedding system with hyperbolic support?',
-                default: true,
-            });
-            let embeddingModel = 'all-MiniLM-L6-v2';
-            if (enableEmbeddings) {
-                embeddingModel = await select({
-                    message: 'Select embedding model:',
-                    options: [
-                        { value: 'all-MiniLM-L6-v2', label: 'MiniLM L6 (384d)', hint: 'Fast, good quality (recommended)' },
-                        { value: 'all-mpnet-base-v2', label: 'MPNet Base (768d)', hint: 'Higher quality, more memory' },
-                    ],
-                });
-            }
-            // Execute initialization
-            output.writeln();
-            const spinner = output.createSpinner({ text: 'Initializing...' });
-            spinner.start();
-            const result = await executeInit(options);
-            if (!result.success) {
-                spinner.fail('Initialization failed');
-                for (const error of result.errors) {
-                    output.printError(error);
-                }
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed('Setup complete!');
-            // Initialize embeddings if enabled
-            let embeddingsInitialized = false;
-            if (enableEmbeddings) {
-                output.writeln();
-                output.printInfo('Initializing ONNX embedding subsystem...');
-                const { execSync } = await import('child_process');
-                try {
-                    execSync(`npx @kynjal/cli@latest embeddings init --model ${embeddingModel} --no-download --force 2>/dev/null`, {
-                        stdio: 'pipe',
-                        cwd: ctx.cwd,
-                        timeout: 30000
+                    _b.label = 9;
+                case 9: return [4 /*yield*/, select({
+                        message: 'Select swarm topology:',
+                        options: [
+                            { value: 'hierarchical-mesh', label: 'Hierarchical Mesh', hint: 'Best for complex projects (recommended)' },
+                            { value: 'mesh', label: 'Mesh', hint: 'Peer-to-peer coordination' },
+                            { value: 'hierarchical', label: 'Hierarchical', hint: 'Tree-based coordination' },
+                            { value: 'adaptive', label: 'Adaptive', hint: 'Dynamic topology switching' },
+                        ]
+                    })];
+                case 10:
+                    topology = _b.sent();
+                    options.runtime.topology = topology;
+                    return [4 /*yield*/, input({
+                            message: 'Maximum concurrent agents:',
+                            "default": String(options.runtime.maxAgents),
+                            validate: function (v) {
+                                var n = parseInt(v);
+                                return (!isNaN(n) && n > 0 && n <= 50) || 'Enter a number between 1 and 50';
+                            }
+                        })];
+                case 11:
+                    maxAgents = _b.sent();
+                    options.runtime.maxAgents = parseInt(maxAgents);
+                    return [4 /*yield*/, select({
+                            message: 'Select memory backend:',
+                            options: [
+                                { value: 'hybrid', label: 'Hybrid', hint: 'SQLite + AgentDB (recommended)' },
+                                { value: 'agentdb', label: 'AgentDB', hint: '150x faster vector search' },
+                                { value: 'sqlite', label: 'SQLite', hint: 'Standard SQL storage' },
+                                { value: 'memory', label: 'In-Memory', hint: 'Fast but non-persistent' },
+                            ]
+                        })];
+                case 12:
+                    memoryBackend = _b.sent();
+                    options.runtime.memoryBackend = memoryBackend;
+                    if (!(memoryBackend === 'agentdb' || memoryBackend === 'hybrid')) return [3 /*break*/, 14];
+                    return [4 /*yield*/, confirm({
+                            message: 'Enable HNSW indexing for faster vector search?',
+                            "default": true
+                        })];
+                case 13:
+                    enableHNSW = _b.sent();
+                    options.runtime.enableHNSW = enableHNSW;
+                    _b.label = 14;
+                case 14: return [4 /*yield*/, confirm({
+                        message: 'Enable neural pattern learning?',
+                        "default": options.runtime.enableNeural
+                    })];
+                case 15:
+                    enableNeural = _b.sent();
+                    options.runtime.enableNeural = enableNeural;
+                    if (!(memoryBackend === 'agentdb' || memoryBackend === 'hybrid')) return [3 /*break*/, 17];
+                    return [4 /*yield*/, confirm({
+                            message: 'Enable self-learning memory? (LearningBridge + Knowledge Graph + Agent Scopes)',
+                            "default": true
+                        })];
+                case 16:
+                    enableSelfLearning = _b.sent();
+                    options.runtime.enableLearningBridge = enableSelfLearning && enableNeural;
+                    options.runtime.enableMemoryGraph = enableSelfLearning;
+                    options.runtime.enableAgentScopes = enableSelfLearning;
+                    return [3 /*break*/, 18];
+                case 17:
+                    options.runtime.enableLearningBridge = false;
+                    options.runtime.enableMemoryGraph = false;
+                    options.runtime.enableAgentScopes = false;
+                    _b.label = 18;
+                case 18: return [4 /*yield*/, confirm({
+                        message: 'Enable ONNX embedding system with hyperbolic support?',
+                        "default": true
+                    })];
+                case 19:
+                    enableEmbeddings = _b.sent();
+                    embeddingModel = 'all-MiniLM-L6-v2';
+                    if (!enableEmbeddings) return [3 /*break*/, 21];
+                    return [4 /*yield*/, select({
+                            message: 'Select embedding model:',
+                            options: [
+                                { value: 'all-MiniLM-L6-v2', label: 'MiniLM L6 (384d)', hint: 'Fast, good quality (recommended)' },
+                                { value: 'all-mpnet-base-v2', label: 'MPNet Base (768d)', hint: 'Higher quality, more memory' },
+                            ]
+                        })];
+                case 20:
+                    embeddingModel = _b.sent();
+                    _b.label = 21;
+                case 21:
+                    // Execute initialization
+                    output.writeln();
+                    spinner = output.createSpinner({ text: 'Initializing...' });
+                    spinner.start();
+                    return [4 /*yield*/, executeInit(options)];
+                case 22:
+                    result = _b.sent();
+                    if (!result.success) {
+                        spinner.fail('Initialization failed');
+                        for (_i = 0, _a = result.errors; _i < _a.length; _i++) {
+                            error = _a[_i];
+                            output.printError(error);
+                        }
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed('Setup complete!');
+                    embeddingsInitialized = false;
+                    if (!enableEmbeddings) return [3 /*break*/, 24];
+                    output.writeln();
+                    output.printInfo('Initializing ONNX embedding subsystem...');
+                    return [4 /*yield*/, import('child_process')];
+                case 23:
+                    execSync = (_b.sent()).execSync;
+                    try {
+                        execSync("npx @claude-flow/cli@latest embeddings init --model " + embeddingModel + " --no-download --force 2>/dev/null", {
+                            stdio: 'pipe',
+                            cwd: ctx.cwd,
+                            timeout: 30000
+                        });
+                        output.writeln(output.success('  ✓ Embeddings configured'));
+                        embeddingsInitialized = true;
+                    }
+                    catch (_c) {
+                        output.writeln(output.dim('  Embeddings will be configured on first use'));
+                    }
+                    _b.label = 24;
+                case 24:
+                    output.writeln();
+                    // Summary table
+                    output.printTable({
+                        columns: [
+                            { key: 'setting', header: 'Setting', width: 20 },
+                            { key: 'value', header: 'Value', width: 40 },
+                        ],
+                        data: [
+                            { setting: 'Preset', value: preset },
+                            { setting: 'Topology', value: options.runtime.topology },
+                            { setting: 'Max Agents', value: String(options.runtime.maxAgents) },
+                            { setting: 'Memory Backend', value: options.runtime.memoryBackend },
+                            { setting: 'HNSW Indexing', value: options.runtime.enableHNSW ? 'Enabled' : 'Disabled' },
+                            { setting: 'Neural Learning', value: options.runtime.enableNeural ? 'Enabled' : 'Disabled' },
+                            { setting: 'Self-Learning', value: options.runtime.enableLearningBridge ? 'LearningBridge + Graph + Scopes' : 'Disabled' },
+                            { setting: 'Embeddings', value: enableEmbeddings ? embeddingModel + " (hyperbolic)" : 'Disabled' },
+                            { setting: 'Skills', value: result.summary.skillsCount + " installed" },
+                            { setting: 'Commands', value: result.summary.commandsCount + " installed" },
+                            { setting: 'Agents', value: result.summary.agentsCount + " installed" },
+                            { setting: 'Hooks', value: result.summary.hooksEnabled + " enabled" },
+                        ]
                     });
-                    output.writeln(output.success('  ✓ Embeddings configured'));
-                    embeddingsInitialized = true;
-                }
-                catch {
-                    output.writeln(output.dim('  Embeddings will be configured on first use'));
-                }
-            }
-            output.writeln();
-            // Summary table
-            output.printTable({
-                columns: [
-                    { key: 'setting', header: 'Setting', width: 20 },
-                    { key: 'value', header: 'Value', width: 40 },
-                ],
-                data: [
-                    { setting: 'Preset', value: preset },
-                    { setting: 'Topology', value: options.runtime.topology },
-                    { setting: 'Max Agents', value: String(options.runtime.maxAgents) },
-                    { setting: 'Memory Backend', value: options.runtime.memoryBackend },
-                    { setting: 'HNSW Indexing', value: options.runtime.enableHNSW ? 'Enabled' : 'Disabled' },
-                    { setting: 'Neural Learning', value: options.runtime.enableNeural ? 'Enabled' : 'Disabled' },
-                    { setting: 'Self-Learning', value: options.runtime.enableLearningBridge ? 'LearningBridge + Graph + Scopes' : 'Disabled' },
-                    { setting: 'Embeddings', value: enableEmbeddings ? `${embeddingModel} (hyperbolic)` : 'Disabled' },
-                    { setting: 'Skills', value: `${result.summary.skillsCount} installed` },
-                    { setting: 'Commands', value: `${result.summary.commandsCount} installed` },
-                    { setting: 'Agents', value: `${result.summary.agentsCount} installed` },
-                    { setting: 'Hooks', value: `${result.summary.hooksEnabled} enabled` },
-                ],
-            });
-            return { success: true, data: result };
-        }
-        catch (error) {
-            if (error instanceof Error && error.message === 'User cancelled') {
-                output.printInfo('Setup cancelled');
-                return { success: true };
+                    return [2 /*return*/, { success: true, data: result }];
+                case 25:
+                    error_3 = _b.sent();
+                    if (error_3 instanceof Error && error_3.message === 'User cancelled') {
+                        output.printInfo('Setup cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    throw error_3;
+                case 26: return [2 /*return*/];
             }
-            throw error;
-        }
-    },
+        });
+    }); }
 };
 // Check subcommand
-const checkCommand = {
+var checkCommand = {
     name: 'check',
-    description: 'Check if KynjalFlow is initialized',
-    action: async (ctx) => {
-        const initialized = isInitialized(ctx.cwd);
-        const result = {
-            initialized: initialized.claude || initialized.claudeFlow,
-            claude: initialized.claude,
-            claudeFlow: initialized.claudeFlow,
-            paths: {
-                claudeSettings: initialized.claude ? path.join(ctx.cwd, '.claude', 'settings.json') : null,
-                claudeFlowConfig: initialized.claudeFlow ? path.join(ctx.cwd, '.claude-flow', 'config.yaml') : null,
-            },
-        };
-        if (ctx.flags.format === 'json') {
-            output.printJson(result);
-            return { success: true, data: result };
-        }
-        if (result.initialized) {
-            output.printSuccess('KynjalFlow is initialized');
-            if (initialized.claude) {
-                output.printInfo(`  Claude Code: .claude/settings.json`);
+    description: 'Check if RuFlo is initialized',
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var initialized, result;
+        return __generator(this, function (_a) {
+            initialized = isInitialized(ctx.cwd);
+            result = {
+                initialized: initialized.claude || initialized.claudeFlow,
+                claude: initialized.claude,
+                claudeFlow: initialized.claudeFlow,
+                paths: {
+                    claudeSettings: initialized.claude ? path.join(ctx.cwd, '.claude', 'settings.json') : null,
+                    claudeFlowConfig: initialized.claudeFlow ? path.join(ctx.cwd, '.claude-flow', 'config.yaml') : null
+                }
+            };
+            if (ctx.flags.format === 'json') {
+                output.printJson(result);
+                return [2 /*return*/, { success: true, data: result }];
             }
-            if (initialized.claudeFlow) {
-                output.printInfo(`  V3 Runtime: .claude-flow/config.yaml`);
+            if (result.initialized) {
+                output.printSuccess('RuFlo is initialized');
+                if (initialized.claude) {
+                    output.printInfo("  Claude Code: .claude/settings.json");
+                }
+                if (initialized.claudeFlow) {
+                    output.printInfo("  V3 Runtime: .claude-flow/config.yaml");
+                }
             }
-        }
-        else {
-            output.printWarning('KynjalFlow is not initialized in this directory');
-            output.printInfo('Run "claude-flow init" to initialize');
-        }
-        return { success: true, data: result };
-    },
+            else {
+                output.printWarning('RuFlo is not initialized in this directory');
+                output.printInfo('Run "ruflo init" to initialize');
+            }
+            return [2 /*return*/, { success: true, data: result }];
+        });
+    }); }
 };
 // Skills subcommand
-const skillsCommand = {
+var skillsCommand = {
     name: 'skills',
     description: 'Initialize only skills',
     options: [
-        { name: 'all', description: 'Install all skills', type: 'boolean', default: false },
-        { name: 'core', description: 'Install core skills', type: 'boolean', default: true },
-        { name: 'agentdb', description: 'Install AgentDB skills', type: 'boolean', default: false },
-        { name: 'github', description: 'Install GitHub skills', type: 'boolean', default: false },
-        { name: 'v3', description: 'Install V3 skills', type: 'boolean', default: false },
+        { name: 'all', description: 'Install all skills', type: 'boolean', "default": false },
+        { name: 'core', description: 'Install core skills', type: 'boolean', "default": true },
+        { name: 'agentdb', description: 'Install AgentDB skills', type: 'boolean', "default": false },
+        { name: 'github', description: 'Install GitHub skills', type: 'boolean', "default": false },
+        { name: 'v3', description: 'Install V3 skills', type: 'boolean', "default": false },
     ],
-    action: async (ctx) => {
-        const options = {
-            ...MINIMAL_INIT_OPTIONS,
-            targetDir: ctx.cwd,
-            force: ctx.flags.force,
-            components: {
-                settings: false,
-                skills: true,
-                commands: false,
-                agents: false,
-                helpers: false,
-                statusline: false,
-                mcp: false,
-                runtime: false,
-                claudeMd: false,
-            },
-            skills: {
-                all: ctx.flags.all,
-                core: ctx.flags.core,
-                agentdb: ctx.flags.agentdb,
-                github: ctx.flags.github,
-                flowNexus: false,
-                browser: false,
-                v3: ctx.flags.v3,
-                dualMode: false,
-            },
-        };
-        const spinner = output.createSpinner({ text: 'Installing skills...' });
-        spinner.start();
-        const result = await executeInit(options);
-        if (result.success) {
-            spinner.succeed(`Installed ${result.summary.skillsCount} skills`);
-        }
-        else {
-            spinner.fail('Failed to install skills');
-            for (const error of result.errors) {
-                output.printError(error);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var options, spinner, result, _i, _a, error;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    options = __assign(__assign({}, MINIMAL_INIT_OPTIONS), { targetDir: ctx.cwd, force: ctx.flags.force, components: {
+                            settings: false,
+                            skills: true,
+                            commands: false,
+                            agents: false,
+                            helpers: false,
+                            statusline: false,
+                            mcp: false,
+                            runtime: false,
+                            claudeMd: false
+                        }, skills: {
+                            all: ctx.flags.all,
+                            core: ctx.flags.core,
+                            agentdb: ctx.flags.agentdb,
+                            github: ctx.flags.github,
+                            flowNexus: false,
+                            browser: false,
+                            v3: ctx.flags.v3,
+                            dualMode: false
+                        } });
+                    spinner = output.createSpinner({ text: 'Installing skills...' });
+                    spinner.start();
+                    return [4 /*yield*/, executeInit(options)];
+                case 1:
+                    result = _b.sent();
+                    if (result.success) {
+                        spinner.succeed("Installed " + result.summary.skillsCount + " skills");
+                    }
+                    else {
+                        spinner.fail('Failed to install skills');
+                        for (_i = 0, _a = result.errors; _i < _a.length; _i++) {
+                            error = _a[_i];
+                            output.printError(error);
+                        }
+                    }
+                    return [2 /*return*/, { success: result.success, data: result }];
             }
-        }
-        return { success: result.success, data: result };
-    },
+        });
+    }); }
 };
 // Hooks subcommand
-const hooksCommand = {
+var hooksCommand = {
     name: 'hooks',
     description: 'Initialize only hooks configuration',
     options: [
-        { name: 'all', description: 'Enable all hooks', type: 'boolean', default: true },
-        { name: 'minimal', description: 'Enable only essential hooks', type: 'boolean', default: false },
+        { name: 'all', description: 'Enable all hooks', type: 'boolean', "default": true },
+        { name: 'minimal', description: 'Enable only essential hooks', type: 'boolean', "default": false },
     ],
-    action: async (ctx) => {
-        const minimal = ctx.flags.minimal;
-        const options = {
-            ...DEFAULT_INIT_OPTIONS,
-            targetDir: ctx.cwd,
-            force: ctx.flags.force,
-            components: {
-                settings: true,
-                skills: false,
-                commands: false,
-                agents: false,
-                helpers: false,
-                statusline: false,
-                mcp: false,
-                runtime: false,
-                claudeMd: false,
-            },
-            hooks: minimal
-                ? {
-                    preToolUse: true,
-                    postToolUse: true,
-                    userPromptSubmit: false,
-                    sessionStart: false,
-                    stop: false,
-                    preCompact: false,
-                    notification: false,
-                    timeout: 5000,
-                    continueOnError: true,
-                }
-                : DEFAULT_INIT_OPTIONS.hooks,
-        };
-        const spinner = output.createSpinner({ text: 'Creating hooks configuration...' });
-        spinner.start();
-        const result = await executeInit(options);
-        if (result.success) {
-            spinner.succeed(`Created settings.json with ${result.summary.hooksEnabled} hooks enabled`);
-        }
-        else {
-            spinner.fail('Failed to create hooks configuration');
-            for (const error of result.errors) {
-                output.printError(error);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var minimal, options, spinner, result, _i, _a, error;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    minimal = ctx.flags.minimal;
+                    options = __assign(__assign({}, DEFAULT_INIT_OPTIONS), { targetDir: ctx.cwd, force: ctx.flags.force, components: {
+                            settings: true,
+                            skills: false,
+                            commands: false,
+                            agents: false,
+                            helpers: false,
+                            statusline: false,
+                            mcp: false,
+                            runtime: false,
+                            claudeMd: false
+                        }, hooks: minimal
+                            ? {
+                                preToolUse: true,
+                                postToolUse: true,
+                                userPromptSubmit: false,
+                                sessionStart: false,
+                                stop: false,
+                                preCompact: false,
+                                notification: false,
+                                teammateIdle: false,
+                                taskCompleted: false,
+                                timeout: 5000,
+                                continueOnError: true
+                            }
+                            : DEFAULT_INIT_OPTIONS.hooks });
+                    spinner = output.createSpinner({ text: 'Creating hooks configuration...' });
+                    spinner.start();
+                    return [4 /*yield*/, executeInit(options)];
+                case 1:
+                    result = _b.sent();
+                    if (result.success) {
+                        spinner.succeed("Created settings.json with " + result.summary.hooksEnabled + " hooks enabled");
+                    }
+                    else {
+                        spinner.fail('Failed to create hooks configuration');
+                        for (_i = 0, _a = result.errors; _i < _a.length; _i++) {
+                            error = _a[_i];
+                            output.printError(error);
+                        }
+                    }
+                    return [2 /*return*/, { success: result.success, data: result }];
             }
-        }
-        return { success: result.success, data: result };
-    },
+        });
+    }); }
 };
 // Upgrade subcommand - updates helpers without losing user data
-const upgradeCommand = {
+var upgradeCommand = {
     name: 'upgrade',
     description: 'Update statusline and helpers while preserving existing data',
     options: [
@@ -744,128 +882,146 @@ const upgradeCommand = {
             short: 'v',
             description: 'Show detailed output',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'add-missing',
             short: 'a',
             description: 'Add any new skills, agents, and commands that are missing',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'settings',
             short: 's',
             description: 'Merge new settings (Agent Teams, hooks) into existing settings.json',
             type: 'boolean',
-            default: false,
+            "default": false
         },
     ],
-    action: async (ctx) => {
-        const addMissing = (ctx.flags['add-missing'] || ctx.flags.addMissing);
-        const upgradeSettings = (ctx.flags.settings);
-        output.writeln();
-        output.writeln(output.bold('Upgrading KynjalFlow'));
-        if (addMissing && upgradeSettings) {
-            output.writeln(output.dim('Updates helpers, settings, and adds any missing skills/agents/commands'));
-        }
-        else if (addMissing) {
-            output.writeln(output.dim('Updates helpers and adds any missing skills/agents/commands'));
-        }
-        else if (upgradeSettings) {
-            output.writeln(output.dim('Updates helpers and merges new settings (Agent Teams, hooks)'));
-        }
-        else {
-            output.writeln(output.dim('Updates helpers while preserving your existing data'));
-        }
-        output.writeln();
-        const spinnerText = upgradeSettings
-            ? 'Upgrading helpers and settings...'
-            : (addMissing ? 'Upgrading and adding missing assets...' : 'Upgrading...');
-        const spinner = output.createSpinner({ text: spinnerText });
-        spinner.start();
-        try {
-            const result = addMissing
-                ? await executeUpgradeWithMissing(ctx.cwd, upgradeSettings)
-                : await executeUpgrade(ctx.cwd, upgradeSettings);
-            if (!result.success) {
-                spinner.fail('Upgrade failed');
-                for (const error of result.errors) {
-                    output.printError(error);
-                }
-                return { success: false, exitCode: 1 };
-            }
-            spinner.succeed('Upgrade complete!');
-            output.writeln();
-            // Show what was updated
-            if (result.updated.length > 0) {
-                output.printBox(result.updated.map(f => `✓ ${f}`).join('\n'), 'Updated (latest version)');
-                output.writeln();
-            }
-            // Show what was created
-            if (result.created.length > 0) {
-                output.printBox(result.created.map(f => `+ ${f}`).join('\n'), 'Created (new files)');
-                output.writeln();
-            }
-            // Show what was preserved
-            if (result.preserved.length > 0 && ctx.flags.verbose) {
-                output.printBox(result.preserved.map(f => `• ${f}`).join('\n'), 'Preserved (existing data kept)');
-                output.writeln();
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var addMissing, upgradeSettings, spinnerText, spinner, result, _a, _i, _b, error, totalAdded, error_4;
+        var _c, _d, _e;
+        return __generator(this, function (_f) {
+            switch (_f.label) {
+                case 0:
+                    addMissing = (ctx.flags['add-missing'] || ctx.flags.addMissing);
+                    upgradeSettings = (ctx.flags.settings);
+                    output.writeln();
+                    output.writeln(output.bold('Upgrading RuFlo'));
+                    if (addMissing && upgradeSettings) {
+                        output.writeln(output.dim('Updates helpers, settings, and adds any missing skills/agents/commands'));
+                    }
+                    else if (addMissing) {
+                        output.writeln(output.dim('Updates helpers and adds any missing skills/agents/commands'));
+                    }
+                    else if (upgradeSettings) {
+                        output.writeln(output.dim('Updates helpers and merges new settings (Agent Teams, hooks)'));
+                    }
+                    else {
+                        output.writeln(output.dim('Updates helpers while preserving your existing data'));
+                    }
+                    output.writeln();
+                    spinnerText = upgradeSettings
+                        ? 'Upgrading helpers and settings...'
+                        : (addMissing ? 'Upgrading and adding missing assets...' : 'Upgrading...');
+                    spinner = output.createSpinner({ text: spinnerText });
+                    spinner.start();
+                    _f.label = 1;
+                case 1:
+                    _f.trys.push([1, 6, , 7]);
+                    if (!addMissing) return [3 /*break*/, 3];
+                    return [4 /*yield*/, executeUpgradeWithMissing(ctx.cwd, upgradeSettings)];
+                case 2:
+                    _a = _f.sent();
+                    return [3 /*break*/, 5];
+                case 3: return [4 /*yield*/, executeUpgrade(ctx.cwd, upgradeSettings)];
+                case 4:
+                    _a = _f.sent();
+                    _f.label = 5;
+                case 5:
+                    result = _a;
+                    if (!result.success) {
+                        spinner.fail('Upgrade failed');
+                        for (_i = 0, _b = result.errors; _i < _b.length; _i++) {
+                            error = _b[_i];
+                            output.printError(error);
+                        }
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner.succeed('Upgrade complete!');
+                    output.writeln();
+                    // Show what was updated
+                    if (result.updated.length > 0) {
+                        output.printBox(result.updated.map(function (f) { return "\u2713 " + f; }).join('\n'), 'Updated (latest version)');
+                        output.writeln();
+                    }
+                    // Show what was created
+                    if (result.created.length > 0) {
+                        output.printBox(result.created.map(function (f) { return "+ " + f; }).join('\n'), 'Created (new files)');
+                        output.writeln();
+                    }
+                    // Show what was preserved
+                    if (result.preserved.length > 0 && ctx.flags.verbose) {
+                        output.printBox(result.preserved.map(function (f) { return "\u2022 " + f; }).join('\n'), 'Preserved (existing data kept)');
+                        output.writeln();
+                    }
+                    else if (result.preserved.length > 0) {
+                        output.printInfo("Preserved " + result.preserved.length + " existing data files");
+                        output.writeln();
+                    }
+                    // Show added assets (when --add-missing flag is used)
+                    if (result.addedSkills && result.addedSkills.length > 0) {
+                        output.printBox(result.addedSkills.map(function (s) { return "+ " + s; }).join('\n'), "Added Skills (" + result.addedSkills.length + " new)");
+                        output.writeln();
+                    }
+                    if (result.addedAgents && result.addedAgents.length > 0) {
+                        output.printBox(result.addedAgents.map(function (a) { return "+ " + a; }).join('\n'), "Added Agents (" + result.addedAgents.length + " new)");
+                        output.writeln();
+                    }
+                    if (result.addedCommands && result.addedCommands.length > 0) {
+                        output.printBox(result.addedCommands.map(function (c) { return "+ " + c; }).join('\n'), "Added Commands (" + result.addedCommands.length + " new)");
+                        output.writeln();
+                    }
+                    // Show settings updates
+                    if (result.settingsUpdated && result.settingsUpdated.length > 0) {
+                        output.printBox(result.settingsUpdated.map(function (s) { return "+ " + s; }).join('\n'), 'Settings Updated');
+                        output.writeln();
+                    }
+                    output.printSuccess('Your statusline helper has been updated to the latest version');
+                    output.printInfo('Existing metrics and learning data were preserved');
+                    // Show settings summary
+                    if (upgradeSettings && result.settingsUpdated && result.settingsUpdated.length > 0) {
+                        output.printSuccess('Settings.json updated with new Agent Teams configuration');
+                    }
+                    // Show summary for --add-missing
+                    if (addMissing) {
+                        totalAdded = (((_c = result.addedSkills) === null || _c === void 0 ? void 0 : _c.length) || 0) + (((_d = result.addedAgents) === null || _d === void 0 ? void 0 : _d.length) || 0) + (((_e = result.addedCommands) === null || _e === void 0 ? void 0 : _e.length) || 0);
+                        if (totalAdded > 0) {
+                            output.printSuccess("Added " + totalAdded + " missing assets to your project");
+                        }
+                        else {
+                            output.printInfo('All skills, agents, and commands are already up to date');
+                        }
+                    }
+                    if (ctx.flags.format === 'json') {
+                        output.printJson(result);
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
+                case 6:
+                    error_4 = _f.sent();
+                    spinner.fail('Upgrade failed');
+                    output.printError("Failed to upgrade: " + (error_4 instanceof Error ? error_4.message : String(error_4)));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 7: return [2 /*return*/];
             }
-            else if (result.preserved.length > 0) {
-                output.printInfo(`Preserved ${result.preserved.length} existing data files`);
-                output.writeln();
-            }
-            // Show added assets (when --add-missing flag is used)
-            if (result.addedSkills && result.addedSkills.length > 0) {
-                output.printBox(result.addedSkills.map(s => `+ ${s}`).join('\n'), `Added Skills (${result.addedSkills.length} new)`);
-                output.writeln();
-            }
-            if (result.addedAgents && result.addedAgents.length > 0) {
-                output.printBox(result.addedAgents.map(a => `+ ${a}`).join('\n'), `Added Agents (${result.addedAgents.length} new)`);
-                output.writeln();
-            }
-            if (result.addedCommands && result.addedCommands.length > 0) {
-                output.printBox(result.addedCommands.map(c => `+ ${c}`).join('\n'), `Added Commands (${result.addedCommands.length} new)`);
-                output.writeln();
-            }
-            // Show settings updates
-            if (result.settingsUpdated && result.settingsUpdated.length > 0) {
-                output.printBox(result.settingsUpdated.map(s => `+ ${s}`).join('\n'), 'Settings Updated');
-                output.writeln();
-            }
-            output.printSuccess('Your statusline helper has been updated to the latest version');
-            output.printInfo('Existing metrics and learning data were preserved');
-            // Show settings summary
-            if (upgradeSettings && result.settingsUpdated && result.settingsUpdated.length > 0) {
-                output.printSuccess('Settings.json updated with new Agent Teams configuration');
-            }
-            // Show summary for --add-missing
-            if (addMissing) {
-                const totalAdded = (result.addedSkills?.length || 0) + (result.addedAgents?.length || 0) + (result.addedCommands?.length || 0);
-                if (totalAdded > 0) {
-                    output.printSuccess(`Added ${totalAdded} missing assets to your project`);
-                }
-                else {
-                    output.printInfo('All skills, agents, and commands are already up to date');
-                }
-            }
-            if (ctx.flags.format === 'json') {
-                output.printJson(result);
-            }
-            return { success: true, data: result };
-        }
-        catch (error) {
-            spinner.fail('Upgrade failed');
-            output.printError(`Failed to upgrade: ${error instanceof Error ? error.message : String(error)}`);
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 // Main init command
-export const initCommand = {
+export var initCommand = {
     name: 'init',
-    description: 'Initialize KynjalFlow in the current directory',
+    description: 'Initialize RuFlo in the current directory',
     subcommands: [wizardCommand, checkCommand, skillsCommand, hooksCommand, upgradeCommand],
     options: [
         {
@@ -873,69 +1029,69 @@ export const initCommand = {
             short: 'f',
             description: 'Overwrite existing configuration',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'minimal',
             short: 'm',
             description: 'Create minimal configuration',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'full',
             description: 'Create full configuration with all components',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'skip-claude',
             description: 'Skip .claude/ directory creation (runtime only)',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'only-claude',
             description: 'Only create .claude/ directory (skip runtime)',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'start-all',
             description: 'Auto-start daemon, memory, and swarm after init',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'start-daemon',
             description: 'Auto-start daemon after init',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'with-embeddings',
             description: 'Initialize ONNX embedding subsystem with hyperbolic support',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'embedding-model',
             description: 'ONNX embedding model to use',
             type: 'string',
-            default: 'all-MiniLM-L6-v2',
-            choices: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2'],
+            "default": 'all-MiniLM-L6-v2',
+            choices: ['all-MiniLM-L6-v2', 'all-mpnet-base-v2']
         },
         {
             name: 'codex',
             description: 'Initialize for OpenAI Codex CLI (creates AGENTS.md, .agents/)',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'dual',
             description: 'Initialize for both Claude Code and OpenAI Codex',
             type: 'boolean',
-            default: false,
+            "default": false
         },
     ],
     examples: [
@@ -959,7 +1115,7 @@ export const initCommand = {
         { command: 'claude-flow init --codex --full', description: 'Codex init with all 137+ skills' },
         { command: 'claude-flow init --dual', description: 'Initialize for both Claude Code and Codex' },
     ],
-    action: initAction,
+    action: initAction
 };
 export default initCommand;
 //# sourceMappingURL=init.js.map