kynjal-cli 4.0.0 → 4.0.2

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

@@ -2,53 +2,6 @@
  * V3 CLI RuVector Status Command
  * Check connection and schema status
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import { output } from '../../output.js';
 /**
  * Get PostgreSQL connection config from context
@@ -61,7 +14,7 @@ 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',
     };
 }
 /**
@@ -70,15 +23,15 @@ function getConnectionConfig(ctx) {
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    var k = 1024;
-    var sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 /**
  * RuVector status command
  */
-export var statusCommand = {
+export const statusCommand = {
     name: 'status',
     description: 'Check connection and schema status',
     options: [
@@ -87,57 +40,57 @@ export var statusCommand = {
             short: 'v',
             description: 'Show detailed information',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'json',
             description: 'Output as JSON',
             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: [
@@ -145,367 +98,359 @@ export var statusCommand = {
         { command: 'claude-flow ruvector status --verbose', description: 'Show detailed info' },
         { command: 'claude-flow ruvector status --json', description: 'Output as JSON' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var config, verbose, jsonOutput, statusData, spinner, pg, _a, startTime, client, connectionTime, versionResult, pgVersion, extensionResult, schemaResult, metadataResult, metadata, _i, _b, row, _c, tablesResult, tableStats, _d, _e, row, rowCount, countResult, _f, indexResult, migrationsResult, _g, pgvectorData, ruvectorData, migrations, embeddingsTable, error_1, errorMessage;
-        return __generator(this, function (_h) {
-            switch (_h.label) {
-                case 0:
-                    config = getConnectionConfig(ctx);
-                    verbose = ctx.flags.verbose;
-                    jsonOutput = ctx.flags.json;
-                    if (!jsonOutput) {
-                        output.writeln();
-                        output.writeln(output.bold('RuVector PostgreSQL Status'));
-                        output.writeln(output.dim('='.repeat(60)));
-                        output.writeln();
-                    }
-                    if (!config.database) {
-                        if (jsonOutput) {
-                            output.printJson({ error: 'Database name required' });
-                        }
-                        else {
-                            output.printError('Database name is required. Use --database or -d flag, or set PGDATABASE env.');
-                        }
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    statusData = {
-                        connection: {},
-                        pgvector: {},
-                        ruvector: {},
-                        tables: [],
-                        indexes: [],
-                        migrations: []
-                    };
-                    spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-                    if (!jsonOutput)
-                        spinner.start();
-                    _h.label = 1;
-                case 1:
-                    _h.trys.push([1, 31, , 32]);
-                    pg = null;
-                    _h.label = 2;
-                case 2:
-                    _h.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, import('pg')];
-                case 3:
-                    pg = _h.sent();
-                    return [3 /*break*/, 5];
-                case 4:
-                    _a = _h.sent();
-                    if (!jsonOutput)
-                        spinner.fail('PostgreSQL driver not found');
-                    if (jsonOutput) {
-                        output.printJson({ error: 'pg package not installed' });
-                    }
-                    else {
-                        output.printError('Install pg package: npm install pg');
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 5:
-                    startTime = Date.now();
-                    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:
-                    _h.sent();
-                    connectionTime = Date.now() - startTime;
-                    if (!jsonOutput)
-                        spinner.succeed("Connected in " + connectionTime + "ms");
-                    statusData.connection = {
-                        host: config.host,
-                        port: config.port,
-                        database: config.database,
-                        user: config.user,
-                        ssl: config.ssl,
-                        latency: connectionTime,
-                        status: 'connected'
-                    };
-                    return [4 /*yield*/, client.query('SELECT version()')];
-                case 7:
-                    versionResult = _h.sent();
-                    pgVersion = versionResult.rows[0].version;
-                    statusData.connection.pgVersion = pgVersion;
-                    // Check pgvector extension
-                    if (!jsonOutput)
-                        spinner.setText('Checking pgvector extension...');
-                    spinner.start();
-                    return [4 /*yield*/, client.query("\n        SELECT extversion FROM pg_extension WHERE extname = 'vector'\n      ")];
-                case 8:
-                    extensionResult = _h.sent();
-                    if (extensionResult.rows.length === 0) {
-                        statusData.pgvector = { installed: false };
-                        if (!jsonOutput) {
-                            spinner.succeed(output.warning('pgvector extension not installed'));
-                        }
-                    }
-                    else {
-                        statusData.pgvector = {
-                            installed: true,
-                            version: extensionResult.rows[0].extversion
-                        };
-                        if (!jsonOutput) {
-                            spinner.succeed("pgvector v" + extensionResult.rows[0].extversion + " installed");
-                        }
-                    }
-                    // Check schema exists
-                    if (!jsonOutput)
-                        spinner.setText("Checking schema \"" + config.schema + "\"...");
-                    spinner.start();
-                    return [4 /*yield*/, client.query("\n        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1\n      ", [config.schema])];
-                case 9:
-                    schemaResult = _h.sent();
-                    if (!(schemaResult.rows.length === 0)) return [3 /*break*/, 11];
-                    statusData.ruvector = { initialized: false };
-                    if (!jsonOutput) {
-                        spinner.succeed(output.warning("Schema \"" + config.schema + "\" not found"));
-                        output.printInfo('Run `claude-flow ruvector init` to initialize');
-                    }
-                    if (jsonOutput) {
-                        output.printJson(statusData);
-                    }
-                    return [4 /*yield*/, client.end()];
-                case 10:
-                    _h.sent();
-                    return [2 /*return*/, { success: true, data: statusData }];
-                case 11:
-                    if (!jsonOutput)
-                        spinner.succeed("Schema \"" + config.schema + "\" found");
-                    // Get RuVector metadata
-                    if (!jsonOutput)
-                        spinner.setText('Loading RuVector metadata...');
-                    spinner.start();
-                    _h.label = 12;
-                case 12:
-                    _h.trys.push([12, 14, , 15]);
-                    return [4 /*yield*/, client.query("\n          SELECT key, value FROM " + config.schema + ".metadata\n        ")];
-                case 13:
-                    metadataResult = _h.sent();
-                    metadata = {};
-                    for (_i = 0, _b = metadataResult.rows; _i < _b.length; _i++) {
-                        row = _b[_i];
-                        metadata[row.key] = JSON.parse(row.value);
-                    }
-                    statusData.ruvector = {
-                        initialized: true,
-                        version: metadata.ruvector_version || 'unknown',
-                        dimensions: metadata.dimensions || 1536,
-                        initializedAt: metadata.initialized_at
-                    };
-                    if (!jsonOutput)
-                        spinner.succeed('RuVector metadata loaded');
-                    return [3 /*break*/, 15];
-                case 14:
-                    _c = _h.sent();
-                    statusData.ruvector = { initialized: true, version: 'unknown' };
-                    if (!jsonOutput)
-                        spinner.succeed(output.warning('Could not load RuVector metadata'));
-                    return [3 /*break*/, 15];
-                case 15:
-                    // Get table statistics
-                    if (!jsonOutput)
-                        spinner.setText('Gathering table statistics...');
-                    spinner.start();
-                    return [4 /*yield*/, client.query("\n        SELECT\n          t.table_name,\n          pg_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as table_size,\n          pg_total_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as total_size,\n          (SELECT count(*) FROM " + config.schema + ".embeddings) as row_count\n        FROM information_schema.tables t\n        WHERE t.table_schema = $1\n        ORDER BY t.table_name\n      ", [config.schema])];
-                case 16:
-                    tablesResult = _h.sent();
-                    tableStats = [];
-                    _d = 0, _e = tablesResult.rows;
-                    _h.label = 17;
-                case 17:
-                    if (!(_d < _e.length)) return [3 /*break*/, 23];
-                    row = _e[_d];
-                    rowCount = 0;
-                    _h.label = 18;
-                case 18:
-                    _h.trys.push([18, 20, , 21]);
-                    return [4 /*yield*/, client.query("\n            SELECT count(*) as cnt FROM " + config.schema + "." + row.table_name + "\n          ")];
-                case 19:
-                    countResult = _h.sent();
+    action: async (ctx) => {
+        const config = getConnectionConfig(ctx);
+        const verbose = ctx.flags.verbose;
+        const jsonOutput = ctx.flags.json;
+        if (!jsonOutput) {
+            output.writeln();
+            output.writeln(output.bold('RuVector PostgreSQL Status'));
+            output.writeln(output.dim('='.repeat(60)));
+            output.writeln();
+        }
+        if (!config.database) {
+            if (jsonOutput) {
+                output.printJson({ error: 'Database name required' });
+            }
+            else {
+                output.printError('Database name is required. Use --database or -d flag, or set PGDATABASE env.');
+            }
+            return { success: false, exitCode: 1 };
+        }
+        const statusData = {
+            connection: {},
+            pgvector: {},
+            ruvector: {},
+            tables: [],
+            indexes: [],
+            migrations: [],
+        };
+        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
+        if (!jsonOutput)
+            spinner.start();
+        try {
+            // Import pg
+            let pg = null;
+            try {
+                pg = await import('pg');
+            }
+            catch {
+                if (!jsonOutput)
+                    spinner.fail('PostgreSQL driver not found');
+                if (jsonOutput) {
+                    output.printJson({ error: 'pg package not installed' });
+                }
+                else {
+                    output.printError('Install pg package: npm install pg');
+                }
+                return { success: false, exitCode: 1 };
+            }
+            const startTime = Date.now();
+            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();
+            const connectionTime = Date.now() - startTime;
+            if (!jsonOutput)
+                spinner.succeed(`Connected in ${connectionTime}ms`);
+            statusData.connection = {
+                host: config.host,
+                port: config.port,
+                database: config.database,
+                user: config.user,
+                ssl: config.ssl,
+                latency: connectionTime,
+                status: 'connected',
+            };
+            // Get PostgreSQL version
+            const versionResult = await client.query('SELECT version()');
+            const pgVersion = versionResult.rows[0].version;
+            statusData.connection.pgVersion = pgVersion;
+            // Check pgvector extension
+            if (!jsonOutput)
+                spinner.setText('Checking pgvector extension...');
+            spinner.start();
+            const extensionResult = await client.query(`
+        SELECT extversion FROM pg_extension WHERE extname = 'vector'
+      `);
+            if (extensionResult.rows.length === 0) {
+                statusData.pgvector = { installed: false };
+                if (!jsonOutput) {
+                    spinner.succeed(output.warning('pgvector extension not installed'));
+                }
+            }
+            else {
+                statusData.pgvector = {
+                    installed: true,
+                    version: extensionResult.rows[0].extversion,
+                };
+                if (!jsonOutput) {
+                    spinner.succeed(`pgvector v${extensionResult.rows[0].extversion} installed`);
+                }
+            }
+            // Check schema exists
+            if (!jsonOutput)
+                spinner.setText(`Checking schema "${config.schema}"...`);
+            spinner.start();
+            const schemaResult = await client.query(`
+        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1
+      `, [config.schema]);
+            if (schemaResult.rows.length === 0) {
+                statusData.ruvector = { initialized: false };
+                if (!jsonOutput) {
+                    spinner.succeed(output.warning(`Schema "${config.schema}" not found`));
+                    output.printInfo('Run `claude-flow ruvector init` to initialize');
+                }
+                if (jsonOutput) {
+                    output.printJson(statusData);
+                }
+                await client.end();
+                return { success: true, data: statusData };
+            }
+            if (!jsonOutput)
+                spinner.succeed(`Schema "${config.schema}" found`);
+            // Get RuVector metadata
+            if (!jsonOutput)
+                spinner.setText('Loading RuVector metadata...');
+            spinner.start();
+            try {
+                const metadataResult = await client.query(`
+          SELECT key, value FROM ${config.schema}.metadata
+        `);
+                const metadata = {};
+                for (const row of metadataResult.rows) {
+                    metadata[row.key] = JSON.parse(row.value);
+                }
+                statusData.ruvector = {
+                    initialized: true,
+                    version: metadata.ruvector_version || 'unknown',
+                    dimensions: metadata.dimensions || 1536,
+                    initializedAt: metadata.initialized_at,
+                };
+                if (!jsonOutput)
+                    spinner.succeed('RuVector metadata loaded');
+            }
+            catch {
+                statusData.ruvector = { initialized: true, version: 'unknown' };
+                if (!jsonOutput)
+                    spinner.succeed(output.warning('Could not load RuVector metadata'));
+            }
+            // Get table statistics
+            if (!jsonOutput)
+                spinner.setText('Gathering table statistics...');
+            spinner.start();
+            const tablesResult = await client.query(`
+        SELECT
+          t.table_name,
+          pg_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as table_size,
+          pg_total_relation_size(quote_ident(t.table_schema) || '.' || quote_ident(t.table_name)) as total_size,
+          (SELECT count(*) FROM ${config.schema}.embeddings) as row_count
+        FROM information_schema.tables t
+        WHERE t.table_schema = $1
+        ORDER BY t.table_name
+      `, [config.schema]);
+            const tableStats = [];
+            for (const row of tablesResult.rows) {
+                // Get row count for each table
+                let rowCount = 0;
+                try {
+                    const countResult = await client.query(`
+            SELECT count(*) as cnt FROM ${config.schema}.${row.table_name}
+          `);
                     rowCount = parseInt(countResult.rows[0].cnt, 10);
-                    return [3 /*break*/, 21];
-                case 20:
-                    _f = _h.sent();
-                    return [3 /*break*/, 21];
-                case 21:
-                    tableStats.push({
-                        name: row.table_name,
-                        rows: rowCount,
-                        size: formatBytes(parseInt(row.table_size, 10)),
-                        totalSize: formatBytes(parseInt(row.total_size, 10))
+                }
+                catch {
+                    // Skip if can't count
+                }
+                tableStats.push({
+                    name: row.table_name,
+                    rows: rowCount,
+                    size: formatBytes(parseInt(row.table_size, 10)),
+                    totalSize: formatBytes(parseInt(row.total_size, 10)),
+                });
+            }
+            statusData.tables = tableStats;
+            if (!jsonOutput)
+                spinner.succeed(`Found ${tableStats.length} tables`);
+            // Get index information
+            if (verbose) {
+                if (!jsonOutput)
+                    spinner.setText('Gathering index information...');
+                spinner.start();
+                const indexResult = await client.query(`
+          SELECT
+            i.relname as index_name,
+            t.relname as table_name,
+            am.amname as index_type,
+            pg_relation_size(i.oid) as index_size,
+            idx.indisvalid as is_valid,
+            idx.indisunique as is_unique
+          FROM pg_index idx
+          JOIN pg_class i ON i.oid = idx.indexrelid
+          JOIN pg_class t ON t.oid = idx.indrelid
+          JOIN pg_namespace n ON n.oid = t.relnamespace
+          JOIN pg_am am ON am.oid = i.relam
+          WHERE n.nspname = $1
+          ORDER BY t.relname, i.relname
+        `, [config.schema]);
+                statusData.indexes = indexResult.rows.map(row => ({
+                    name: row.index_name,
+                    table: row.table_name,
+                    type: row.index_type,
+                    size: formatBytes(parseInt(row.index_size, 10)),
+                    valid: row.is_valid,
+                    unique: row.is_unique,
+                }));
+                if (!jsonOutput)
+                    spinner.succeed(`Found ${indexResult.rows.length} indexes`);
+            }
+            // Get migration status
+            if (!jsonOutput)
+                spinner.setText('Checking migration status...');
+            spinner.start();
+            try {
+                const migrationsResult = await client.query(`
+          SELECT version, name, applied_at
+          FROM ${config.schema}.migrations
+          ORDER BY version ASC
+        `);
+                statusData.migrations = migrationsResult.rows.map(row => ({
+                    version: row.version,
+                    name: row.name,
+                    appliedAt: row.applied_at,
+                }));
+                if (!jsonOutput)
+                    spinner.succeed(`${migrationsResult.rows.length} migrations applied`);
+            }
+            catch {
+                statusData.migrations = [];
+                if (!jsonOutput)
+                    spinner.succeed(output.warning('Could not read migrations table'));
+            }
+            await client.end();
+            // Output results
+            if (jsonOutput) {
+                output.printJson(statusData);
+            }
+            else {
+                output.writeln();
+                // Connection info
+                output.writeln(output.highlight('Connection:'));
+                output.printTable({
+                    columns: [
+                        { key: 'property', header: 'Property', width: 20 },
+                        { key: 'value', header: 'Value', width: 40 },
+                    ],
+                    data: [
+                        { property: 'Host', value: config.host },
+                        { property: 'Port', value: String(config.port) },
+                        { property: 'Database', value: config.database },
+                        { property: 'User', value: config.user },
+                        { property: 'SSL', value: config.ssl ? 'Enabled' : 'Disabled' },
+                        { property: 'Latency', value: `${connectionTime}ms` },
+                    ],
+                });
+                output.writeln();
+                // pgvector info
+                output.writeln(output.highlight('pgvector Extension:'));
+                const pgvectorData = statusData.pgvector;
+                output.writeln(`  Status: ${pgvectorData.installed ? output.success('Installed') : output.error('Not Installed')}`);
+                if (pgvectorData.version) {
+                    output.writeln(`  Version: ${pgvectorData.version}`);
+                }
+                output.writeln();
+                // RuVector info
+                output.writeln(output.highlight('RuVector:'));
+                const ruvectorData = statusData.ruvector;
+                output.writeln(`  Initialized: ${ruvectorData.initialized ? output.success('Yes') : output.error('No')}`);
+                if (ruvectorData.version) {
+                    output.writeln(`  Version: ${ruvectorData.version}`);
+                }
+                if (ruvectorData.dimensions) {
+                    output.writeln(`  Dimensions: ${ruvectorData.dimensions}`);
+                }
+                output.writeln();
+                // Table statistics
+                output.writeln(output.highlight('Table Statistics:'));
+                output.printTable({
+                    columns: [
+                        { key: 'name', header: 'Table', width: 30 },
+                        { key: 'rows', header: 'Rows', width: 12 },
+                        { key: 'size', header: 'Size', width: 12 },
+                        { key: 'totalSize', header: 'Total Size', width: 12 },
+                    ],
+                    data: tableStats,
+                });
+                output.writeln();
+                // Index information (verbose only)
+                if (verbose && statusData.indexes.length > 0) {
+                    output.writeln(output.highlight('Index Health:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'name', header: 'Index', width: 35 },
+                            { key: 'table', header: 'Table', width: 20 },
+                            { key: 'type', header: 'Type', width: 10 },
+                            { key: 'size', header: 'Size', width: 10 },
+                            { key: 'status', header: 'Status', width: 10 },
+                        ],
+                        data: statusData.indexes.map(idx => ({
+                            ...idx,
+                            status: idx.valid ? output.success('Valid') : output.error('Invalid'),
+                        })),
                     });
-                    _h.label = 22;
-                case 22:
-                    _d++;
-                    return [3 /*break*/, 17];
-                case 23:
-                    statusData.tables = tableStats;
-                    if (!jsonOutput)
-                        spinner.succeed("Found " + tableStats.length + " tables");
-                    if (!verbose) return [3 /*break*/, 25];
-                    if (!jsonOutput)
-                        spinner.setText('Gathering index information...');
-                    spinner.start();
-                    return [4 /*yield*/, client.query("\n          SELECT\n            i.relname as index_name,\n            t.relname as table_name,\n            am.amname as index_type,\n            pg_relation_size(i.oid) as index_size,\n            idx.indisvalid as is_valid,\n            idx.indisunique as is_unique\n          FROM pg_index idx\n          JOIN pg_class i ON i.oid = idx.indexrelid\n          JOIN pg_class t ON t.oid = idx.indrelid\n          JOIN pg_namespace n ON n.oid = t.relnamespace\n          JOIN pg_am am ON am.oid = i.relam\n          WHERE n.nspname = $1\n          ORDER BY t.relname, i.relname\n        ", [config.schema])];
-                case 24:
-                    indexResult = _h.sent();
-                    statusData.indexes = indexResult.rows.map(function (row) { return ({
-                        name: row.index_name,
-                        table: row.table_name,
-                        type: row.index_type,
-                        size: formatBytes(parseInt(row.index_size, 10)),
-                        valid: row.is_valid,
-                        unique: row.is_unique
-                    }); });
-                    if (!jsonOutput)
-                        spinner.succeed("Found " + indexResult.rows.length + " indexes");
-                    _h.label = 25;
-                case 25:
-                    // Get migration status
-                    if (!jsonOutput)
-                        spinner.setText('Checking migration status...');
-                    spinner.start();
-                    _h.label = 26;
-                case 26:
-                    _h.trys.push([26, 28, , 29]);
-                    return [4 /*yield*/, client.query("\n          SELECT version, name, applied_at\n          FROM " + config.schema + ".migrations\n          ORDER BY version ASC\n        ")];
-                case 27:
-                    migrationsResult = _h.sent();
-                    statusData.migrations = migrationsResult.rows.map(function (row) { return ({
-                        version: row.version,
-                        name: row.name,
-                        appliedAt: row.applied_at
-                    }); });
-                    if (!jsonOutput)
-                        spinner.succeed(migrationsResult.rows.length + " migrations applied");
-                    return [3 /*break*/, 29];
-                case 28:
-                    _g = _h.sent();
-                    statusData.migrations = [];
-                    if (!jsonOutput)
-                        spinner.succeed(output.warning('Could not read migrations table'));
-                    return [3 /*break*/, 29];
-                case 29: return [4 /*yield*/, client.end()];
-                case 30:
-                    _h.sent();
-                    // Output results
-                    if (jsonOutput) {
-                        output.printJson(statusData);
-                    }
-                    else {
-                        output.writeln();
-                        // Connection info
-                        output.writeln(output.highlight('Connection:'));
-                        output.printTable({
-                            columns: [
-                                { key: 'property', header: 'Property', width: 20 },
-                                { key: 'value', header: 'Value', width: 40 },
-                            ],
-                            data: [
-                                { property: 'Host', value: config.host },
-                                { property: 'Port', value: String(config.port) },
-                                { property: 'Database', value: config.database },
-                                { property: 'User', value: config.user },
-                                { property: 'SSL', value: config.ssl ? 'Enabled' : 'Disabled' },
-                                { property: 'Latency', value: connectionTime + "ms" },
-                            ]
-                        });
-                        output.writeln();
-                        // pgvector info
-                        output.writeln(output.highlight('pgvector Extension:'));
-                        pgvectorData = statusData.pgvector;
-                        output.writeln("  Status: " + (pgvectorData.installed ? output.success('Installed') : output.error('Not Installed')));
-                        if (pgvectorData.version) {
-                            output.writeln("  Version: " + pgvectorData.version);
-                        }
-                        output.writeln();
-                        // RuVector info
-                        output.writeln(output.highlight('RuVector:'));
-                        ruvectorData = statusData.ruvector;
-                        output.writeln("  Initialized: " + (ruvectorData.initialized ? output.success('Yes') : output.error('No')));
-                        if (ruvectorData.version) {
-                            output.writeln("  Version: " + ruvectorData.version);
-                        }
-                        if (ruvectorData.dimensions) {
-                            output.writeln("  Dimensions: " + ruvectorData.dimensions);
-                        }
-                        output.writeln();
-                        // Table statistics
-                        output.writeln(output.highlight('Table Statistics:'));
-                        output.printTable({
-                            columns: [
-                                { key: 'name', header: 'Table', width: 30 },
-                                { key: 'rows', header: 'Rows', width: 12 },
-                                { key: 'size', header: 'Size', width: 12 },
-                                { key: 'totalSize', header: 'Total Size', width: 12 },
-                            ],
-                            data: tableStats
-                        });
-                        output.writeln();
-                        // Index information (verbose only)
-                        if (verbose && statusData.indexes.length > 0) {
-                            output.writeln(output.highlight('Index Health:'));
-                            output.printTable({
-                                columns: [
-                                    { key: 'name', header: 'Index', width: 35 },
-                                    { key: 'table', header: 'Table', width: 20 },
-                                    { key: 'type', header: 'Type', width: 10 },
-                                    { key: 'size', header: 'Size', width: 10 },
-                                    { key: 'status', header: 'Status', width: 10 },
-                                ],
-                                data: statusData.indexes.map(function (idx) { return (__assign(__assign({}, idx), { status: idx.valid ? output.success('Valid') : output.error('Invalid') })); })
-                            });
-                            output.writeln();
-                        }
-                        // Migration status
-                        output.writeln(output.highlight('Migrations:'));
-                        migrations = statusData.migrations;
-                        if (migrations.length === 0) {
-                            output.writeln('  No migrations applied');
-                        }
-                        else {
-                            output.printTable({
-                                columns: [
-                                    { key: 'version', header: 'Version', width: 12 },
-                                    { key: 'name', header: 'Name', width: 35 },
-                                    { key: 'appliedAt', header: 'Applied At', width: 22 },
-                                ],
-                                data: migrations.map(function (m) { return (__assign(__assign({}, m), { appliedAt: new Date(m.appliedAt).toISOString().replace('T', ' ').substring(0, 19) })); })
-                            });
-                        }
-                        output.writeln();
-                        embeddingsTable = tableStats.find(function (t) { return t.name === 'embeddings'; });
-                        if (embeddingsTable) {
-                            output.printBox([
-                                "Total Vectors: " + embeddingsTable.rows.toLocaleString(),
-                                "Storage Used: " + embeddingsTable.totalSize,
-                                "Schema: " + config.schema,
-                                "Migrations: " + migrations.length + " applied",
-                            ].join('\n'), 'Summary');
-                        }
-                    }
-                    return [2 /*return*/, { success: true, data: statusData }];
-                case 31:
-                    error_1 = _h.sent();
-                    if (!jsonOutput)
-                        spinner.fail('Status check failed');
-                    errorMessage = error_1 instanceof Error ? error_1.message : String(error_1);
-                    if (jsonOutput) {
-                        output.printJson({ error: errorMessage });
-                    }
-                    else {
-                        output.printError(errorMessage);
-                    }
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 32: return [2 /*return*/];
+                    output.writeln();
+                }
+                // Migration status
+                output.writeln(output.highlight('Migrations:'));
+                const migrations = statusData.migrations;
+                if (migrations.length === 0) {
+                    output.writeln('  No migrations applied');
+                }
+                else {
+                    output.printTable({
+                        columns: [
+                            { key: 'version', header: 'Version', width: 12 },
+                            { key: 'name', header: 'Name', width: 35 },
+                            { key: 'appliedAt', header: 'Applied At', width: 22 },
+                        ],
+                        data: migrations.map(m => ({
+                            ...m,
+                            appliedAt: new Date(m.appliedAt).toISOString().replace('T', ' ').substring(0, 19),
+                        })),
+                    });
+                }
+                output.writeln();
+                // Summary
+                const embeddingsTable = tableStats.find(t => t.name === 'embeddings');
+                if (embeddingsTable) {
+                    output.printBox([
+                        `Total Vectors: ${embeddingsTable.rows.toLocaleString()}`,
+                        `Storage Used: ${embeddingsTable.totalSize}`,
+                        `Schema: ${config.schema}`,
+                        `Migrations: ${migrations.length} applied`,
+                    ].join('\n'), 'Summary');
+                }
             }
-        });
-    }); }
+            return { success: true, data: statusData };
+        }
+        catch (error) {
+            if (!jsonOutput)
+                spinner.fail('Status check failed');
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (jsonOutput) {
+                output.printJson({ error: errorMessage });
+            }
+            else {
+                output.printError(errorMessage);
+            }
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 export default statusCommand;
 //# sourceMappingURL=status.js.map