kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/migrate.js

@@ -2,10 +2,46 @@
  * V3 CLI Migrate Command
  * Migration tools for V2 to V3 transition
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../output.js';
 import { select, confirm } from '../prompt.js';
 // Migration targets
-const MIGRATION_TARGETS = [
+var MIGRATION_TARGETS = [
     { value: 'config', label: 'Configuration', hint: 'Migrate configuration files' },
     { value: 'memory', label: 'Memory Data', hint: 'Migrate memory/database content' },
     { value: 'agents', label: 'Agent Configs', hint: 'Migrate agent configurations' },
@@ -15,57 +51,60 @@ const MIGRATION_TARGETS = [
     { value: 'all', label: 'All', hint: 'Full migration' }
 ];
 // Status command
-const statusCommand = {
+var statusCommand = {
     name: 'status',
     description: 'Check migration status',
-    action: async (ctx) => {
-        const status = {
-            v2Version: '2.6.0',
-            v3Version: '3.0.0-alpha.1',
-            migrationState: 'partial',
-            components: [
-                { name: 'Configuration', status: 'migrated', v2Path: './claude-flow.json', v3Path: './claude-flow.config.json' },
-                { name: 'Memory Data', status: 'pending', v2Path: './.claude-flow/memory', v3Path: './data/memory' },
-                { name: 'Agent Configs', status: 'pending', v2Path: './.claude-flow/agents', v3Path: './v3/agents' },
-                { name: 'Hooks', status: 'pending', v2Path: './src/hooks', v3Path: './v3/hooks' },
-                { name: 'Workflows', status: 'not-required', v2Path: 'N/A', v3Path: 'N/A' },
-                { name: 'Embeddings', status: 'pending', v2Path: 'OpenAI/TF.js', v3Path: 'ONNX + Hyperbolic' }
-            ],
-            recommendations: [
-                'Backup v2 data before migration',
-                'Test migration in staging environment first',
-                'Review breaking changes in CHANGELOG.md'
-            ]
-        };
-        if (ctx.flags.format === 'json') {
-            output.printJson(status);
-            return { success: true, data: status };
-        }
-        output.writeln();
-        output.writeln(output.bold('Migration Status'));
-        output.writeln();
-        output.writeln(`V2 Version: ${status.v2Version}`);
-        output.writeln(`V3 Version: ${status.v3Version}`);
-        output.writeln(`State: ${formatMigrationStatus(status.migrationState)}`);
-        output.writeln();
-        output.writeln(output.bold('Components'));
-        output.printTable({
-            columns: [
-                { key: 'name', header: 'Component', width: 18 },
-                { key: 'status', header: 'Status', width: 15, format: (v) => formatMigrationStatus(String(v)) },
-                { key: 'v2Path', header: 'V2 Path', width: 25 },
-                { key: 'v3Path', header: 'V3 Path', width: 25 }
-            ],
-            data: status.components
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var status;
+        return __generator(this, function (_a) {
+            status = {
+                v2Version: '2.6.0',
+                v3Version: '3.0.0-alpha.1',
+                migrationState: 'partial',
+                components: [
+                    { name: 'Configuration', status: 'migrated', v2Path: './claude-flow.json', v3Path: './claude-flow.config.json' },
+                    { name: 'Memory Data', status: 'pending', v2Path: './.claude-flow/memory', v3Path: './data/memory' },
+                    { name: 'Agent Configs', status: 'pending', v2Path: './.claude-flow/agents', v3Path: './v3/agents' },
+                    { name: 'Hooks', status: 'pending', v2Path: './src/hooks', v3Path: './v3/hooks' },
+                    { name: 'Workflows', status: 'not-required', v2Path: 'N/A', v3Path: 'N/A' },
+                    { name: 'Embeddings', status: 'pending', v2Path: 'OpenAI/TF.js', v3Path: 'ONNX + Hyperbolic' }
+                ],
+                recommendations: [
+                    'Backup v2 data before migration',
+                    'Test migration in staging environment first',
+                    'Review breaking changes in CHANGELOG.md'
+                ]
+            };
+            if (ctx.flags.format === 'json') {
+                output.printJson(status);
+                return [2 /*return*/, { success: true, data: status }];
+            }
+            output.writeln();
+            output.writeln(output.bold('Migration Status'));
+            output.writeln();
+            output.writeln("V2 Version: " + status.v2Version);
+            output.writeln("V3 Version: " + status.v3Version);
+            output.writeln("State: " + formatMigrationStatus(status.migrationState));
+            output.writeln();
+            output.writeln(output.bold('Components'));
+            output.printTable({
+                columns: [
+                    { key: 'name', header: 'Component', width: 18 },
+                    { key: 'status', header: 'Status', width: 15, format: function (v) { return formatMigrationStatus(String(v)); } },
+                    { key: 'v2Path', header: 'V2 Path', width: 25 },
+                    { key: 'v3Path', header: 'V3 Path', width: 25 }
+                ],
+                data: status.components
+            });
+            output.writeln();
+            output.writeln(output.bold('Recommendations'));
+            output.printList(status.recommendations);
+            return [2 /*return*/, { success: true, data: status }];
         });
-        output.writeln();
-        output.writeln(output.bold('Recommendations'));
-        output.printList(status.recommendations);
-        return { success: true, data: status };
-    }
+    }); }
 };
 // Run migration
-const runCommand = {
+var runCommand = {
     name: 'run',
     description: 'Run migration',
     options: [
@@ -74,86 +113,95 @@ const runCommand = {
             short: 't',
             description: 'Migration target',
             type: 'string',
-            choices: MIGRATION_TARGETS.map(t => t.value)
+            choices: MIGRATION_TARGETS.map(function (t) { return t.value; })
         },
         {
             name: 'dry-run',
             description: 'Show what would be migrated without making changes',
             type: 'boolean',
-            default: false
+            "default": false
         },
         {
             name: 'backup',
             description: 'Create backup before migration',
             type: 'boolean',
-            default: true
+            "default": true
         },
         {
             name: 'force',
             short: 'f',
             description: 'Force migration (overwrite existing)',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        let target = ctx.flags.target;
-        const dryRun = ctx.flags.dryRun;
-        const backup = ctx.flags.backup;
-        const force = ctx.flags.force;
-        if (!target && ctx.interactive) {
-            target = await select({
-                message: 'Select migration target:',
-                options: MIGRATION_TARGETS,
-                default: 'all'
-            });
-        }
-        target = target || 'all';
-        output.writeln();
-        if (dryRun) {
-            output.printInfo('DRY RUN - No changes will be made');
-            output.writeln();
-        }
-        output.printInfo(`Migrating: ${target}`);
-        output.writeln();
-        // Backup step
-        if (backup && !dryRun) {
-            output.writeln(output.dim('Creating backup...'));
-            output.writeln(output.dim(`  Backup created: ./.claude-flow-backup-${Date.now()}`));
-            output.writeln();
-        }
-        // Migration steps based on target
-        const steps = getMigrationSteps(target);
-        for (const step of steps) {
-            output.writeln(`${output.info('>')} ${step.name}`);
-            output.writeln(output.dim(`   ${step.description}`));
-            if (!dryRun) {
-                // Execute migration step
-                output.writeln(output.dim(`   ${output.success('[OK]')} Completed`));
-            }
-            else {
-                output.writeln(output.dim(`   Would migrate: ${step.source} -> ${step.dest}`));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var target, dryRun, backup, force, steps, _i, steps_1, step, result;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    target = ctx.flags.target;
+                    dryRun = ctx.flags.dryRun;
+                    backup = ctx.flags.backup;
+                    force = ctx.flags.force;
+                    if (!(!target && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, select({
+                            message: 'Select migration target:',
+                            options: MIGRATION_TARGETS,
+                            "default": 'all'
+                        })];
+                case 1:
+                    target = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    target = target || 'all';
+                    output.writeln();
+                    if (dryRun) {
+                        output.printInfo('DRY RUN - No changes will be made');
+                        output.writeln();
+                    }
+                    output.printInfo("Migrating: " + target);
+                    output.writeln();
+                    // Backup step
+                    if (backup && !dryRun) {
+                        output.writeln(output.dim('Creating backup...'));
+                        output.writeln(output.dim("  Backup created: ./.claude-flow-backup-" + Date.now()));
+                        output.writeln();
+                    }
+                    steps = getMigrationSteps(target);
+                    for (_i = 0, steps_1 = steps; _i < steps_1.length; _i++) {
+                        step = steps_1[_i];
+                        output.writeln(output.info('>') + " " + step.name);
+                        output.writeln(output.dim("   " + step.description));
+                        if (!dryRun) {
+                            // Execute migration step
+                            output.writeln(output.dim("   " + output.success('[OK]') + " Completed"));
+                        }
+                        else {
+                            output.writeln(output.dim("   Would migrate: " + step.source + " -> " + step.dest));
+                        }
+                        output.writeln();
+                    }
+                    result = {
+                        target: target,
+                        dryRun: dryRun,
+                        backup: backup,
+                        stepsCompleted: steps.length,
+                        success: true
+                    };
+                    if (dryRun) {
+                        output.printInfo('Dry run complete. Run without --dry-run to apply changes.');
+                    }
+                    else {
+                        output.printSuccess('Migration completed successfully');
+                    }
+                    return [2 /*return*/, { success: true, data: result }];
             }
-            output.writeln();
-        }
-        const result = {
-            target,
-            dryRun,
-            backup,
-            stepsCompleted: steps.length,
-            success: true
-        };
-        if (dryRun) {
-            output.printInfo('Dry run complete. Run without --dry-run to apply changes.');
-        }
-        else {
-            output.printSuccess('Migration completed successfully');
-        }
-        return { success: true, data: result };
-    }
+        });
+    }); }
 };
 // Verify migration
-const verifyCommand = {
+var verifyCommand = {
     name: 'verify',
     description: 'Verify migration integrity',
     options: [
@@ -161,55 +209,58 @@ const verifyCommand = {
             name: 'fix',
             description: 'Automatically fix issues',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const fix = ctx.flags.fix;
-        output.writeln();
-        output.printInfo('Verifying migration...');
-        output.writeln();
-        const checks = [
-            { name: 'Configuration Schema', status: 'passed', details: 'V3 schema valid' },
-            { name: 'Memory Data Integrity', status: 'passed', details: 'All entries valid' },
-            { name: 'Agent Configurations', status: 'warning', details: '2 deprecated fields detected' },
-            { name: 'Hook Definitions', status: 'passed', details: 'All hooks registered' },
-            { name: 'File Permissions', status: 'passed', details: 'Correct permissions' },
-            { name: 'Dependencies', status: 'passed', details: 'All dependencies available' }
-        ];
-        output.printTable({
-            columns: [
-                { key: 'name', header: 'Check', width: 25 },
-                { key: 'status', header: 'Status', width: 12, format: (v) => {
-                        if (v === 'passed')
-                            return output.success('PASSED');
-                        if (v === 'warning')
-                            return output.warning('WARNING');
-                        return output.error('FAILED');
-                    } },
-                { key: 'details', header: 'Details', width: 30 }
-            ],
-            data: checks
-        });
-        const hasIssues = checks.some(c => c.status !== 'passed');
-        output.writeln();
-        if (hasIssues) {
-            if (fix) {
-                output.printInfo('Attempting to fix issues...');
-                output.printSuccess('Issues fixed');
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var fix, checks, hasIssues;
+        return __generator(this, function (_a) {
+            fix = ctx.flags.fix;
+            output.writeln();
+            output.printInfo('Verifying migration...');
+            output.writeln();
+            checks = [
+                { name: 'Configuration Schema', status: 'passed', details: 'V3 schema valid' },
+                { name: 'Memory Data Integrity', status: 'passed', details: 'All entries valid' },
+                { name: 'Agent Configurations', status: 'warning', details: '2 deprecated fields detected' },
+                { name: 'Hook Definitions', status: 'passed', details: 'All hooks registered' },
+                { name: 'File Permissions', status: 'passed', details: 'Correct permissions' },
+                { name: 'Dependencies', status: 'passed', details: 'All dependencies available' }
+            ];
+            output.printTable({
+                columns: [
+                    { key: 'name', header: 'Check', width: 25 },
+                    { key: 'status', header: 'Status', width: 12, format: function (v) {
+                            if (v === 'passed')
+                                return output.success('PASSED');
+                            if (v === 'warning')
+                                return output.warning('WARNING');
+                            return output.error('FAILED');
+                        } },
+                    { key: 'details', header: 'Details', width: 30 }
+                ],
+                data: checks
+            });
+            hasIssues = checks.some(function (c) { return c.status !== 'passed'; });
+            output.writeln();
+            if (hasIssues) {
+                if (fix) {
+                    output.printInfo('Attempting to fix issues...');
+                    output.printSuccess('Issues fixed');
+                }
+                else {
+                    output.printWarning('Some issues detected. Run with --fix to attempt automatic fixes.');
+                }
             }
             else {
-                output.printWarning('Some issues detected. Run with --fix to attempt automatic fixes.');
+                output.printSuccess('All verification checks passed');
             }
-        }
-        else {
-            output.printSuccess('All verification checks passed');
-        }
-        return { success: true, data: { checks, hasIssues } };
-    }
+            return [2 /*return*/, { success: true, data: { checks: checks, hasIssues: hasIssues } }];
+        });
+    }); }
 };
 // Rollback migration
-const rollbackCommand = {
+var rollbackCommand = {
     name: 'rollback',
     description: 'Rollback to previous version',
     options: [
@@ -223,133 +274,145 @@ const rollbackCommand = {
             short: 'f',
             description: 'Skip confirmation',
             type: 'boolean',
-            default: false
+            "default": false
         }
     ],
-    action: async (ctx) => {
-        const backupId = ctx.flags.backupId;
-        const force = ctx.flags.force;
-        // List available backups
-        const backups = [
-            { id: 'backup-1704369600', date: '2024-01-04 10:00:00', size: '45.2 MB' },
-            { id: 'backup-1704283200', date: '2024-01-03 10:00:00', size: '44.8 MB' },
-            { id: 'backup-1704196800', date: '2024-01-02 10:00:00', size: '43.5 MB' }
-        ];
-        if (!backupId && ctx.interactive) {
-            output.writeln();
-            output.writeln(output.bold('Available Backups'));
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'id', header: 'Backup ID', width: 20 },
-                    { key: 'date', header: 'Date', width: 22 },
-                    { key: 'size', header: 'Size', width: 12, align: 'right' }
-                ],
-                data: backups
-            });
-            output.writeln();
-            const confirmed = await confirm({
-                message: `Rollback to most recent backup (${backups[0].id})?`,
-                default: false
-            });
-            if (!confirmed) {
-                output.printInfo('Operation cancelled');
-                return { success: true };
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var backupId, force, backups, confirmed, targetBackup;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    backupId = ctx.flags.backupId;
+                    force = ctx.flags.force;
+                    backups = [
+                        { id: 'backup-1704369600', date: '2024-01-04 10:00:00', size: '45.2 MB' },
+                        { id: 'backup-1704283200', date: '2024-01-03 10:00:00', size: '44.8 MB' },
+                        { id: 'backup-1704196800', date: '2024-01-02 10:00:00', size: '43.5 MB' }
+                    ];
+                    if (!(!backupId && ctx.interactive)) return [3 /*break*/, 2];
+                    output.writeln();
+                    output.writeln(output.bold('Available Backups'));
+                    output.writeln();
+                    output.printTable({
+                        columns: [
+                            { key: 'id', header: 'Backup ID', width: 20 },
+                            { key: 'date', header: 'Date', width: 22 },
+                            { key: 'size', header: 'Size', width: 12, align: 'right' }
+                        ],
+                        data: backups
+                    });
+                    output.writeln();
+                    return [4 /*yield*/, confirm({
+                            message: "Rollback to most recent backup (" + backups[0].id + ")?",
+                            "default": false
+                        })];
+                case 1:
+                    confirmed = _a.sent();
+                    if (!confirmed) {
+                        output.printInfo('Operation cancelled');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    _a.label = 2;
+                case 2:
+                    targetBackup = backupId || backups[0].id;
+                    if (!force && !ctx.interactive) {
+                        output.printError('Use --force to rollback without confirmation');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    output.writeln();
+                    output.printInfo("Rolling back to " + targetBackup + "...");
+                    output.writeln();
+                    output.writeln(output.dim('  Stopping services...'));
+                    output.writeln(output.dim('  Restoring configuration...'));
+                    output.writeln(output.dim('  Restoring memory data...'));
+                    output.writeln(output.dim('  Restoring agent configs...'));
+                    output.writeln(output.dim('  Verifying integrity...'));
+                    output.writeln();
+                    output.printSuccess("Rolled back to " + targetBackup);
+                    output.writeln(output.dim('  Note: Restart services to apply changes'));
+                    return [2 /*return*/, { success: true, data: { backupId: targetBackup, rolledBack: true } }];
             }
-        }
-        const targetBackup = backupId || backups[0].id;
-        if (!force && !ctx.interactive) {
-            output.printError('Use --force to rollback without confirmation');
-            return { success: false, exitCode: 1 };
-        }
-        output.writeln();
-        output.printInfo(`Rolling back to ${targetBackup}...`);
-        output.writeln();
-        output.writeln(output.dim('  Stopping services...'));
-        output.writeln(output.dim('  Restoring configuration...'));
-        output.writeln(output.dim('  Restoring memory data...'));
-        output.writeln(output.dim('  Restoring agent configs...'));
-        output.writeln(output.dim('  Verifying integrity...'));
-        output.writeln();
-        output.printSuccess(`Rolled back to ${targetBackup}`);
-        output.writeln(output.dim('  Note: Restart services to apply changes'));
-        return { success: true, data: { backupId: targetBackup, rolledBack: true } };
-    }
+        });
+    }); }
 };
 // Breaking changes info
-const breakingCommand = {
+var breakingCommand = {
     name: 'breaking',
     description: 'Show V3 breaking changes',
-    action: async (ctx) => {
-        const changes = [
-            {
-                category: 'Configuration',
-                changes: [
-                    { change: 'Config file renamed', from: 'claude-flow.json', to: 'claude-flow.config.json' },
-                    { change: 'Swarm config restructured', from: 'swarm.mode', to: 'swarm.topology' },
-                    { change: 'Provider config format', from: 'provider: "anthropic"', to: 'providers: [...]' }
-                ]
-            },
-            {
-                category: 'Memory',
-                changes: [
-                    { change: 'Backend option changed', from: 'memory: { type }', to: 'memory: { backend }' },
-                    { change: 'HNSW enabled by default', from: 'Manual opt-in', to: 'Auto-enabled' },
-                    { change: 'Storage path changed', from: '.claude-flow/memory', to: 'data/memory' }
-                ]
-            },
-            {
-                category: 'CLI',
-                changes: [
-                    { change: 'Agent command renamed', from: 'spawn <type>', to: 'agent spawn -t <type>' },
-                    { change: 'Memory command added', from: 'N/A', to: 'memory <subcommand>' },
-                    { change: 'Hook command enhanced', from: 'hook <type>', to: 'hooks <subcommand>' }
-                ]
-            },
-            {
-                category: 'API',
-                changes: [
-                    { change: 'Removed Deno support', from: 'Deno + Node.js', to: 'Node.js 20+ only' },
-                    { change: 'Event system changed', from: 'EventEmitter', to: 'Event sourcing' },
-                    { change: 'Coordination unified', from: 'Multiple coordinators', to: 'SwarmCoordinator' }
-                ]
-            },
-            {
-                category: 'Embeddings',
-                changes: [
-                    { change: 'Provider changed', from: 'OpenAI API / TF.js', to: 'ONNX Runtime (local)' },
-                    { change: 'Geometry support', from: 'Euclidean only', to: 'Hyperbolic (Poincaré ball)' },
-                    { change: 'Cache system', from: 'Memory-only', to: 'sql.js persistent cache' },
-                    { change: 'Neural substrate', from: 'None', to: 'RuVector integration' }
-                ]
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var changes, _i, changes_1, category;
+        return __generator(this, function (_a) {
+            changes = [
+                {
+                    category: 'Configuration',
+                    changes: [
+                        { change: 'Config file renamed', from: 'claude-flow.json', to: 'claude-flow.config.json' },
+                        { change: 'Swarm config restructured', from: 'swarm.mode', to: 'swarm.topology' },
+                        { change: 'Provider config format', from: 'provider: "anthropic"', to: 'providers: [...]' }
+                    ]
+                },
+                {
+                    category: 'Memory',
+                    changes: [
+                        { change: 'Backend option changed', from: 'memory: { type }', to: 'memory: { backend }' },
+                        { change: 'HNSW enabled by default', from: 'Manual opt-in', to: 'Auto-enabled' },
+                        { change: 'Storage path changed', from: '.claude-flow/memory', to: 'data/memory' }
+                    ]
+                },
+                {
+                    category: 'CLI',
+                    changes: [
+                        { change: 'Agent command renamed', from: 'spawn <type>', to: 'agent spawn -t <type>' },
+                        { change: 'Memory command added', from: 'N/A', to: 'memory <subcommand>' },
+                        { change: 'Hook command enhanced', from: 'hook <type>', to: 'hooks <subcommand>' }
+                    ]
+                },
+                {
+                    category: 'API',
+                    changes: [
+                        { change: 'Removed Deno support', from: 'Deno + Node.js', to: 'Node.js 20+ only' },
+                        { change: 'Event system changed', from: 'EventEmitter', to: 'Event sourcing' },
+                        { change: 'Coordination unified', from: 'Multiple coordinators', to: 'SwarmCoordinator' }
+                    ]
+                },
+                {
+                    category: 'Embeddings',
+                    changes: [
+                        { change: 'Provider changed', from: 'OpenAI API / TF.js', to: 'ONNX Runtime (local)' },
+                        { change: 'Geometry support', from: 'Euclidean only', to: 'Hyperbolic (Poincaré ball)' },
+                        { change: 'Cache system', from: 'Memory-only', to: 'sql.js persistent cache' },
+                        { change: 'Neural substrate', from: 'None', to: 'RuVector integration' }
+                    ]
+                }
+            ];
+            if (ctx.flags.format === 'json') {
+                output.printJson(changes);
+                return [2 /*return*/, { success: true, data: changes }];
             }
-        ];
-        if (ctx.flags.format === 'json') {
-            output.printJson(changes);
-            return { success: true, data: changes };
-        }
-        output.writeln();
-        output.writeln(output.bold('V3 Breaking Changes'));
-        output.writeln();
-        for (const category of changes) {
-            output.writeln(output.highlight(category.category));
-            output.printTable({
-                columns: [
-                    { key: 'change', header: 'Change', width: 25 },
-                    { key: 'from', header: 'V2', width: 25 },
-                    { key: 'to', header: 'V3', width: 25 }
-                ],
-                data: category.changes,
-                border: false
-            });
             output.writeln();
-        }
-        output.printInfo('Run "claude-flow migrate run" to automatically handle these changes');
-        return { success: true, data: changes };
-    }
+            output.writeln(output.bold('V3 Breaking Changes'));
+            output.writeln();
+            for (_i = 0, changes_1 = changes; _i < changes_1.length; _i++) {
+                category = changes_1[_i];
+                output.writeln(output.highlight(category.category));
+                output.printTable({
+                    columns: [
+                        { key: 'change', header: 'Change', width: 25 },
+                        { key: 'from', header: 'V2', width: 25 },
+                        { key: 'to', header: 'V3', width: 25 }
+                    ],
+                    data: category.changes,
+                    border: false
+                });
+                output.writeln();
+            }
+            output.printInfo('Run "claude-flow migrate run" to automatically handle these changes');
+            return [2 /*return*/, { success: true, data: changes }];
+        });
+    }); }
 };
 // Main migrate command
-export const migrateCommand = {
+export var migrateCommand = {
     name: 'migrate',
     description: 'V2 to V3 migration tools',
     subcommands: [statusCommand, runCommand, verifyCommand, rollbackCommand, breakingCommand],
@@ -359,22 +422,24 @@ export const migrateCommand = {
         { command: 'claude-flow migrate run --dry-run', description: 'Preview migration' },
         { command: 'claude-flow migrate run -t all', description: 'Run full migration' }
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('V2 to V3 Migration Tools'));
-        output.writeln();
-        output.writeln('Usage: claude-flow migrate <subcommand> [options]');
-        output.writeln();
-        output.writeln('Subcommands:');
-        output.printList([
-            `${output.highlight('status')}    - Check migration status`,
-            `${output.highlight('run')}       - Run migration`,
-            `${output.highlight('verify')}    - Verify migration integrity`,
-            `${output.highlight('rollback')}  - Rollback to previous version`,
-            `${output.highlight('breaking')}  - Show breaking changes`
-        ]);
-        return { success: true };
-    }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('V2 to V3 Migration Tools'));
+            output.writeln();
+            output.writeln('Usage: claude-flow migrate <subcommand> [options]');
+            output.writeln();
+            output.writeln('Subcommands:');
+            output.printList([
+                output.highlight('status') + "    - Check migration status",
+                output.highlight('run') + "       - Run migration",
+                output.highlight('verify') + "    - Verify migration integrity",
+                output.highlight('rollback') + "  - Rollback to previous version",
+                output.highlight('breaking') + "  - Show breaking changes"
+            ]);
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 // Helper functions
 function formatMigrationStatus(status) {
@@ -394,7 +459,7 @@ function formatMigrationStatus(status) {
     }
 }
 function getMigrationSteps(target) {
-    const allSteps = [
+    var allSteps = [
         { name: 'Configuration Files', description: 'Migrate config schema to V3 format', source: './claude-flow.json', dest: './claude-flow.config.json' },
         { name: 'Memory Backend', description: 'Upgrade to hybrid backend with AgentDB', source: './.claude-flow/memory', dest: './data/memory' },
         { name: 'Agent Definitions', description: 'Convert agent configs to V3 format', source: './.claude-flow/agents', dest: './v3/agents' },
@@ -404,7 +469,7 @@ function getMigrationSteps(target) {
     ];
     if (target === 'all')
         return allSteps;
-    return allSteps.filter(s => s.name.toLowerCase().includes(target.toLowerCase()));
+    return allSteps.filter(function (s) { return s.name.toLowerCase().includes(target.toLowerCase()); });
 }
 export default migrateCommand;
 //# sourceMappingURL=migrate.js.map