kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/migrate.js

@@ -2,46 +2,10 @@
  * 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
-var MIGRATION_TARGETS = [
+const 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' },
@@ -51,60 +15,57 @@ var MIGRATION_TARGETS = [
     { value: 'all', label: 'All', hint: 'Full migration' }
 ];
 // Status command
-var statusCommand = {
+const statusCommand = {
     name: 'status',
     description: 'Check migration status',
-    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 }];
+    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
         });
-    }); }
+        output.writeln();
+        output.writeln(output.bold('Recommendations'));
+        output.printList(status.recommendations);
+        return { success: true, data: status };
+    }
 };
 // Run migration
-var runCommand = {
+const runCommand = {
     name: 'run',
     description: 'Run migration',
     options: [
@@ -113,95 +74,86 @@ var runCommand = {
             short: 't',
             description: 'Migration target',
             type: 'string',
-            choices: MIGRATION_TARGETS.map(function (t) { return t.value; })
+            choices: MIGRATION_TARGETS.map(t => 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: 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 }];
+    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}`));
+            }
+            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
-var verifyCommand = {
+const verifyCommand = {
     name: 'verify',
     description: 'Verify migration integrity',
     options: [
@@ -209,58 +161,55 @@ var verifyCommand = {
             name: 'fix',
             description: 'Automatically fix issues',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
-    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.');
-                }
+    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');
             }
             else {
-                output.printSuccess('All verification checks passed');
+                output.printWarning('Some issues detected. Run with --fix to attempt automatic fixes.');
             }
-            return [2 /*return*/, { success: true, data: { checks: checks, hasIssues: hasIssues } }];
-        });
-    }); }
+        }
+        else {
+            output.printSuccess('All verification checks passed');
+        }
+        return { success: true, data: { checks, hasIssues } };
+    }
 };
 // Rollback migration
-var rollbackCommand = {
+const rollbackCommand = {
     name: 'rollback',
     description: 'Rollback to previous version',
     options: [
@@ -274,145 +223,133 @@ var rollbackCommand = {
             short: 'f',
             description: 'Skip confirmation',
             type: 'boolean',
-            "default": false
+            default: false
         }
     ],
-    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 } }];
+    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 };
             }
-        });
-    }); }
+        }
+        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
-var breakingCommand = {
+const breakingCommand = {
     name: 'breaking',
     description: 'Show V3 breaking changes',
-    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 }];
+    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' }
+                ]
             }
+        ];
+        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.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 }];
-        });
-    }); }
+        }
+        output.printInfo('Run "claude-flow migrate run" to automatically handle these changes');
+        return { success: true, data: changes };
+    }
 };
 // Main migrate command
-export var migrateCommand = {
+export const migrateCommand = {
     name: 'migrate',
     description: 'V2 to V3 migration tools',
     subcommands: [statusCommand, runCommand, verifyCommand, rollbackCommand, breakingCommand],
@@ -422,24 +359,22 @@ export var migrateCommand = {
         { command: 'claude-flow migrate run --dry-run', description: 'Preview migration' },
         { command: 'claude-flow migrate run -t all', description: 'Run full migration' }
     ],
-    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 }];
-        });
-    }); }
+    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 };
+    }
 };
 // Helper functions
 function formatMigrationStatus(status) {
@@ -459,7 +394,7 @@ function formatMigrationStatus(status) {
     }
 }
 function getMigrationSteps(target) {
-    var allSteps = [
+    const 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' },
@@ -469,7 +404,7 @@ function getMigrationSteps(target) {
     ];
     if (target === 'all')
         return allSteps;
-    return allSteps.filter(function (s) { return s.name.toLowerCase().includes(target.toLowerCase()); });
+    return allSteps.filter(s => s.name.toLowerCase().includes(target.toLowerCase()));
 }
 export default migrateCommand;
 //# sourceMappingURL=migrate.js.map