kynjal-cli 3.1.3 → 4.0.0

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

@@ -2,132 +2,83 @@
  * 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
  */
-const MIGRATIONS = [
+var 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: `
-      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;
-    `,
+        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    "
     },
     {
         version: '1.2.0',
         name: 'Add embedding statistics',
-        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;
-    `,
+        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    "
     },
     {
         version: '1.3.0',
         name: 'Add query cache',
-        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;
-    `,
+        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    "
     },
     {
         version: '1.4.0',
         name: 'Add batch operations support',
-        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;
-    `,
+        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    "
     },
     {
         version: '1.5.0',
         name: 'Add neural pattern learning',
-        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;
-    `,
+        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    "
     },
 ];
 /**
@@ -141,16 +92,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) {
-    let hash = 0;
-    for (let i = 0; i < sql.length; i++) {
-        const char = sql.charCodeAt(i);
+    var hash = 0;
+    for (var i = 0; i < sql.length; i++) {
+        var char = sql.charCodeAt(i);
         hash = ((hash << 5) - hash) + char;
         hash = hash & hash;
     }
@@ -159,7 +110,7 @@ function calculateChecksum(sql) {
 /**
  * RuVector migrate command
  */
-export const migrateCommand = {
+export var migrateCommand = {
     name: 'migrate',
     description: 'Run database migrations',
     options: [
@@ -167,74 +118,74 @@ export const 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: [
@@ -243,239 +194,275 @@ export const 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: 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) {
+    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];
                     output.printWarning('No migrations to rollback');
-                    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()));
+                    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(resolvedSql);
+                    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
                     output.writeln();
-                }
-                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.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();
+                    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];
                     output.printInfo('Migration cancelled');
-                    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');
+                    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
-                    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'}`);
+                    return [4 /*yield*/, client.query(resolvedSql)];
+                case 28:
+                    // 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'));
                     results.push({ version: migration.version, success: true });
-                }
-                catch (error) {
-                    await client.query('ROLLBACK');
-                    spinner.fail(`Migration ${migration.version} failed`);
-                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    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);
                     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.');
-                        break;
+                        return [3 /*break*/, 37];
                     }
-                }
-            }
-            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 [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*/];
             }
-            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