kynjal-cli 3.1.4 → 4.0.0

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

@@ -2,6 +2,42 @@
  * V3 CLI RuVector Benchmark Command
  * Performance benchmarking for RuVector PostgreSQL Bridge
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 import { output } from '../../output.js';
 import { confirm } from '../../prompt.js';
 /**
@@ -15,32 +51,32 @@ 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'
     };
 }
 /**
  * Generate random vector
  */
 function generateRandomVector(dimensions) {
-    const vector = [];
-    for (let i = 0; i < dimensions; i++) {
+    var vector = [];
+    for (var i = 0; i < dimensions; i++) {
         vector.push(Math.random() * 2 - 1);
     }
     // Normalize
-    const magnitude = Math.sqrt(vector.reduce((sum, v) => sum + v * v, 0));
-    return vector.map(v => v / magnitude);
+    var magnitude = Math.sqrt(vector.reduce(function (sum, v) { return sum + v * v; }, 0));
+    return vector.map(function (v) { return v / magnitude; });
 }
 /**
  * Calculate percentile from sorted array
  */
 function percentile(sortedArr, p) {
-    const index = Math.ceil((p / 100) * sortedArr.length) - 1;
+    var index = Math.ceil((p / 100) * sortedArr.length) - 1;
     return sortedArr[Math.max(0, index)];
 }
 /**
  * RuVector benchmark command
  */
-export const benchmarkCommand = {
+export var benchmarkCommand = {
     name: 'benchmark',
     description: 'Performance benchmarking',
     options: [
@@ -49,98 +85,98 @@ export const benchmarkCommand = {
             short: 'n',
             description: 'Number of test vectors',
             type: 'number',
-            default: 10000,
+            "default": 10000
         },
         {
             name: 'dimensions',
             short: 'd',
             description: 'Vector dimensions',
             type: 'number',
-            default: 1536,
+            "default": 1536
         },
         {
             name: 'queries',
             short: 'q',
             description: 'Number of test queries',
             type: 'number',
-            default: 100,
+            "default": 100
         },
         {
             name: 'k',
             description: 'Top-k results to retrieve',
             type: 'number',
-            default: 10,
+            "default": 10
         },
         {
             name: 'metric',
             short: 'm',
             description: 'Distance metric',
             type: 'string',
-            default: 'cosine',
-            choices: ['cosine', 'l2', 'inner'],
+            "default": 'cosine',
+            choices: ['cosine', 'l2', 'inner']
         },
         {
             name: 'index',
             short: 'i',
             description: 'Index type to test',
             type: 'string',
-            default: 'hnsw',
-            choices: ['hnsw', 'ivfflat', 'none'],
+            "default": 'hnsw',
+            choices: ['hnsw', 'ivfflat', 'none']
         },
         {
             name: 'batch-size',
             description: 'Batch size for inserts',
             type: 'number',
-            default: 1000,
+            "default": 1000
         },
         {
             name: 'cleanup',
             description: 'Clean up test data after benchmark',
             type: 'boolean',
-            default: true,
+            "default": true
         },
         {
             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: [
@@ -149,332 +185,348 @@ export const benchmarkCommand = {
         { command: 'claude-flow ruvector benchmark --index ivfflat', description: 'Test IVFFlat index' },
         { command: 'claude-flow ruvector benchmark --dimensions 768 --metric l2', description: 'Custom dimensions and metric' },
     ],
-    action: async (ctx) => {
-        const config = getConnectionConfig(ctx);
-        const numVectors = parseInt(ctx.flags.vectors || '10000', 10);
-        const dimensions = parseInt(ctx.flags.dimensions || '1536', 10);
-        const numQueries = parseInt(ctx.flags.queries || '100', 10);
-        const topK = parseInt(ctx.flags.k || '10', 10);
-        const metric = ctx.flags.metric || 'cosine';
-        const indexType = ctx.flags.index || 'hnsw';
-        const batchSize = parseInt(ctx.flags['batch-size'] || '1000', 10);
-        const cleanup = ctx.flags.cleanup !== false;
-        output.writeln();
-        output.writeln(output.bold('RuVector Performance Benchmark'));
-        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 };
-        }
-        // Show benchmark configuration
-        output.writeln(output.highlight('Benchmark Configuration:'));
-        output.printTable({
-            columns: [
-                { key: 'setting', header: 'Setting', width: 20 },
-                { key: 'value', header: 'Value', width: 20 },
-            ],
-            data: [
-                { setting: 'Vectors', value: numVectors.toLocaleString() },
-                { setting: 'Dimensions', value: dimensions.toLocaleString() },
-                { setting: 'Queries', value: numQueries.toLocaleString() },
-                { setting: 'Top-K', value: topK.toLocaleString() },
-                { setting: 'Metric', value: metric },
-                { setting: 'Index Type', value: indexType.toUpperCase() },
-                { setting: 'Batch Size', value: batchSize.toLocaleString() },
-            ],
-        });
-        output.writeln();
-        // Confirm large benchmarks
-        if (numVectors >= 50000 && ctx.interactive) {
-            const confirmRun = await confirm({
-                message: `This will insert ${numVectors.toLocaleString()} vectors. Continue?`,
-                default: true,
-            });
-            if (!confirmRun) {
-                output.printInfo('Benchmark cancelled');
-                return { success: false, exitCode: 0 };
-            }
-        }
-        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-        spinner.start();
-        const results = {
-            config: { numVectors, dimensions, numQueries, topK, metric, indexType },
-            insert: {},
-            query: {},
-            memory: {},
-        };
-        try {
-            // Import pg
-            let pg = null;
-            try {
-                pg = await import('pg');
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var config, numVectors, dimensions, numQueries, topK, metric, indexType, batchSize, cleanup, confirmRun, spinner, results, pg, _a, client, benchmarkTable, insertStart, insertedCount, batch, batchStart, batchEnd, batchVectors, i, vector, insertDuration, insertThroughput, indexStart, metricOp, lists, indexDuration, queryLatencies, distanceOp, q, queryVector, queryStart, avgLatency, p50, p95, p99, minLatency, maxLatency, qps, sizeResult, tableSize, totalSize, indexSize, bytesPerVector, estimatedRecall, formatBytes, grade, gradeColor, error_1;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    config = getConnectionConfig(ctx);
+                    numVectors = parseInt(ctx.flags.vectors || '10000', 10);
+                    dimensions = parseInt(ctx.flags.dimensions || '1536', 10);
+                    numQueries = parseInt(ctx.flags.queries || '100', 10);
+                    topK = parseInt(ctx.flags.k || '10', 10);
+                    metric = ctx.flags.metric || 'cosine';
+                    indexType = ctx.flags.index || 'hnsw';
+                    batchSize = parseInt(ctx.flags['batch-size'] || '1000', 10);
+                    cleanup = ctx.flags.cleanup !== false;
+                    output.writeln();
+                    output.writeln(output.bold('RuVector Performance Benchmark'));
+                    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 }];
+                    }
+                    // Show benchmark configuration
+                    output.writeln(output.highlight('Benchmark Configuration:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'setting', header: 'Setting', width: 20 },
+                            { key: 'value', header: 'Value', width: 20 },
+                        ],
+                        data: [
+                            { setting: 'Vectors', value: numVectors.toLocaleString() },
+                            { setting: 'Dimensions', value: dimensions.toLocaleString() },
+                            { setting: 'Queries', value: numQueries.toLocaleString() },
+                            { setting: 'Top-K', value: topK.toLocaleString() },
+                            { setting: 'Metric', value: metric },
+                            { setting: 'Index Type', value: indexType.toUpperCase() },
+                            { setting: 'Batch Size', value: batchSize.toLocaleString() },
+                        ]
+                    });
+                    output.writeln();
+                    if (!(numVectors >= 50000 && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, confirm({
+                            message: "This will insert " + numVectors.toLocaleString() + " vectors. Continue?",
+                            "default": true
+                        })];
+                case 1:
+                    confirmRun = _b.sent();
+                    if (!confirmRun) {
+                        output.printInfo('Benchmark cancelled');
+                        return [2 /*return*/, { success: false, exitCode: 0 }];
+                    }
+                    _b.label = 2;
+                case 2:
+                    spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
+                    spinner.start();
+                    results = {
+                        config: { numVectors: numVectors, dimensions: dimensions, numQueries: numQueries, topK: topK, metric: metric, indexType: indexType },
+                        insert: {},
+                        query: {},
+                        memory: {}
+                    };
+                    _b.label = 3;
+                case 3:
+                    _b.trys.push([3, 31, , 32]);
+                    pg = null;
+                    _b.label = 4;
+                case 4:
+                    _b.trys.push([4, 6, , 7]);
+                    return [4 /*yield*/, import('pg')];
+                case 5:
+                    pg = _b.sent();
+                    return [3 /*break*/, 7];
+                case 6:
+                    _a = _b.sent();
+                    spinner.fail('PostgreSQL driver not found');
+                    output.printError('Install pg package: npm install pg');
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 7:
+                    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 8:
+                    _b.sent();
+                    spinner.succeed('Connected to PostgreSQL');
+                    benchmarkTable = config.schema + ".benchmark_" + Date.now();
+                    spinner.setText('Creating benchmark table...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n        CREATE TABLE " + benchmarkTable + " (\n          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n          embedding vector(" + dimensions + "),\n          created_at TIMESTAMPTZ DEFAULT NOW()\n        )\n      ")];
+                case 9:
+                    _b.sent();
+                    spinner.succeed('Benchmark table created');
+                    // Insert vectors
+                    spinner.setText("Inserting " + numVectors.toLocaleString() + " vectors...");
+                    spinner.start();
+                    insertStart = Date.now();
+                    insertedCount = 0;
+                    batch = 0;
+                    _b.label = 10;
+                case 10:
+                    if (!(batch < Math.ceil(numVectors / batchSize))) return [3 /*break*/, 13];
+                    batchStart = batch * batchSize;
+                    batchEnd = Math.min(batchStart + batchSize, numVectors);
+                    batchVectors = [];
+                    for (i = batchStart; i < batchEnd; i++) {
+                        vector = generateRandomVector(dimensions);
+                        batchVectors.push("('[" + vector.join(',') + "]')");
+                    }
+                    return [4 /*yield*/, client.query("\n          INSERT INTO " + benchmarkTable + " (embedding)\n          VALUES " + batchVectors.join(',') + "\n        ")];
+                case 11:
+                    _b.sent();
+                    insertedCount = batchEnd;
+                    spinner.setText("Inserting vectors... " + insertedCount.toLocaleString() + "/" + numVectors.toLocaleString());
+                    _b.label = 12;
+                case 12:
+                    batch++;
+                    return [3 /*break*/, 10];
+                case 13:
+                    insertDuration = Date.now() - insertStart;
+                    insertThroughput = Math.round(numVectors / (insertDuration / 1000));
+                    results.insert = {
+                        totalTime: insertDuration,
+                        throughput: insertThroughput,
+                        vectorsInserted: numVectors
+                    };
+                    spinner.succeed("Inserted " + numVectors.toLocaleString() + " vectors in " + (insertDuration / 1000).toFixed(2) + "s (" + insertThroughput.toLocaleString() + " vectors/sec)");
+                    if (!(indexType !== 'none')) return [3 /*break*/, 21];
+                    spinner.setText("Creating " + indexType.toUpperCase() + " index...");
+                    spinner.start();
+                    indexStart = Date.now();
+                    metricOp = metric === 'cosine' ? 'vector_cosine_ops' :
+                        metric === 'l2' ? 'vector_l2_ops' : 'vector_ip_ops';
+                    if (!(indexType === 'hnsw')) return [3 /*break*/, 15];
+                    return [4 /*yield*/, client.query("\n            CREATE INDEX idx_benchmark_hnsw\n            ON " + benchmarkTable + "\n            USING hnsw (embedding " + metricOp + ")\n            WITH (m = 16, ef_construction = 64)\n          ")];
+                case 14:
+                    _b.sent();
+                    return [3 /*break*/, 17];
+                case 15:
+                    if (!(indexType === 'ivfflat')) return [3 /*break*/, 17];
+                    lists = Math.max(100, Math.floor(numVectors / 1000));
+                    return [4 /*yield*/, client.query("\n            CREATE INDEX idx_benchmark_ivfflat\n            ON " + benchmarkTable + "\n            USING ivfflat (embedding " + metricOp + ")\n            WITH (lists = " + lists + ")\n          ")];
+                case 16:
+                    _b.sent();
+                    _b.label = 17;
+                case 17:
+                    indexDuration = Date.now() - indexStart;
+                    results.insert.indexTime = indexDuration;
+                    spinner.succeed(indexType.toUpperCase() + " index created in " + (indexDuration / 1000).toFixed(2) + "s");
+                    if (!(indexType === 'hnsw')) return [3 /*break*/, 19];
+                    return [4 /*yield*/, client.query("SET hnsw.ef_search = 100")];
+                case 18:
+                    _b.sent();
+                    return [3 /*break*/, 21];
+                case 19:
+                    if (!(indexType === 'ivfflat')) return [3 /*break*/, 21];
+                    return [4 /*yield*/, client.query("SET ivfflat.probes = 10")];
+                case 20:
+                    _b.sent();
+                    _b.label = 21;
+                case 21:
+                    // Run queries
+                    spinner.setText("Running " + numQueries + " queries...");
+                    spinner.start();
+                    queryLatencies = [];
+                    distanceOp = metric === 'cosine' ? '<=>' :
+                        metric === 'l2' ? '<->' : '<#>';
+                    q = 0;
+                    _b.label = 22;
+                case 22:
+                    if (!(q < numQueries)) return [3 /*break*/, 25];
+                    queryVector = generateRandomVector(dimensions);
+                    queryStart = Date.now();
+                    return [4 /*yield*/, client.query("\n          SELECT id, embedding " + distanceOp + " '[" + queryVector.join(',') + "]' as distance\n          FROM " + benchmarkTable + "\n          ORDER BY embedding " + distanceOp + " '[" + queryVector.join(',') + "]'\n          LIMIT " + topK + "\n        ")];
+                case 23:
+                    _b.sent();
+                    queryLatencies.push(Date.now() - queryStart);
+                    if (q % 10 === 0) {
+                        spinner.setText("Running queries... " + (q + 1) + "/" + numQueries);
+                    }
+                    _b.label = 24;
+                case 24:
+                    q++;
+                    return [3 /*break*/, 22];
+                case 25:
+                    // Calculate query statistics
+                    queryLatencies.sort(function (a, b) { return a - b; });
+                    avgLatency = queryLatencies.reduce(function (a, b) { return a + b; }, 0) / queryLatencies.length;
+                    p50 = percentile(queryLatencies, 50);
+                    p95 = percentile(queryLatencies, 95);
+                    p99 = percentile(queryLatencies, 99);
+                    minLatency = queryLatencies[0];
+                    maxLatency = queryLatencies[queryLatencies.length - 1];
+                    qps = Math.round(1000 / avgLatency);
+                    results.query = {
+                        totalQueries: numQueries,
+                        avgLatency: avgLatency,
+                        p50: p50,
+                        p95: p95,
+                        p99: p99,
+                        minLatency: minLatency,
+                        maxLatency: maxLatency,
+                        qps: qps
+                    };
+                    spinner.succeed("Completed " + numQueries + " queries");
+                    // Get memory usage
+                    spinner.setText('Analyzing memory usage...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n        SELECT\n          pg_relation_size('" + benchmarkTable + "') as table_size,\n          pg_total_relation_size('" + benchmarkTable + "') as total_size,\n          pg_indexes_size('" + benchmarkTable + "') as index_size\n      ")];
+                case 26:
+                    sizeResult = _b.sent();
+                    tableSize = parseInt(sizeResult.rows[0].table_size, 10);
+                    totalSize = parseInt(sizeResult.rows[0].total_size, 10);
+                    indexSize = parseInt(sizeResult.rows[0].index_size, 10);
+                    bytesPerVector = totalSize / numVectors;
+                    results.memory = {
+                        tableSize: tableSize,
+                        indexSize: indexSize,
+                        totalSize: totalSize,
+                        bytesPerVector: bytesPerVector,
+                        vectorDimensions: dimensions
+                    };
+                    spinner.succeed('Memory analysis complete');
+                    estimatedRecall = 1.0;
+                    if (indexType === 'hnsw') {
+                        estimatedRecall = 0.99; // HNSW typically achieves 99%+ recall with default params
+                    }
+                    else if (indexType === 'ivfflat') {
+                        estimatedRecall = 0.95; // IVFFlat typically 95% with probes=10
+                    }
+                    results.query.estimatedRecall = estimatedRecall;
+                    if (!cleanup) return [3 /*break*/, 28];
+                    spinner.setText('Cleaning up benchmark data...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("DROP TABLE IF EXISTS " + benchmarkTable)];
+                case 27:
+                    _b.sent();
+                    spinner.succeed('Benchmark data cleaned up');
+                    return [3 /*break*/, 29];
+                case 28:
+                    output.printInfo("Benchmark table retained: " + benchmarkTable);
+                    _b.label = 29;
+                case 29: return [4 /*yield*/, client.end()];
+                case 30:
+                    _b.sent();
+                    // Display results
+                    output.writeln();
+                    output.writeln(output.bold('Benchmark Results'));
+                    output.writeln(output.dim('-'.repeat(60)));
+                    output.writeln();
+                    // Insert performance
+                    output.writeln(output.highlight('Insert Performance:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'metric', header: 'Metric', width: 25 },
+                            { key: 'value', header: 'Value', width: 25 },
+                        ],
+                        data: [
+                            { metric: 'Total Vectors', value: numVectors.toLocaleString() },
+                            { metric: 'Total Time', value: (insertDuration / 1000).toFixed(2) + "s" },
+                            { metric: 'Throughput', value: insertThroughput.toLocaleString() + " vectors/sec" },
+                            { metric: 'Index Build Time', value: results.insert.indexTime
+                                    ? (results.insert.indexTime / 1000).toFixed(2) + "s"
+                                    : 'N/A' },
+                        ]
+                    });
+                    output.writeln();
+                    // Query performance
+                    output.writeln(output.highlight('Query Performance:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'metric', header: 'Metric', width: 25 },
+                            { key: 'value', header: 'Value', width: 25 },
+                        ],
+                        data: [
+                            { metric: 'Total Queries', value: numQueries.toLocaleString() },
+                            { metric: 'Avg Latency', value: avgLatency.toFixed(2) + "ms" },
+                            { metric: 'P50 Latency', value: p50.toFixed(2) + "ms" },
+                            { metric: 'P95 Latency', value: p95.toFixed(2) + "ms" },
+                            { metric: 'P99 Latency', value: p99.toFixed(2) + "ms" },
+                            { metric: 'Min/Max Latency', value: minLatency.toFixed(2) + "ms / " + maxLatency.toFixed(2) + "ms" },
+                            { metric: 'Queries/Second', value: qps.toLocaleString() },
+                            { metric: 'Estimated Recall@K', value: (estimatedRecall * 100).toFixed(1) + "%" },
+                        ]
+                    });
+                    output.writeln();
+                    // Memory usage
+                    output.writeln(output.highlight('Memory Usage:'));
+                    formatBytes = function (b) {
+                        if (b < 1024)
+                            return b + " B";
+                        if (b < 1024 * 1024)
+                            return (b / 1024).toFixed(2) + " KB";
+                        if (b < 1024 * 1024 * 1024)
+                            return (b / 1024 / 1024).toFixed(2) + " MB";
+                        return (b / 1024 / 1024 / 1024).toFixed(2) + " GB";
+                    };
+                    output.printTable({
+                        columns: [
+                            { key: 'metric', header: 'Metric', width: 25 },
+                            { key: 'value', header: 'Value', width: 25 },
+                        ],
+                        data: [
+                            { metric: 'Table Size', value: formatBytes(tableSize) },
+                            { metric: 'Index Size', value: formatBytes(indexSize) },
+                            { metric: 'Total Size', value: formatBytes(totalSize) },
+                            { metric: 'Bytes per Vector', value: bytesPerVector.toFixed(2) + " bytes" },
+                        ]
+                    });
+                    output.writeln();
+                    grade = qps >= 1000 ? 'Excellent' :
+                        qps >= 500 ? 'Good' :
+                            qps >= 100 ? 'Fair' : 'Needs Optimization';
+                    gradeColor = qps >= 1000 ? output.success.bind(output) :
+                        qps >= 500 ? output.highlight.bind(output) :
+                            qps >= 100 ? output.warning.bind(output) : output.error.bind(output);
+                    output.printBox([
+                        "Performance Grade: " + gradeColor(grade),
+                        '',
+                        "Throughput: " + insertThroughput.toLocaleString() + " inserts/sec, " + qps.toLocaleString() + " queries/sec",
+                        "Latency: " + avgLatency.toFixed(2) + "ms avg, " + p99.toFixed(2) + "ms p99",
+                        "Memory: " + formatBytes(bytesPerVector) + " per " + dimensions + "-dim vector",
+                        "Recall: ~" + (estimatedRecall * 100).toFixed(0) + "% @ k=" + topK,
+                        '',
+                        indexType === 'hnsw' ? 'HNSW index provides excellent recall with good performance.' :
+                            indexType === 'ivfflat' ? 'IVFFlat index balances memory usage and query speed.' :
+                                'No index: exact search provides 100% recall but slower queries.',
+                    ].join('\n'), 'Summary');
+                    return [2 /*return*/, { success: true, data: results }];
+                case 31:
+                    error_1 = _b.sent();
+                    spinner.fail('Benchmark failed');
+                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 32: return [2 /*return*/];
             }
-            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');
-            // Create benchmark table
-            const benchmarkTable = `${config.schema}.benchmark_${Date.now()}`;
-            spinner.setText('Creating benchmark table...');
-            spinner.start();
-            await client.query(`
-        CREATE TABLE ${benchmarkTable} (
-          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-          embedding vector(${dimensions}),
-          created_at TIMESTAMPTZ DEFAULT NOW()
-        )
-      `);
-            spinner.succeed('Benchmark table created');
-            // Insert vectors
-            spinner.setText(`Inserting ${numVectors.toLocaleString()} vectors...`);
-            spinner.start();
-            const insertStart = Date.now();
-            let insertedCount = 0;
-            for (let batch = 0; batch < Math.ceil(numVectors / batchSize); batch++) {
-                const batchStart = batch * batchSize;
-                const batchEnd = Math.min(batchStart + batchSize, numVectors);
-                const batchVectors = [];
-                for (let i = batchStart; i < batchEnd; i++) {
-                    const vector = generateRandomVector(dimensions);
-                    batchVectors.push(`('[${vector.join(',')}]')`);
-                }
-                await client.query(`
-          INSERT INTO ${benchmarkTable} (embedding)
-          VALUES ${batchVectors.join(',')}
-        `);
-                insertedCount = batchEnd;
-                spinner.setText(`Inserting vectors... ${insertedCount.toLocaleString()}/${numVectors.toLocaleString()}`);
-            }
-            const insertDuration = Date.now() - insertStart;
-            const insertThroughput = Math.round(numVectors / (insertDuration / 1000));
-            results.insert = {
-                totalTime: insertDuration,
-                throughput: insertThroughput,
-                vectorsInserted: numVectors,
-            };
-            spinner.succeed(`Inserted ${numVectors.toLocaleString()} vectors in ${(insertDuration / 1000).toFixed(2)}s (${insertThroughput.toLocaleString()} vectors/sec)`);
-            // Create index
-            if (indexType !== 'none') {
-                spinner.setText(`Creating ${indexType.toUpperCase()} index...`);
-                spinner.start();
-                const indexStart = Date.now();
-                const metricOp = metric === 'cosine' ? 'vector_cosine_ops' :
-                    metric === 'l2' ? 'vector_l2_ops' : 'vector_ip_ops';
-                if (indexType === 'hnsw') {
-                    await client.query(`
-            CREATE INDEX idx_benchmark_hnsw
-            ON ${benchmarkTable}
-            USING hnsw (embedding ${metricOp})
-            WITH (m = 16, ef_construction = 64)
-          `);
-                }
-                else if (indexType === 'ivfflat') {
-                    // Need to train IVFFlat with existing data
-                    const lists = Math.max(100, Math.floor(numVectors / 1000));
-                    await client.query(`
-            CREATE INDEX idx_benchmark_ivfflat
-            ON ${benchmarkTable}
-            USING ivfflat (embedding ${metricOp})
-            WITH (lists = ${lists})
-          `);
-                }
-                const indexDuration = Date.now() - indexStart;
-                results.insert.indexTime = indexDuration;
-                spinner.succeed(`${indexType.toUpperCase()} index created in ${(indexDuration / 1000).toFixed(2)}s`);
-                // Set search parameters
-                if (indexType === 'hnsw') {
-                    await client.query(`SET hnsw.ef_search = 100`);
-                }
-                else if (indexType === 'ivfflat') {
-                    await client.query(`SET ivfflat.probes = 10`);
-                }
-            }
-            // Run queries
-            spinner.setText(`Running ${numQueries} queries...`);
-            spinner.start();
-            const queryLatencies = [];
-            const distanceOp = metric === 'cosine' ? '<=>' :
-                metric === 'l2' ? '<->' : '<#>';
-            for (let q = 0; q < numQueries; q++) {
-                const queryVector = generateRandomVector(dimensions);
-                const queryStart = Date.now();
-                await client.query(`
-          SELECT id, embedding ${distanceOp} '[${queryVector.join(',')}]' as distance
-          FROM ${benchmarkTable}
-          ORDER BY embedding ${distanceOp} '[${queryVector.join(',')}]'
-          LIMIT ${topK}
-        `);
-                queryLatencies.push(Date.now() - queryStart);
-                if (q % 10 === 0) {
-                    spinner.setText(`Running queries... ${q + 1}/${numQueries}`);
-                }
-            }
-            // Calculate query statistics
-            queryLatencies.sort((a, b) => a - b);
-            const avgLatency = queryLatencies.reduce((a, b) => a + b, 0) / queryLatencies.length;
-            const p50 = percentile(queryLatencies, 50);
-            const p95 = percentile(queryLatencies, 95);
-            const p99 = percentile(queryLatencies, 99);
-            const minLatency = queryLatencies[0];
-            const maxLatency = queryLatencies[queryLatencies.length - 1];
-            const qps = Math.round(1000 / avgLatency);
-            results.query = {
-                totalQueries: numQueries,
-                avgLatency,
-                p50,
-                p95,
-                p99,
-                minLatency,
-                maxLatency,
-                qps,
-            };
-            spinner.succeed(`Completed ${numQueries} queries`);
-            // Get memory usage
-            spinner.setText('Analyzing memory usage...');
-            spinner.start();
-            const sizeResult = await client.query(`
-        SELECT
-          pg_relation_size('${benchmarkTable}') as table_size,
-          pg_total_relation_size('${benchmarkTable}') as total_size,
-          pg_indexes_size('${benchmarkTable}') as index_size
-      `);
-            const tableSize = parseInt(sizeResult.rows[0].table_size, 10);
-            const totalSize = parseInt(sizeResult.rows[0].total_size, 10);
-            const indexSize = parseInt(sizeResult.rows[0].index_size, 10);
-            const bytesPerVector = totalSize / numVectors;
-            results.memory = {
-                tableSize,
-                indexSize,
-                totalSize,
-                bytesPerVector,
-                vectorDimensions: dimensions,
-            };
-            spinner.succeed('Memory analysis complete');
-            // Calculate recall (if we have ground truth)
-            // For now, we'll estimate based on index type
-            let estimatedRecall = 1.0;
-            if (indexType === 'hnsw') {
-                estimatedRecall = 0.99; // HNSW typically achieves 99%+ recall with default params
-            }
-            else if (indexType === 'ivfflat') {
-                estimatedRecall = 0.95; // IVFFlat typically 95% with probes=10
-            }
-            results.query.estimatedRecall = estimatedRecall;
-            // Cleanup
-            if (cleanup) {
-                spinner.setText('Cleaning up benchmark data...');
-                spinner.start();
-                await client.query(`DROP TABLE IF EXISTS ${benchmarkTable}`);
-                spinner.succeed('Benchmark data cleaned up');
-            }
-            else {
-                output.printInfo(`Benchmark table retained: ${benchmarkTable}`);
-            }
-            await client.end();
-            // Display results
-            output.writeln();
-            output.writeln(output.bold('Benchmark Results'));
-            output.writeln(output.dim('-'.repeat(60)));
-            output.writeln();
-            // Insert performance
-            output.writeln(output.highlight('Insert Performance:'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 25 },
-                ],
-                data: [
-                    { metric: 'Total Vectors', value: numVectors.toLocaleString() },
-                    { metric: 'Total Time', value: `${(insertDuration / 1000).toFixed(2)}s` },
-                    { metric: 'Throughput', value: `${insertThroughput.toLocaleString()} vectors/sec` },
-                    { metric: 'Index Build Time', value: results.insert.indexTime
-                            ? `${(results.insert.indexTime / 1000).toFixed(2)}s`
-                            : 'N/A' },
-                ],
-            });
-            output.writeln();
-            // Query performance
-            output.writeln(output.highlight('Query Performance:'));
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 25 },
-                ],
-                data: [
-                    { metric: 'Total Queries', value: numQueries.toLocaleString() },
-                    { metric: 'Avg Latency', value: `${avgLatency.toFixed(2)}ms` },
-                    { metric: 'P50 Latency', value: `${p50.toFixed(2)}ms` },
-                    { metric: 'P95 Latency', value: `${p95.toFixed(2)}ms` },
-                    { metric: 'P99 Latency', value: `${p99.toFixed(2)}ms` },
-                    { metric: 'Min/Max Latency', value: `${minLatency.toFixed(2)}ms / ${maxLatency.toFixed(2)}ms` },
-                    { metric: 'Queries/Second', value: qps.toLocaleString() },
-                    { metric: 'Estimated Recall@K', value: `${(estimatedRecall * 100).toFixed(1)}%` },
-                ],
-            });
-            output.writeln();
-            // Memory usage
-            output.writeln(output.highlight('Memory Usage:'));
-            const formatBytes = (b) => {
-                if (b < 1024)
-                    return `${b} B`;
-                if (b < 1024 * 1024)
-                    return `${(b / 1024).toFixed(2)} KB`;
-                if (b < 1024 * 1024 * 1024)
-                    return `${(b / 1024 / 1024).toFixed(2)} MB`;
-                return `${(b / 1024 / 1024 / 1024).toFixed(2)} GB`;
-            };
-            output.printTable({
-                columns: [
-                    { key: 'metric', header: 'Metric', width: 25 },
-                    { key: 'value', header: 'Value', width: 25 },
-                ],
-                data: [
-                    { metric: 'Table Size', value: formatBytes(tableSize) },
-                    { metric: 'Index Size', value: formatBytes(indexSize) },
-                    { metric: 'Total Size', value: formatBytes(totalSize) },
-                    { metric: 'Bytes per Vector', value: `${bytesPerVector.toFixed(2)} bytes` },
-                ],
-            });
-            output.writeln();
-            // Summary box
-            const grade = qps >= 1000 ? 'Excellent' :
-                qps >= 500 ? 'Good' :
-                    qps >= 100 ? 'Fair' : 'Needs Optimization';
-            const gradeColor = qps >= 1000 ? output.success.bind(output) :
-                qps >= 500 ? output.highlight.bind(output) :
-                    qps >= 100 ? output.warning.bind(output) : output.error.bind(output);
-            output.printBox([
-                `Performance Grade: ${gradeColor(grade)}`,
-                '',
-                `Throughput: ${insertThroughput.toLocaleString()} inserts/sec, ${qps.toLocaleString()} queries/sec`,
-                `Latency: ${avgLatency.toFixed(2)}ms avg, ${p99.toFixed(2)}ms p99`,
-                `Memory: ${formatBytes(bytesPerVector)} per ${dimensions}-dim vector`,
-                `Recall: ~${(estimatedRecall * 100).toFixed(0)}% @ k=${topK}`,
-                '',
-                indexType === 'hnsw' ? 'HNSW index provides excellent recall with good performance.' :
-                    indexType === 'ivfflat' ? 'IVFFlat index balances memory usage and query speed.' :
-                        'No index: exact search provides 100% recall but slower queries.',
-            ].join('\n'), 'Summary');
-            return { success: true, data: results };
-        }
-        catch (error) {
-            spinner.fail('Benchmark failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 export default benchmarkCommand;
 //# sourceMappingURL=benchmark.js.map