kynjal-cli 3.1.3 → 4.0.0

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

@@ -2,6 +2,51 @@
  * V3 CLI RuVector Optimize Command
  * Optimization analysis and recommendations
  */
+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 };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { output } from '../../output.js';
 import { confirm } from '../../prompt.js';
 /**
@@ -15,13 +60,13 @@ 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'
     };
 }
 /**
  * RuVector optimize command
  */
-export const optimizeCommand = {
+export var optimizeCommand = {
     name: 'optimize',
     description: 'Optimization analysis and recommendations',
     options: [
@@ -30,74 +75,74 @@ export const optimizeCommand = {
             short: 'a',
             description: 'Analyze current performance',
             type: 'boolean',
-            default: true,
+            "default": true
         },
         {
             name: 'apply',
             description: 'Apply suggested optimizations',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'index',
             short: 'i',
             description: 'Optimize specific index',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'vacuum',
             description: 'Run VACUUM ANALYZE',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'reindex',
             description: 'Rebuild indexes',
             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',
             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: [
@@ -106,204 +151,203 @@ export const optimizeCommand = {
         { command: 'claude-flow ruvector optimize --vacuum', description: 'Run VACUUM ANALYZE' },
         { command: 'claude-flow ruvector optimize --reindex', description: 'Rebuild all indexes' },
     ],
-    action: async (ctx) => {
-        const config = getConnectionConfig(ctx);
-        const applyOptimizations = ctx.flags.apply;
-        const runVacuum = ctx.flags.vacuum;
-        const runReindex = ctx.flags.reindex;
-        const specificIndex = ctx.flags.index;
-        output.writeln();
-        output.writeln(output.bold('RuVector Optimization Analysis'));
-        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 };
-        }
-        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-        spinner.start();
-        const recommendations = [];
-        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 schema exists
-            const schemaResult = await client.query(`
-        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1
-      `, [config.schema]);
-            if (schemaResult.rows.length === 0) {
-                output.printError(`Schema "${config.schema}" not found`);
-                await client.end();
-                return { success: false, exitCode: 1 };
-            }
-            // Run VACUUM if requested
-            if (runVacuum) {
-                spinner.setText('Running VACUUM ANALYZE...');
-                spinner.start();
-                const tables = await client.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-        `, [config.schema]);
-                for (const row of tables.rows) {
-                    await client.query(`VACUUM ANALYZE ${config.schema}.${row.table_name}`);
-                }
-                spinner.succeed('VACUUM ANALYZE completed');
-            }
-            // Rebuild indexes if requested
-            if (runReindex) {
-                spinner.setText('Rebuilding indexes...');
-                spinner.start();
-                if (specificIndex) {
-                    await client.query(`REINDEX INDEX ${config.schema}.${specificIndex}`);
-                    spinner.succeed(`Index ${specificIndex} rebuilt`);
-                }
-                else {
-                    await client.query(`REINDEX SCHEMA ${config.schema}`);
-                    spinner.succeed('All indexes rebuilt');
-                }
-            }
-            // Analyze table statistics
-            spinner.setText('Analyzing table statistics...');
-            spinner.start();
-            const tableStatsResult = await client.query(`
-        SELECT
-          relname as table_name,
-          n_live_tup as live_rows,
-          n_dead_tup as dead_rows,
-          last_vacuum,
-          last_autovacuum,
-          last_analyze,
-          last_autoanalyze
-        FROM pg_stat_user_tables
-        WHERE schemaname = $1
-      `, [config.schema]);
-            for (const row of tableStatsResult.rows) {
-                const deadRatio = row.live_rows > 0 ? row.dead_rows / row.live_rows : 0;
-                // Check for high dead tuple ratio
-                if (deadRatio > 0.1) {
-                    recommendations.push({
-                        category: 'Table Bloat',
-                        priority: deadRatio > 0.3 ? 'critical' : 'high',
-                        issue: `Table "${row.table_name}" has ${(deadRatio * 100).toFixed(1)}% dead tuples`,
-                        recommendation: 'Run VACUUM to reclaim space',
-                        sql: `VACUUM ANALYZE ${config.schema}.${row.table_name}`,
-                        impact: 'Reduces storage and improves query performance',
-                    });
-                }
-                // Check for missing statistics
-                if (!row.last_analyze && !row.last_autoanalyze) {
-                    recommendations.push({
-                        category: 'Statistics',
-                        priority: 'medium',
-                        issue: `Table "${row.table_name}" has never been analyzed`,
-                        recommendation: 'Run ANALYZE to collect statistics',
-                        sql: `ANALYZE ${config.schema}.${row.table_name}`,
-                        impact: 'Improves query planner decisions',
-                    });
-                }
-            }
-            spinner.succeed('Table statistics analyzed');
-            // Analyze indexes
-            spinner.setText('Analyzing index health...');
-            spinner.start();
-            const indexStatsResult = 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.indisready as is_ready,
-          idx.indislive as is_live,
-          pg_stat_user_indexes.idx_scan as scans,
-          pg_stat_user_indexes.idx_tup_read as tuples_read,
-          pg_stat_user_indexes.idx_tup_fetch as tuples_fetched
-        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
-        LEFT JOIN pg_stat_user_indexes ON pg_stat_user_indexes.indexrelid = i.oid
-        WHERE n.nspname = $1
-      `, [config.schema]);
-            for (const row of indexStatsResult.rows) {
-                // Check for invalid indexes
-                if (!row.is_valid) {
-                    recommendations.push({
-                        category: 'Index Health',
-                        priority: 'critical',
-                        issue: `Index "${row.index_name}" is invalid`,
-                        recommendation: 'Rebuild the index',
-                        sql: `REINDEX INDEX ${config.schema}.${row.index_name}`,
-                        impact: 'Index is not being used for queries',
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var config, applyOptimizations, runVacuum, runReindex, specificIndex, spinner, recommendations, pg, _a, client, schemaResult, tables, _i, _b, row, tableStatsResult, _c, _d, row, deadRatio, indexStatsResult, _e, _f, row, sizeKB, vectorIndexes, _g, vectorIndexes_1, idx, optionsResult, options, m, efConstruction, mValue, efValue, countResult, rowCount, lists, listsValue, countResult, rowCount, recommendedLists, settingsResult, settings, _h, _j, row, workMemMB, maintMemMB, critical, high, medium, low, displayRecommendations, confirmApply, applyClient, _k, _l, rec, error_1, error_2;
+        var _m;
+        return __generator(this, function (_o) {
+            switch (_o.label) {
+                case 0:
+                    config = getConnectionConfig(ctx);
+                    applyOptimizations = ctx.flags.apply;
+                    runVacuum = ctx.flags.vacuum;
+                    runReindex = ctx.flags.reindex;
+                    specificIndex = ctx.flags.index;
+                    output.writeln();
+                    output.writeln(output.bold('RuVector Optimization Analysis'));
+                    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 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
+                    spinner.start();
+                    recommendations = [];
+                    _o.label = 1;
+                case 1:
+                    _o.trys.push([1, 41, , 42]);
+                    pg = null;
+                    _o.label = 2;
+                case 2:
+                    _o.trys.push([2, 4, , 5]);
+                    return [4 /*yield*/, import('pg')];
+                case 3:
+                    pg = _o.sent();
+                    return [3 /*break*/, 5];
+                case 4:
+                    _a = _o.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
                     });
-                }
-                // Check for unused indexes (skip vector indexes as they may be new)
-                if (row.scans === 0 && row.index_type !== 'hnsw' && row.index_type !== 'ivfflat') {
-                    const sizeKB = parseInt(row.index_size, 10) / 1024;
-                    if (sizeKB > 100) {
-                        recommendations.push({
-                            category: 'Unused Index',
-                            priority: 'low',
-                            issue: `Index "${row.index_name}" has never been used (${(sizeKB / 1024).toFixed(2)} MB)`,
-                            recommendation: 'Consider dropping if not needed',
-                            sql: `-- DROP INDEX IF EXISTS ${config.schema}.${row.index_name}`,
-                            impact: 'Reduces storage and write overhead',
-                        });
+                    return [4 /*yield*/, client.connect()];
+                case 6:
+                    _o.sent();
+                    spinner.succeed('Connected to PostgreSQL');
+                    return [4 /*yield*/, client.query("\n        SELECT schema_name FROM information_schema.schemata WHERE schema_name = $1\n      ", [config.schema])];
+                case 7:
+                    schemaResult = _o.sent();
+                    if (!(schemaResult.rows.length === 0)) return [3 /*break*/, 9];
+                    output.printError("Schema \"" + config.schema + "\" not found");
+                    return [4 /*yield*/, client.end()];
+                case 8:
+                    _o.sent();
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 9:
+                    if (!runVacuum) return [3 /*break*/, 15];
+                    spinner.setText('Running VACUUM ANALYZE...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n          SELECT table_name FROM information_schema.tables\n          WHERE table_schema = $1 AND table_type = 'BASE TABLE'\n        ", [config.schema])];
+                case 10:
+                    tables = _o.sent();
+                    _i = 0, _b = tables.rows;
+                    _o.label = 11;
+                case 11:
+                    if (!(_i < _b.length)) return [3 /*break*/, 14];
+                    row = _b[_i];
+                    return [4 /*yield*/, client.query("VACUUM ANALYZE " + config.schema + "." + row.table_name)];
+                case 12:
+                    _o.sent();
+                    _o.label = 13;
+                case 13:
+                    _i++;
+                    return [3 /*break*/, 11];
+                case 14:
+                    spinner.succeed('VACUUM ANALYZE completed');
+                    _o.label = 15;
+                case 15:
+                    if (!runReindex) return [3 /*break*/, 19];
+                    spinner.setText('Rebuilding indexes...');
+                    spinner.start();
+                    if (!specificIndex) return [3 /*break*/, 17];
+                    return [4 /*yield*/, client.query("REINDEX INDEX " + config.schema + "." + specificIndex)];
+                case 16:
+                    _o.sent();
+                    spinner.succeed("Index " + specificIndex + " rebuilt");
+                    return [3 /*break*/, 19];
+                case 17: return [4 /*yield*/, client.query("REINDEX SCHEMA " + config.schema)];
+                case 18:
+                    _o.sent();
+                    spinner.succeed('All indexes rebuilt');
+                    _o.label = 19;
+                case 19:
+                    // Analyze table statistics
+                    spinner.setText('Analyzing table statistics...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n        SELECT\n          relname as table_name,\n          n_live_tup as live_rows,\n          n_dead_tup as dead_rows,\n          last_vacuum,\n          last_autovacuum,\n          last_analyze,\n          last_autoanalyze\n        FROM pg_stat_user_tables\n        WHERE schemaname = $1\n      ", [config.schema])];
+                case 20:
+                    tableStatsResult = _o.sent();
+                    for (_c = 0, _d = tableStatsResult.rows; _c < _d.length; _c++) {
+                        row = _d[_c];
+                        deadRatio = row.live_rows > 0 ? row.dead_rows / row.live_rows : 0;
+                        // Check for high dead tuple ratio
+                        if (deadRatio > 0.1) {
+                            recommendations.push({
+                                category: 'Table Bloat',
+                                priority: deadRatio > 0.3 ? 'critical' : 'high',
+                                issue: "Table \"" + row.table_name + "\" has " + (deadRatio * 100).toFixed(1) + "% dead tuples",
+                                recommendation: 'Run VACUUM to reclaim space',
+                                sql: "VACUUM ANALYZE " + config.schema + "." + row.table_name,
+                                impact: 'Reduces storage and improves query performance'
+                            });
+                        }
+                        // Check for missing statistics
+                        if (!row.last_analyze && !row.last_autoanalyze) {
+                            recommendations.push({
+                                category: 'Statistics',
+                                priority: 'medium',
+                                issue: "Table \"" + row.table_name + "\" has never been analyzed",
+                                recommendation: 'Run ANALYZE to collect statistics',
+                                sql: "ANALYZE " + config.schema + "." + row.table_name,
+                                impact: 'Improves query planner decisions'
+                            });
+                        }
                     }
-                }
-            }
-            spinner.succeed('Index health analyzed');
-            // Analyze vector index parameters
-            spinner.setText('Analyzing vector index configuration...');
-            spinner.start();
-            const vectorIndexes = indexStatsResult.rows.filter(r => r.index_type === 'hnsw' || r.index_type === 'ivfflat');
-            for (const idx of vectorIndexes) {
-                // Get index options
-                const optionsResult = await client.query(`
-          SELECT reloptions FROM pg_class
-          WHERE relname = $1 AND relnamespace = (
-            SELECT oid FROM pg_namespace WHERE nspname = $2
-          )
-        `, [idx.index_name, config.schema]);
-                const options = optionsResult.rows[0]?.reloptions || [];
-                if (idx.index_type === 'hnsw') {
-                    // Check HNSW parameters
-                    const m = options.find((o) => o.startsWith('m='));
-                    const efConstruction = options.find((o) => o.startsWith('ef_construction='));
-                    const mValue = m ? parseInt(m.split('=')[1], 10) : 16;
-                    const efValue = efConstruction ? parseInt(efConstruction.split('=')[1], 10) : 64;
-                    // Get table row count
-                    const countResult = await client.query(`
-            SELECT count(*) as cnt FROM ${config.schema}.${idx.table_name}
-          `);
-                    const rowCount = parseInt(countResult.rows[0].cnt, 10);
+                    spinner.succeed('Table statistics analyzed');
+                    // Analyze indexes
+                    spinner.setText('Analyzing index health...');
+                    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.indisready as is_ready,\n          idx.indislive as is_live,\n          pg_stat_user_indexes.idx_scan as scans,\n          pg_stat_user_indexes.idx_tup_read as tuples_read,\n          pg_stat_user_indexes.idx_tup_fetch as tuples_fetched\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        LEFT JOIN pg_stat_user_indexes ON pg_stat_user_indexes.indexrelid = i.oid\n        WHERE n.nspname = $1\n      ", [config.schema])];
+                case 21:
+                    indexStatsResult = _o.sent();
+                    for (_e = 0, _f = indexStatsResult.rows; _e < _f.length; _e++) {
+                        row = _f[_e];
+                        // Check for invalid indexes
+                        if (!row.is_valid) {
+                            recommendations.push({
+                                category: 'Index Health',
+                                priority: 'critical',
+                                issue: "Index \"" + row.index_name + "\" is invalid",
+                                recommendation: 'Rebuild the index',
+                                sql: "REINDEX INDEX " + config.schema + "." + row.index_name,
+                                impact: 'Index is not being used for queries'
+                            });
+                        }
+                        // Check for unused indexes (skip vector indexes as they may be new)
+                        if (row.scans === 0 && row.index_type !== 'hnsw' && row.index_type !== 'ivfflat') {
+                            sizeKB = parseInt(row.index_size, 10) / 1024;
+                            if (sizeKB > 100) {
+                                recommendations.push({
+                                    category: 'Unused Index',
+                                    priority: 'low',
+                                    issue: "Index \"" + row.index_name + "\" has never been used (" + (sizeKB / 1024).toFixed(2) + " MB)",
+                                    recommendation: 'Consider dropping if not needed',
+                                    sql: "-- DROP INDEX IF EXISTS " + config.schema + "." + row.index_name,
+                                    impact: 'Reduces storage and write overhead'
+                                });
+                            }
+                        }
+                    }
+                    spinner.succeed('Index health analyzed');
+                    // Analyze vector index parameters
+                    spinner.setText('Analyzing vector index configuration...');
+                    spinner.start();
+                    vectorIndexes = indexStatsResult.rows.filter(function (r) { return r.index_type === 'hnsw' || r.index_type === 'ivfflat'; });
+                    _g = 0, vectorIndexes_1 = vectorIndexes;
+                    _o.label = 22;
+                case 22:
+                    if (!(_g < vectorIndexes_1.length)) return [3 /*break*/, 28];
+                    idx = vectorIndexes_1[_g];
+                    return [4 /*yield*/, client.query("\n          SELECT reloptions FROM pg_class\n          WHERE relname = $1 AND relnamespace = (\n            SELECT oid FROM pg_namespace WHERE nspname = $2\n          )\n        ", [idx.index_name, config.schema])];
+                case 23:
+                    optionsResult = _o.sent();
+                    options = ((_m = optionsResult.rows[0]) === null || _m === void 0 ? void 0 : _m.reloptions) || [];
+                    if (!(idx.index_type === 'hnsw')) return [3 /*break*/, 25];
+                    m = options.find(function (o) { return o.startsWith('m='); });
+                    efConstruction = options.find(function (o) { return o.startsWith('ef_construction='); });
+                    mValue = m ? parseInt(m.split('=')[1], 10) : 16;
+                    efValue = efConstruction ? parseInt(efConstruction.split('=')[1], 10) : 64;
+                    return [4 /*yield*/, client.query("\n            SELECT count(*) as cnt FROM " + config.schema + "." + idx.table_name + "\n          ")];
+                case 24:
+                    countResult = _o.sent();
+                    rowCount = parseInt(countResult.rows[0].cnt, 10);
                     // Recommend higher ef_construction for large datasets
                     if (rowCount > 100000 && efValue < 100) {
                         recommendations.push({
                             category: 'HNSW Tuning',
                             priority: 'medium',
-                            issue: `HNSW index "${idx.index_name}" has ef_construction=${efValue} for ${rowCount.toLocaleString()} vectors`,
+                            issue: "HNSW index \"" + idx.index_name + "\" has ef_construction=" + efValue + " for " + rowCount.toLocaleString() + " vectors",
                             recommendation: 'Consider rebuilding with higher ef_construction for better recall',
-                            sql: `-- Rebuild with: CREATE INDEX ... WITH (m = ${mValue}, ef_construction = 128)`,
-                            impact: 'Improves recall at slight build time cost',
+                            sql: "-- Rebuild with: CREATE INDEX ... WITH (m = " + mValue + ", ef_construction = 128)",
+                            impact: 'Improves recall at slight build time cost'
                         });
                     }
                     // Recommend higher m for very large datasets
@@ -311,193 +355,205 @@ export const optimizeCommand = {
                         recommendations.push({
                             category: 'HNSW Tuning',
                             priority: 'medium',
-                            issue: `HNSW index "${idx.index_name}" has m=${mValue} for ${rowCount.toLocaleString()} vectors`,
+                            issue: "HNSW index \"" + idx.index_name + "\" has m=" + mValue + " for " + rowCount.toLocaleString() + " vectors",
                             recommendation: 'Consider rebuilding with higher m for better connectivity',
-                            sql: `-- Rebuild with: CREATE INDEX ... WITH (m = 24, ef_construction = ${efValue})`,
-                            impact: 'Improves recall and query performance',
+                            sql: "-- Rebuild with: CREATE INDEX ... WITH (m = 24, ef_construction = " + efValue + ")",
+                            impact: 'Improves recall and query performance'
                         });
                     }
-                }
-                if (idx.index_type === 'ivfflat') {
-                    // Check IVFFlat lists parameter
-                    const lists = options.find((o) => o.startsWith('lists='));
-                    const listsValue = lists ? parseInt(lists.split('=')[1], 10) : 100;
-                    // Get table row count
-                    const countResult = await client.query(`
-            SELECT count(*) as cnt FROM ${config.schema}.${idx.table_name}
-          `);
-                    const rowCount = parseInt(countResult.rows[0].cnt, 10);
-                    // Recommended lists = sqrt(n)
-                    const recommendedLists = Math.floor(Math.sqrt(rowCount));
+                    _o.label = 25;
+                case 25:
+                    if (!(idx.index_type === 'ivfflat')) return [3 /*break*/, 27];
+                    lists = options.find(function (o) { return o.startsWith('lists='); });
+                    listsValue = lists ? parseInt(lists.split('=')[1], 10) : 100;
+                    return [4 /*yield*/, client.query("\n            SELECT count(*) as cnt FROM " + config.schema + "." + idx.table_name + "\n          ")];
+                case 26:
+                    countResult = _o.sent();
+                    rowCount = parseInt(countResult.rows[0].cnt, 10);
+                    recommendedLists = Math.floor(Math.sqrt(rowCount));
                     if (Math.abs(listsValue - recommendedLists) / recommendedLists > 0.5) {
                         recommendations.push({
                             category: 'IVFFlat Tuning',
                             priority: 'medium',
-                            issue: `IVFFlat index "${idx.index_name}" has lists=${listsValue} (recommended: ~${recommendedLists})`,
+                            issue: "IVFFlat index \"" + idx.index_name + "\" has lists=" + listsValue + " (recommended: ~" + recommendedLists + ")",
                             recommendation: 'Consider rebuilding with optimal lists parameter',
-                            sql: `-- Rebuild with: CREATE INDEX ... WITH (lists = ${recommendedLists})`,
-                            impact: 'Balances query speed and recall',
+                            sql: "-- Rebuild with: CREATE INDEX ... WITH (lists = " + recommendedLists + ")",
+                            impact: 'Balances query speed and recall'
                         });
                     }
-                }
-            }
-            spinner.succeed('Vector index configuration analyzed');
-            // Check memory settings
-            spinner.setText('Checking PostgreSQL settings...');
-            spinner.start();
-            const settingsResult = await client.query(`
-        SELECT name, setting, unit, context
-        FROM pg_settings
-        WHERE name IN (
-          'shared_buffers', 'effective_cache_size', 'work_mem',
-          'maintenance_work_mem', 'max_parallel_workers_per_gather'
-        )
-      `);
-            const settings = {};
-            for (const row of settingsResult.rows) {
-                settings[row.name] = row.setting + (row.unit || '');
-            }
-            // Check work_mem for vector operations
-            const workMemMB = parseInt(settings.work_mem || '4096', 10) / 1024;
-            if (workMemMB < 64) {
-                recommendations.push({
-                    category: 'Memory Settings',
-                    priority: 'medium',
-                    issue: `work_mem is ${workMemMB.toFixed(0)}MB (recommended: 64MB+ for vector ops)`,
-                    recommendation: 'Increase work_mem for better vector search performance',
-                    sql: `SET work_mem = '64MB'`,
-                    impact: 'Improves sorting and index build performance',
-                });
-            }
-            // Check maintenance_work_mem for index building
-            const maintMemMB = parseInt(settings.maintenance_work_mem || '65536', 10) / 1024;
-            if (maintMemMB < 256) {
-                recommendations.push({
-                    category: 'Memory Settings',
-                    priority: 'low',
-                    issue: `maintenance_work_mem is ${maintMemMB.toFixed(0)}MB`,
-                    recommendation: 'Increase for faster index builds',
-                    sql: `SET maintenance_work_mem = '256MB'`,
-                    impact: 'Faster VACUUM and index creation',
-                });
-            }
-            spinner.succeed('PostgreSQL settings checked');
-            await client.end();
-            // Display recommendations
-            output.writeln();
-            if (recommendations.length === 0) {
-                output.printSuccess('No optimization recommendations - your setup looks good!');
-                output.writeln();
-                output.printBox([
-                    'All tables have been analyzed',
-                    'Indexes are valid and properly configured',
-                    'Memory settings are adequate',
-                    '',
-                    'Tips for maintaining performance:',
-                    '  - Run VACUUM ANALYZE regularly',
-                    '  - Monitor dead tuple ratio',
-                    '  - Rebuild indexes after large batch inserts',
-                ].join('\n'), 'Status: Optimal');
-                return { success: true, data: { recommendations: [] } };
-            }
-            // Group by priority
-            const critical = recommendations.filter(r => r.priority === 'critical');
-            const high = recommendations.filter(r => r.priority === 'high');
-            const medium = recommendations.filter(r => r.priority === 'medium');
-            const low = recommendations.filter(r => r.priority === 'low');
-            output.writeln(output.bold(`Found ${recommendations.length} optimization recommendations:`));
-            output.writeln();
-            // Display by priority
-            const displayRecommendations = (recs, label, color) => {
-                if (recs.length === 0)
-                    return;
-                output.writeln(color(`${label} Priority (${recs.length}):`));
-                output.writeln();
-                for (const rec of recs) {
-                    output.writeln(`  ${output.bold(rec.category)}: ${rec.issue}`);
-                    output.writeln(`    ${output.dim('Recommendation:')} ${rec.recommendation}`);
-                    output.writeln(`    ${output.dim('Impact:')} ${rec.impact}`);
-                    if (rec.sql) {
-                        output.writeln(`    ${output.dim('SQL:')} ${output.highlight(rec.sql)}`);
+                    _o.label = 27;
+                case 27:
+                    _g++;
+                    return [3 /*break*/, 22];
+                case 28:
+                    spinner.succeed('Vector index configuration analyzed');
+                    // Check memory settings
+                    spinner.setText('Checking PostgreSQL settings...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n        SELECT name, setting, unit, context\n        FROM pg_settings\n        WHERE name IN (\n          'shared_buffers', 'effective_cache_size', 'work_mem',\n          'maintenance_work_mem', 'max_parallel_workers_per_gather'\n        )\n      ")];
+                case 29:
+                    settingsResult = _o.sent();
+                    settings = {};
+                    for (_h = 0, _j = settingsResult.rows; _h < _j.length; _h++) {
+                        row = _j[_h];
+                        settings[row.name] = row.setting + (row.unit || '');
+                    }
+                    workMemMB = parseInt(settings.work_mem || '4096', 10) / 1024;
+                    if (workMemMB < 64) {
+                        recommendations.push({
+                            category: 'Memory Settings',
+                            priority: 'medium',
+                            issue: "work_mem is " + workMemMB.toFixed(0) + "MB (recommended: 64MB+ for vector ops)",
+                            recommendation: 'Increase work_mem for better vector search performance',
+                            sql: "SET work_mem = '64MB'",
+                            impact: 'Improves sorting and index build performance'
+                        });
+                    }
+                    maintMemMB = parseInt(settings.maintenance_work_mem || '65536', 10) / 1024;
+                    if (maintMemMB < 256) {
+                        recommendations.push({
+                            category: 'Memory Settings',
+                            priority: 'low',
+                            issue: "maintenance_work_mem is " + maintMemMB.toFixed(0) + "MB",
+                            recommendation: 'Increase for faster index builds',
+                            sql: "SET maintenance_work_mem = '256MB'",
+                            impact: 'Faster VACUUM and index creation'
+                        });
                     }
+                    spinner.succeed('PostgreSQL settings checked');
+                    return [4 /*yield*/, client.end()];
+                case 30:
+                    _o.sent();
+                    // Display recommendations
                     output.writeln();
-                }
-            };
-            displayRecommendations(critical, 'CRITICAL', output.error.bind(output));
-            displayRecommendations(high, 'HIGH', output.warning.bind(output));
-            displayRecommendations(medium, 'MEDIUM', output.highlight.bind(output));
-            displayRecommendations(low, 'LOW', output.dim.bind(output));
-            // Apply optimizations if requested
-            if (applyOptimizations && (critical.length > 0 || high.length > 0)) {
-                output.writeln(output.dim('-'.repeat(60)));
-                output.writeln();
-                if (ctx.interactive) {
-                    const confirmApply = await confirm({
-                        message: `Apply ${critical.length + high.length} critical/high priority optimizations?`,
-                        default: false,
+                    if (recommendations.length === 0) {
+                        output.printSuccess('No optimization recommendations - your setup looks good!');
+                        output.writeln();
+                        output.printBox([
+                            'All tables have been analyzed',
+                            'Indexes are valid and properly configured',
+                            'Memory settings are adequate',
+                            '',
+                            'Tips for maintaining performance:',
+                            '  - Run VACUUM ANALYZE regularly',
+                            '  - Monitor dead tuple ratio',
+                            '  - Rebuild indexes after large batch inserts',
+                        ].join('\n'), 'Status: Optimal');
+                        return [2 /*return*/, { success: true, data: { recommendations: [] } }];
+                    }
+                    critical = recommendations.filter(function (r) { return r.priority === 'critical'; });
+                    high = recommendations.filter(function (r) { return r.priority === 'high'; });
+                    medium = recommendations.filter(function (r) { return r.priority === 'medium'; });
+                    low = recommendations.filter(function (r) { return r.priority === 'low'; });
+                    output.writeln(output.bold("Found " + recommendations.length + " optimization recommendations:"));
+                    output.writeln();
+                    displayRecommendations = function (recs, label, color) {
+                        if (recs.length === 0)
+                            return;
+                        output.writeln(color(label + " Priority (" + recs.length + "):"));
+                        output.writeln();
+                        for (var _i = 0, recs_1 = recs; _i < recs_1.length; _i++) {
+                            var rec = recs_1[_i];
+                            output.writeln("  " + output.bold(rec.category) + ": " + rec.issue);
+                            output.writeln("    " + output.dim('Recommendation:') + " " + rec.recommendation);
+                            output.writeln("    " + output.dim('Impact:') + " " + rec.impact);
+                            if (rec.sql) {
+                                output.writeln("    " + output.dim('SQL:') + " " + output.highlight(rec.sql));
+                            }
+                            output.writeln();
+                        }
+                    };
+                    displayRecommendations(critical, 'CRITICAL', output.error.bind(output));
+                    displayRecommendations(high, 'HIGH', output.warning.bind(output));
+                    displayRecommendations(medium, 'MEDIUM', output.highlight.bind(output));
+                    displayRecommendations(low, 'LOW', output.dim.bind(output));
+                    if (!(applyOptimizations && (critical.length > 0 || high.length > 0))) return [3 /*break*/, 40];
+                    output.writeln(output.dim('-'.repeat(60)));
+                    output.writeln();
+                    if (!ctx.interactive) return [3 /*break*/, 40];
+                    return [4 /*yield*/, confirm({
+                            message: "Apply " + (critical.length + high.length) + " critical/high priority optimizations?",
+                            "default": false
+                        })];
+                case 31:
+                    confirmApply = _o.sent();
+                    if (!confirmApply) return [3 /*break*/, 40];
+                    applyClient = new pg.Client({
+                        host: config.host,
+                        port: config.port,
+                        database: config.database,
+                        user: config.user,
+                        password: config.password,
+                        ssl: config.ssl ? { rejectUnauthorized: false } : false
                     });
-                    if (confirmApply) {
-                        const applyClient = 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 applyClient.connect();
-                        for (const rec of [...critical, ...high]) {
-                            if (rec.sql && !rec.sql.startsWith('--')) {
-                                spinner.setText(`Applying: ${rec.issue}...`);
-                                spinner.start();
-                                try {
-                                    await applyClient.query(rec.sql);
-                                    spinner.succeed(`Applied: ${rec.category}`);
-                                }
-                                catch (error) {
-                                    spinner.fail(`Failed: ${rec.category}`);
-                                    output.printError(error instanceof Error ? error.message : String(error));
+                    return [4 /*yield*/, applyClient.connect()];
+                case 32:
+                    _o.sent();
+                    _k = 0, _l = __spreadArray(__spreadArray([], critical, true), high, true);
+                    _o.label = 33;
+                case 33:
+                    if (!(_k < _l.length)) return [3 /*break*/, 38];
+                    rec = _l[_k];
+                    if (!(rec.sql && !rec.sql.startsWith('--'))) return [3 /*break*/, 37];
+                    spinner.setText("Applying: " + rec.issue + "...");
+                    spinner.start();
+                    _o.label = 34;
+                case 34:
+                    _o.trys.push([34, 36, , 37]);
+                    return [4 /*yield*/, applyClient.query(rec.sql)];
+                case 35:
+                    _o.sent();
+                    spinner.succeed("Applied: " + rec.category);
+                    return [3 /*break*/, 37];
+                case 36:
+                    error_1 = _o.sent();
+                    spinner.fail("Failed: " + rec.category);
+                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
+                    return [3 /*break*/, 37];
+                case 37:
+                    _k++;
+                    return [3 /*break*/, 33];
+                case 38: return [4 /*yield*/, applyClient.end()];
+                case 39:
+                    _o.sent();
+                    output.writeln();
+                    output.printSuccess('Optimizations applied');
+                    _o.label = 40;
+                case 40:
+                    // Summary
+                    output.printBox([
+                        "Total Recommendations: " + recommendations.length,
+                        "  Critical: " + critical.length,
+                        "  High: " + high.length,
+                        "  Medium: " + medium.length,
+                        "  Low: " + low.length,
+                        '',
+                        'Quick commands:',
+                        "  claude-flow ruvector optimize --vacuum    # Clean up tables",
+                        "  claude-flow ruvector optimize --reindex  # Rebuild indexes",
+                        "  claude-flow ruvector optimize --apply    # Apply critical fixes",
+                    ].join('\n'), 'Optimization Summary');
+                    return [2 /*return*/, {
+                            success: true,
+                            data: {
+                                recommendations: recommendations,
+                                summary: {
+                                    critical: critical.length,
+                                    high: high.length,
+                                    medium: medium.length,
+                                    low: low.length
                                 }
                             }
-                        }
-                        await applyClient.end();
-                        output.writeln();
-                        output.printSuccess('Optimizations applied');
-                    }
-                }
+                        }];
+                case 41:
+                    error_2 = _o.sent();
+                    spinner.fail('Optimization analysis failed');
+                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 42: return [2 /*return*/];
             }
-            // Summary
-            output.printBox([
-                `Total Recommendations: ${recommendations.length}`,
-                `  Critical: ${critical.length}`,
-                `  High: ${high.length}`,
-                `  Medium: ${medium.length}`,
-                `  Low: ${low.length}`,
-                '',
-                'Quick commands:',
-                `  claude-flow ruvector optimize --vacuum    # Clean up tables`,
-                `  claude-flow ruvector optimize --reindex  # Rebuild indexes`,
-                `  claude-flow ruvector optimize --apply    # Apply critical fixes`,
-            ].join('\n'), 'Optimization Summary');
-            return {
-                success: true,
-                data: {
-                    recommendations,
-                    summary: {
-                        critical: critical.length,
-                        high: high.length,
-                        medium: medium.length,
-                        low: low.length,
-                    },
-                },
-            };
-        }
-        catch (error) {
-            spinner.fail('Optimization analysis failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 export default optimizeCommand;
 //# sourceMappingURL=optimize.js.map