kynjal-cli 4.0.0 → 4.0.1

package/dist/src/commands/ruvector/migrate.js

@@ -2,83 +2,132 @@
  * V3 CLI RuVector Migrate Command
  * Database migration management for RuVector
  */
-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 } from '../../prompt.js';
 /**
  * Available migrations
  */
-var MIGRATIONS = [
+const MIGRATIONS = [
     {
         version: '1.0.0',
         name: 'Initial RuVector setup',
         up: '-- Initial setup handled by init command',
-        down: '-- Drop all tables in schema'
+        down: '-- Drop all tables in schema',
     },
     {
         version: '1.1.0',
         name: 'Add full-text search',
-        up: "\n      CREATE INDEX IF NOT EXISTS idx_embeddings_content_fts\n      ON {{schema}}.embeddings\n      USING gin (to_tsvector('english', COALESCE(content, '')));\n\n      ALTER TABLE {{schema}}.embeddings\n      ADD COLUMN IF NOT EXISTS search_vector tsvector\n      GENERATED ALWAYS AS (to_tsvector('english', COALESCE(content, ''))) STORED;\n    ",
-        down: "\n      DROP INDEX IF EXISTS {{schema}}.idx_embeddings_content_fts;\n      ALTER TABLE {{schema}}.embeddings DROP COLUMN IF EXISTS search_vector;\n    "
+        up: `
+      CREATE INDEX IF NOT EXISTS idx_embeddings_content_fts
+      ON {{schema}}.embeddings
+      USING gin (to_tsvector('english', COALESCE(content, '')));
+
+      ALTER TABLE {{schema}}.embeddings
+      ADD COLUMN IF NOT EXISTS search_vector tsvector
+      GENERATED ALWAYS AS (to_tsvector('english', COALESCE(content, ''))) STORED;
+    `,
+        down: `
+      DROP INDEX IF EXISTS {{schema}}.idx_embeddings_content_fts;
+      ALTER TABLE {{schema}}.embeddings DROP COLUMN IF EXISTS search_vector;
+    `,
     },
     {
         version: '1.2.0',
         name: 'Add embedding statistics',
-        up: "\n      CREATE TABLE IF NOT EXISTS {{schema}}.embedding_stats (\n        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n        namespace VARCHAR(128) NOT NULL,\n        total_vectors INTEGER DEFAULT 0,\n        avg_magnitude FLOAT,\n        dimension_stats JSONB,\n        computed_at TIMESTAMPTZ DEFAULT NOW()\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_embedding_stats_namespace\n      ON {{schema}}.embedding_stats (namespace);\n    ",
-        down: "\n      DROP TABLE IF EXISTS {{schema}}.embedding_stats;\n    "
+        up: `
+      CREATE TABLE IF NOT EXISTS {{schema}}.embedding_stats (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        namespace VARCHAR(128) NOT NULL,
+        total_vectors INTEGER DEFAULT 0,
+        avg_magnitude FLOAT,
+        dimension_stats JSONB,
+        computed_at TIMESTAMPTZ DEFAULT NOW()
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_embedding_stats_namespace
+      ON {{schema}}.embedding_stats (namespace);
+    `,
+        down: `
+      DROP TABLE IF EXISTS {{schema}}.embedding_stats;
+    `,
     },
     {
         version: '1.3.0',
         name: 'Add query cache',
-        up: "\n      CREATE TABLE IF NOT EXISTS {{schema}}.query_cache (\n        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n        query_hash VARCHAR(64) NOT NULL UNIQUE,\n        query_embedding vector(1536),\n        result_ids UUID[],\n        result_scores FLOAT[],\n        hit_count INTEGER DEFAULT 1,\n        created_at TIMESTAMPTZ DEFAULT NOW(),\n        last_accessed TIMESTAMPTZ DEFAULT NOW()\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_query_cache_hash\n      ON {{schema}}.query_cache (query_hash);\n\n      CREATE INDEX IF NOT EXISTS idx_query_cache_last_accessed\n      ON {{schema}}.query_cache (last_accessed);\n    ",
-        down: "\n      DROP TABLE IF EXISTS {{schema}}.query_cache;\n    "
+        up: `
+      CREATE TABLE IF NOT EXISTS {{schema}}.query_cache (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        query_hash VARCHAR(64) NOT NULL UNIQUE,
+        query_embedding vector(1536),
+        result_ids UUID[],
+        result_scores FLOAT[],
+        hit_count INTEGER DEFAULT 1,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        last_accessed TIMESTAMPTZ DEFAULT NOW()
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_query_cache_hash
+      ON {{schema}}.query_cache (query_hash);
+
+      CREATE INDEX IF NOT EXISTS idx_query_cache_last_accessed
+      ON {{schema}}.query_cache (last_accessed);
+    `,
+        down: `
+      DROP TABLE IF EXISTS {{schema}}.query_cache;
+    `,
     },
     {
         version: '1.4.0',
         name: 'Add batch operations support',
-        up: "\n      CREATE TABLE IF NOT EXISTS {{schema}}.batch_jobs (\n        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n        job_type VARCHAR(64) NOT NULL,\n        status VARCHAR(32) DEFAULT 'pending',\n        total_items INTEGER DEFAULT 0,\n        processed_items INTEGER DEFAULT 0,\n        error_count INTEGER DEFAULT 0,\n        metadata JSONB DEFAULT '{}',\n        started_at TIMESTAMPTZ,\n        completed_at TIMESTAMPTZ,\n        created_at TIMESTAMPTZ DEFAULT NOW()\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_batch_jobs_status\n      ON {{schema}}.batch_jobs (status);\n    ",
-        down: "\n      DROP TABLE IF EXISTS {{schema}}.batch_jobs;\n    "
+        up: `
+      CREATE TABLE IF NOT EXISTS {{schema}}.batch_jobs (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        job_type VARCHAR(64) NOT NULL,
+        status VARCHAR(32) DEFAULT 'pending',
+        total_items INTEGER DEFAULT 0,
+        processed_items INTEGER DEFAULT 0,
+        error_count INTEGER DEFAULT 0,
+        metadata JSONB DEFAULT '{}',
+        started_at TIMESTAMPTZ,
+        completed_at TIMESTAMPTZ,
+        created_at TIMESTAMPTZ DEFAULT NOW()
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_batch_jobs_status
+      ON {{schema}}.batch_jobs (status);
+    `,
+        down: `
+      DROP TABLE IF EXISTS {{schema}}.batch_jobs;
+    `,
     },
     {
         version: '1.5.0',
         name: 'Add neural pattern learning',
-        up: "\n      CREATE TABLE IF NOT EXISTS {{schema}}.neural_patterns (\n        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n        pattern_type VARCHAR(64) NOT NULL,\n        input_embedding vector(1536),\n        output_embedding vector(1536),\n        weight_matrix JSONB,\n        activation VARCHAR(32) DEFAULT 'relu',\n        accuracy FLOAT,\n        training_steps INTEGER DEFAULT 0,\n        created_at TIMESTAMPTZ DEFAULT NOW(),\n        updated_at TIMESTAMPTZ DEFAULT NOW()\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_neural_patterns_type\n      ON {{schema}}.neural_patterns (pattern_type);\n\n      CREATE INDEX IF NOT EXISTS idx_neural_patterns_input_hnsw\n      ON {{schema}}.neural_patterns\n      USING hnsw (input_embedding vector_cosine_ops)\n      WITH (m = 16, ef_construction = 64);\n    ",
-        down: "\n      DROP TABLE IF EXISTS {{schema}}.neural_patterns;\n    "
+        up: `
+      CREATE TABLE IF NOT EXISTS {{schema}}.neural_patterns (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        pattern_type VARCHAR(64) NOT NULL,
+        input_embedding vector(1536),
+        output_embedding vector(1536),
+        weight_matrix JSONB,
+        activation VARCHAR(32) DEFAULT 'relu',
+        accuracy FLOAT,
+        training_steps INTEGER DEFAULT 0,
+        created_at TIMESTAMPTZ DEFAULT NOW(),
+        updated_at TIMESTAMPTZ DEFAULT NOW()
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_neural_patterns_type
+      ON {{schema}}.neural_patterns (pattern_type);
+
+      CREATE INDEX IF NOT EXISTS idx_neural_patterns_input_hnsw
+      ON {{schema}}.neural_patterns
+      USING hnsw (input_embedding vector_cosine_ops)
+      WITH (m = 16, ef_construction = 64);
+    `,
+        down: `
+      DROP TABLE IF EXISTS {{schema}}.neural_patterns;
+    `,
     },
 ];
 /**
@@ -92,16 +141,16 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow'
+        schema: ctx.flags.schema || 'claude_flow',
     };
 }
 /**
  * Calculate simple checksum for migration SQL
  */
 function calculateChecksum(sql) {
-    var hash = 0;
-    for (var i = 0; i < sql.length; i++) {
-        var char = sql.charCodeAt(i);
+    let hash = 0;
+    for (let i = 0; i < sql.length; i++) {
+        const char = sql.charCodeAt(i);
         hash = ((hash << 5) - hash) + char;
         hash = hash & hash;
     }
@@ -110,7 +159,7 @@ function calculateChecksum(sql) {
 /**
  * RuVector migrate command
  */
-export var migrateCommand = {
+export const migrateCommand = {
     name: 'migrate',
     description: 'Run database migrations',
     options: [
@@ -118,74 +167,74 @@ export var migrateCommand = {
             name: 'up',
             description: 'Run pending migrations (default)',
             type: 'boolean',
-            "default": true
+            default: true,
         },
         {
             name: 'down',
             description: 'Rollback last migration',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'to',
             description: 'Migrate to specific version',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'dry-run',
             description: 'Show SQL without executing',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'force',
             description: 'Force migration even if dirty',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'host',
             short: 'h',
             description: 'PostgreSQL host',
             type: 'string',
-            "default": 'localhost'
+            default: 'localhost',
         },
         {
             name: 'port',
             short: 'p',
             description: 'PostgreSQL port',
             type: 'number',
-            "default": 5432
+            default: 5432,
         },
         {
             name: 'database',
             short: 'd',
             description: 'Database name',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'user',
             short: 'u',
             description: 'Database user',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'password',
             description: 'Database password',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'ssl',
             description: 'Enable SSL',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'schema',
             short: 's',
             description: 'Schema name',
             type: 'string',
-            "default": 'claude_flow'
+            default: 'claude_flow',
         },
     ],
     examples: [
@@ -194,275 +243,239 @@ export var migrateCommand = {
         { command: 'claude-flow ruvector migrate --to 1.2.0', description: 'Migrate to version 1.2.0' },
         { command: 'claude-flow ruvector migrate --dry-run', description: 'Preview migration SQL' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var config, dryRun, force, targetVersion, rollback, spinner, pg, _a, client, schemaExists, appliedResult, appliedVersions_1, migrationsToRun, direction_1, lastApplied_1, migration, targetIdx, currentVersions_1, currentIdx, _i, migrationsToRun_1, migration, sql, resolvedSql, confirmRun, results, _b, migrationsToRun_2, migration, sql, resolvedSql, checksum, error_1, errorMessage, successful, failed, error_2;
-        return __generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    config = getConnectionConfig(ctx);
-                    dryRun = ctx.flags['dry-run'];
-                    force = ctx.flags.force;
-                    targetVersion = ctx.flags.to;
-                    rollback = ctx.flags.down;
-                    output.writeln();
-                    output.writeln(output.bold('RuVector Migration'));
-                    output.writeln(output.dim('='.repeat(60)));
-                    output.writeln();
-                    if (!config.database) {
-                        output.printError('Database name is required. Use --database or -d flag, or set PGDATABASE env.');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    if (dryRun) {
-                        output.printInfo('Dry run mode: SQL will be shown but not executed');
-                        output.writeln();
-                    }
-                    spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-                    spinner.start();
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 39, , 40]);
-                    pg = null;
-                    _c.label = 2;
-                case 2:
-                    _c.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, import('pg')];
-                case 3:
-                    pg = _c.sent();
-                    return [3 /*break*/, 5];
-                case 4:
-                    _a = _c.sent();
-                    spinner.fail('PostgreSQL driver not found');
-                    output.printError('Install pg package: npm install pg');
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5:
-                    client = new pg.Client({
-                        host: config.host,
-                        port: config.port,
-                        database: config.database,
-                        user: config.user,
-                        password: config.password,
-                        ssl: config.ssl ? { rejectUnauthorized: false } : false
-                    });
-                    return [4 /*yield*/, client.connect()];
-                case 6:
-                    _c.sent();
-                    spinner.succeed('Connected to PostgreSQL');
-                    // Check if schema and migrations table exist
-                    spinner.setText('Checking migration status...');
-                    spinner.start();
-                    return [4 /*yield*/, client.query("\n        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1\n      ", [config.schema])];
-                case 7:
-                    schemaExists = _c.sent();
-                    if (!(schemaExists.rows.length === 0)) return [3 /*break*/, 9];
-                    spinner.fail("Schema \"" + config.schema + "\" not found");
-                    output.printError('Run `claude-flow ruvector init` first');
-                    return [4 /*yield*/, client.end()];
-                case 8:
-                    _c.sent();
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 9: return [4 /*yield*/, client.query("\n        SELECT version, name, applied_at, checksum\n        FROM " + config.schema + ".migrations\n        ORDER BY version ASC\n      ")];
-                case 10:
-                    appliedResult = _c.sent();
-                    appliedVersions_1 = new Set(appliedResult.rows.map(function (r) { return r.version; }));
-                    spinner.succeed("Found " + appliedVersions_1.size + " applied migrations");
-                    migrationsToRun = [];
-                    direction_1 = 'up';
-                    if (!rollback) return [3 /*break*/, 13];
-                    direction_1 = 'down';
-                    lastApplied_1 = appliedResult.rows[appliedResult.rows.length - 1];
-                    if (!!lastApplied_1) return [3 /*break*/, 12];
+    action: async (ctx) => {
+        const config = getConnectionConfig(ctx);
+        const dryRun = ctx.flags['dry-run'];
+        const force = ctx.flags.force;
+        const targetVersion = ctx.flags.to;
+        const rollback = ctx.flags.down;
+        output.writeln();
+        output.writeln(output.bold('RuVector Migration'));
+        output.writeln(output.dim('='.repeat(60)));
+        output.writeln();
+        if (!config.database) {
+            output.printError('Database name is required. Use --database or -d flag, or set PGDATABASE env.');
+            return { success: false, exitCode: 1 };
+        }
+        if (dryRun) {
+            output.printInfo('Dry run mode: SQL will be shown but not executed');
+            output.writeln();
+        }
+        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Import pg
+            let pg = null;
+            try {
+                pg = await import('pg');
+            }
+            catch {
+                spinner.fail('PostgreSQL driver not found');
+                output.printError('Install pg package: npm install pg');
+                return { success: false, exitCode: 1 };
+            }
+            const client = new pg.Client({
+                host: config.host,
+                port: config.port,
+                database: config.database,
+                user: config.user,
+                password: config.password,
+                ssl: config.ssl ? { rejectUnauthorized: false } : false,
+            });
+            await client.connect();
+            spinner.succeed('Connected to PostgreSQL');
+            // Check if schema and migrations table exist
+            spinner.setText('Checking migration status...');
+            spinner.start();
+            const schemaExists = await client.query(`
+        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1
+      `, [config.schema]);
+            if (schemaExists.rows.length === 0) {
+                spinner.fail(`Schema "${config.schema}" not found`);
+                output.printError('Run `claude-flow ruvector init` first');
+                await client.end();
+                return { success: false, exitCode: 1 };
+            }
+            // Get applied migrations
+            const appliedResult = await client.query(`
+        SELECT version, name, applied_at, checksum
+        FROM ${config.schema}.migrations
+        ORDER BY version ASC
+      `);
+            const appliedVersions = new Set(appliedResult.rows.map(r => r.version));
+            spinner.succeed(`Found ${appliedVersions.size} applied migrations`);
+            // Determine migrations to run
+            let migrationsToRun = [];
+            let direction = 'up';
+            if (rollback) {
+                direction = 'down';
+                // Get the last applied migration
+                const lastApplied = appliedResult.rows[appliedResult.rows.length - 1];
+                if (!lastApplied) {
                     output.printWarning('No migrations to rollback');
-                    return [4 /*yield*/, client.end()];
-                case 11:
-                    _c.sent();
-                    return [2 /*return*/, { success: true }];
-                case 12:
-                    migration = MIGRATIONS.find(function (m) { return m.version === lastApplied_1.version; });
-                    if (migration) {
-                        migrationsToRun = [migration];
-                    }
-                    return [3 /*break*/, 17];
-                case 13:
-                    if (!targetVersion) return [3 /*break*/, 16];
-                    targetIdx = MIGRATIONS.findIndex(function (m) { return m.version === targetVersion; });
-                    if (!(targetIdx === -1)) return [3 /*break*/, 15];
-                    output.printError("Version " + targetVersion + " not found");
-                    return [4 /*yield*/, client.end()];
-                case 14:
-                    _c.sent();
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 15:
-                    currentVersions_1 = Array.from(appliedVersions_1);
-                    currentIdx = currentVersions_1.length > 0
-                        ? MIGRATIONS.findIndex(function (m) { return m.version === currentVersions_1[currentVersions_1.length - 1]; })
-                        : -1;
-                    if (targetIdx > currentIdx) {
-                        // Migrate up
-                        migrationsToRun = MIGRATIONS.slice(currentIdx + 1, targetIdx + 1)
-                            .filter(function (m) { return !appliedVersions_1.has(m.version); });
-                    }
-                    else if (targetIdx < currentIdx) {
-                        // Migrate down
-                        direction_1 = 'down';
-                        migrationsToRun = MIGRATIONS.slice(targetIdx + 1, currentIdx + 1)
-                            .filter(function (m) { return appliedVersions_1.has(m.version); })
-                            .reverse();
-                    }
-                    return [3 /*break*/, 17];
-                case 16:
-                    // Run all pending migrations
-                    migrationsToRun = MIGRATIONS.filter(function (m) { return !appliedVersions_1.has(m.version); });
-                    _c.label = 17;
-                case 17:
-                    if (!(migrationsToRun.length === 0)) return [3 /*break*/, 19];
-                    output.printSuccess('Database is up to date');
-                    // Show current migration status
-                    output.writeln();
-                    output.writeln(output.highlight('Applied Migrations:'));
-                    output.printTable({
-                        columns: [
-                            { key: 'version', header: 'Version', width: 12 },
-                            { key: 'name', header: 'Name', width: 35 },
-                            { key: 'applied', header: 'Applied At', width: 22 },
-                        ],
-                        data: appliedResult.rows.map(function (r) { return ({
-                            version: r.version,
-                            name: r.name,
-                            applied: new Date(r.applied_at).toISOString().replace('T', ' ').substring(0, 19)
-                        }); })
-                    });
-                    return [4 /*yield*/, client.end()];
-                case 18:
-                    _c.sent();
-                    return [2 /*return*/, { success: true }];
-                case 19:
-                    // Show migrations to run
+                    await client.end();
+                    return { success: true };
+                }
+                const migration = MIGRATIONS.find(m => m.version === lastApplied.version);
+                if (migration) {
+                    migrationsToRun = [migration];
+                }
+            }
+            else if (targetVersion) {
+                // Migrate to specific version
+                const targetIdx = MIGRATIONS.findIndex(m => m.version === targetVersion);
+                if (targetIdx === -1) {
+                    output.printError(`Version ${targetVersion} not found`);
+                    await client.end();
+                    return { success: false, exitCode: 1 };
+                }
+                const currentVersions = Array.from(appliedVersions);
+                const currentIdx = currentVersions.length > 0
+                    ? MIGRATIONS.findIndex(m => m.version === currentVersions[currentVersions.length - 1])
+                    : -1;
+                if (targetIdx > currentIdx) {
+                    // Migrate up
+                    migrationsToRun = MIGRATIONS.slice(currentIdx + 1, targetIdx + 1)
+                        .filter(m => !appliedVersions.has(m.version));
+                }
+                else if (targetIdx < currentIdx) {
+                    // Migrate down
+                    direction = 'down';
+                    migrationsToRun = MIGRATIONS.slice(targetIdx + 1, currentIdx + 1)
+                        .filter(m => appliedVersions.has(m.version))
+                        .reverse();
+                }
+            }
+            else {
+                // Run all pending migrations
+                migrationsToRun = MIGRATIONS.filter(m => !appliedVersions.has(m.version));
+            }
+            if (migrationsToRun.length === 0) {
+                output.printSuccess('Database is up to date');
+                // Show current migration status
+                output.writeln();
+                output.writeln(output.highlight('Applied Migrations:'));
+                output.printTable({
+                    columns: [
+                        { key: 'version', header: 'Version', width: 12 },
+                        { key: 'name', header: 'Name', width: 35 },
+                        { key: 'applied', header: 'Applied At', width: 22 },
+                    ],
+                    data: appliedResult.rows.map(r => ({
+                        version: r.version,
+                        name: r.name,
+                        applied: new Date(r.applied_at).toISOString().replace('T', ' ').substring(0, 19),
+                    })),
+                });
+                await client.end();
+                return { success: true };
+            }
+            // Show migrations to run
+            output.writeln();
+            output.writeln(output.highlight(`Migrations to ${direction === 'up' ? 'apply' : 'rollback'}:`));
+            output.printTable({
+                columns: [
+                    { key: 'version', header: 'Version', width: 12 },
+                    { key: 'name', header: 'Name', width: 40 },
+                    { key: 'direction', header: 'Direction', width: 10 },
+                ],
+                data: migrationsToRun.map(m => ({
+                    version: m.version,
+                    name: m.name,
+                    direction: direction === 'up' ? output.success('UP') : output.warning('DOWN'),
+                })),
+            });
+            output.writeln();
+            // Dry run: show SQL
+            if (dryRun) {
+                for (const migration of migrationsToRun) {
+                    const sql = direction === 'up' ? migration.up : migration.down;
+                    const resolvedSql = sql.replace(/\{\{schema\}\}/g, config.schema);
+                    output.writeln(output.bold(`-- Migration ${migration.version}: ${migration.name}`));
+                    output.writeln(output.dim('-- Direction: ' + direction.toUpperCase()));
                     output.writeln();
-                    output.writeln(output.highlight("Migrations to " + (direction_1 === 'up' ? 'apply' : 'rollback') + ":"));
-                    output.printTable({
-                        columns: [
-                            { key: 'version', header: 'Version', width: 12 },
-                            { key: 'name', header: 'Name', width: 40 },
-                            { key: 'direction', header: 'Direction', width: 10 },
-                        ],
-                        data: migrationsToRun.map(function (m) { return ({
-                            version: m.version,
-                            name: m.name,
-                            direction: direction_1 === 'up' ? output.success('UP') : output.warning('DOWN')
-                        }); })
-                    });
+                    output.writeln(resolvedSql);
                     output.writeln();
-                    if (!dryRun) return [3 /*break*/, 21];
-                    for (_i = 0, migrationsToRun_1 = migrationsToRun; _i < migrationsToRun_1.length; _i++) {
-                        migration = migrationsToRun_1[_i];
-                        sql = direction_1 === 'up' ? migration.up : migration.down;
-                        resolvedSql = sql.replace(/\{\{schema\}\}/g, config.schema);
-                        output.writeln(output.bold("-- Migration " + migration.version + ": " + migration.name));
-                        output.writeln(output.dim('-- Direction: ' + direction_1.toUpperCase()));
-                        output.writeln();
-                        output.writeln(resolvedSql);
-                        output.writeln();
-                    }
-                    return [4 /*yield*/, client.end()];
-                case 20:
-                    _c.sent();
-                    return [2 /*return*/, { success: true, data: { dryRun: true, migrations: migrationsToRun.map(function (m) { return m.version; }) } }];
-                case 21:
-                    if (!(ctx.interactive && !force)) return [3 /*break*/, 24];
-                    return [4 /*yield*/, confirm({
-                            message: "Run " + migrationsToRun.length + " migration(s)?",
-                            "default": true
-                        })];
-                case 22:
-                    confirmRun = _c.sent();
-                    if (!!confirmRun) return [3 /*break*/, 24];
+                }
+                await client.end();
+                return { success: true, data: { dryRun: true, migrations: migrationsToRun.map(m => m.version) } };
+            }
+            // Confirm before running
+            if (ctx.interactive && !force) {
+                const confirmRun = await confirm({
+                    message: `Run ${migrationsToRun.length} migration(s)?`,
+                    default: true,
+                });
+                if (!confirmRun) {
                     output.printInfo('Migration cancelled');
-                    return [4 /*yield*/, client.end()];
-                case 23:
-                    _c.sent();
-                    return [2 /*return*/, { success: false, exitCode: 0 }];
-                case 24:
-                    results = [];
-                    _b = 0, migrationsToRun_2 = migrationsToRun;
-                    _c.label = 25;
-                case 25:
-                    if (!(_b < migrationsToRun_2.length)) return [3 /*break*/, 37];
-                    migration = migrationsToRun_2[_b];
-                    spinner.setText("Running migration " + migration.version + ": " + migration.name + "...");
-                    spinner.start();
-                    _c.label = 26;
-                case 26:
-                    _c.trys.push([26, 34, , 36]);
-                    sql = direction_1 === 'up' ? migration.up : migration.down;
-                    resolvedSql = sql.replace(/\{\{schema\}\}/g, config.schema);
-                    return [4 /*yield*/, client.query('BEGIN')];
-                case 27:
-                    _c.sent();
-                    // Execute migration SQL
-                    return [4 /*yield*/, client.query(resolvedSql)];
-                case 28:
+                    await client.end();
+                    return { success: false, exitCode: 0 };
+                }
+            }
+            // Run migrations
+            const results = [];
+            for (const migration of migrationsToRun) {
+                spinner.setText(`Running migration ${migration.version}: ${migration.name}...`);
+                spinner.start();
+                try {
+                    const sql = direction === 'up' ? migration.up : migration.down;
+                    const resolvedSql = sql.replace(/\{\{schema\}\}/g, config.schema);
+                    await client.query('BEGIN');
                     // Execute migration SQL
-                    _c.sent();
-                    if (!(direction_1 === 'up')) return [3 /*break*/, 30];
-                    checksum = calculateChecksum(resolvedSql);
-                    return [4 /*yield*/, client.query("\n              INSERT INTO " + config.schema + ".migrations (version, name, checksum)\n              VALUES ($1, $2, $3)\n              ON CONFLICT (version) DO UPDATE SET applied_at = NOW()\n            ", [migration.version, migration.name, checksum])];
-                case 29:
-                    _c.sent();
-                    return [3 /*break*/, 32];
-                case 30: return [4 /*yield*/, client.query("\n              DELETE FROM " + config.schema + ".migrations WHERE version = $1\n            ", [migration.version])];
-                case 31:
-                    _c.sent();
-                    _c.label = 32;
-                case 32: return [4 /*yield*/, client.query('COMMIT')];
-                case 33:
-                    _c.sent();
-                    spinner.succeed("Migration " + migration.version + " " + (direction_1 === 'up' ? 'applied' : 'rolled back'));
+                    await client.query(resolvedSql);
+                    // Update migrations table
+                    if (direction === 'up') {
+                        const checksum = calculateChecksum(resolvedSql);
+                        await client.query(`
+              INSERT INTO ${config.schema}.migrations (version, name, checksum)
+              VALUES ($1, $2, $3)
+              ON CONFLICT (version) DO UPDATE SET applied_at = NOW()
+            `, [migration.version, migration.name, checksum]);
+                    }
+                    else {
+                        await client.query(`
+              DELETE FROM ${config.schema}.migrations WHERE version = $1
+            `, [migration.version]);
+                    }
+                    await client.query('COMMIT');
+                    spinner.succeed(`Migration ${migration.version} ${direction === 'up' ? 'applied' : 'rolled back'}`);
                     results.push({ version: migration.version, success: true });
-                    return [3 /*break*/, 36];
-                case 34:
-                    error_1 = _c.sent();
-                    return [4 /*yield*/, client.query('ROLLBACK')];
-                case 35:
-                    _c.sent();
-                    spinner.fail("Migration " + migration.version + " failed");
-                    errorMessage = error_1 instanceof Error ? error_1.message : String(error_1);
+                }
+                catch (error) {
+                    await client.query('ROLLBACK');
+                    spinner.fail(`Migration ${migration.version} failed`);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
                     output.printError(errorMessage);
                     results.push({ version: migration.version, success: false, error: errorMessage });
                     if (!force) {
                         output.printWarning('Stopping migration due to error. Use --force to continue.');
-                        return [3 /*break*/, 37];
+                        break;
                     }
-                    return [3 /*break*/, 36];
-                case 36:
-                    _b++;
-                    return [3 /*break*/, 25];
-                case 37: return [4 /*yield*/, client.end()];
-                case 38:
-                    _c.sent();
-                    // Summary
-                    output.writeln();
-                    successful = results.filter(function (r) { return r.success; }).length;
-                    failed = results.filter(function (r) { return !r.success; }).length;
-                    if (failed === 0) {
-                        output.printSuccess("All " + successful + " migration(s) completed successfully");
-                    }
-                    else {
-                        output.printWarning(successful + " succeeded, " + failed + " failed");
-                    }
-                    return [2 /*return*/, {
-                            success: failed === 0,
-                            data: { results: results },
-                            exitCode: failed > 0 ? 1 : 0
-                        }];
-                case 39:
-                    error_2 = _c.sent();
-                    spinner.fail('Migration failed');
-                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 40: return [2 /*return*/];
+                }
+            }
+            await client.end();
+            // Summary
+            output.writeln();
+            const successful = results.filter(r => r.success).length;
+            const failed = results.filter(r => !r.success).length;
+            if (failed === 0) {
+                output.printSuccess(`All ${successful} migration(s) completed successfully`);
             }
-        });
-    }); }
+            else {
+                output.printWarning(`${successful} succeeded, ${failed} failed`);
+            }
+            return {
+                success: failed === 0,
+                data: { results },
+                exitCode: failed > 0 ? 1 : 0,
+            };
+        }
+        catch (error) {
+            spinner.fail('Migration failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 export default migrateCommand;
 //# sourceMappingURL=migrate.js.map