kynjal-cli 4.0.0 → 4.0.2

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

@@ -2,51 +2,6 @@
  * 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';
 /**
@@ -60,13 +15,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 var optimizeCommand = {
+export const optimizeCommand = {
     name: 'optimize',
     description: 'Optimization analysis and recommendations',
     options: [
@@ -75,74 +30,74 @@ export var 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: [
@@ -151,203 +106,204 @@ export var optimizeCommand = {
         { command: 'claude-flow ruvector optimize --vacuum', description: 'Run VACUUM ANALYZE' },
         { command: 'claude-flow ruvector optimize --reindex', description: 'Rebuild all indexes' },
     ],
-    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
-                    });
-                    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();
+    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');
-                    _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('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'
-                                });
-                            }
-                        }
+                }
+            }
+            // 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',
+                    });
+                }
+                // 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',
+                        });
                     }
-                    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);
+                }
+            }
+            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);
                     // 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
@@ -355,205 +311,193 @@ export var 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',
                         });
                     }
-                    _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 (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));
                     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'
-                        });
-                    }
-                    _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'
+                            sql: `-- Rebuild with: CREATE INDEX ... WITH (lists = ${recommendedLists})`,
+                            impact: 'Balances query speed and recall',
                         });
                     }
-                    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();
-                    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: [] } }];
+                }
+            }
+            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)}`);
                     }
-                    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
+                }
+            };
+            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,
                     });
-                    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
+                    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));
                                 }
                             }
-                        }];
-                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*/];
+                        }
+                        await applyClient.end();
+                        output.writeln();
+                        output.printSuccess('Optimizations applied');
+                    }
+                }
             }
-        });
-    }); }
+            // 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