kynjal-cli 3.1.3 → 4.0.0

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

@@ -2,6 +2,53 @@
  * 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
@@ -14,7 +61,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'
     };
 }
 /**
@@ -23,15 +70,15 @@ function getConnectionConfig(ctx) {
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    var k = 1024;
+    var sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 /**
  * RuVector status command
  */
-export const statusCommand = {
+export var statusCommand = {
     name: 'status',
     description: 'Check connection and schema status',
     options: [
@@ -40,57 +87,57 @@ export const 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: [
@@ -98,359 +145,367 @@ export const statusCommand = {
         { command: 'claude-flow ruvector status --verbose', description: 'Show detailed info' },
         { command: 'claude-flow ruvector status --json', description: 'Output as JSON' },
     ],
-    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);
-                }
-                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'),
-                        })),
+    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
                     });
-                    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),
-                        })),
+                    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();
+                    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))
                     });
-                }
-                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');
-                }
+                    _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*/];
             }
-            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