kynjal-cli 4.0.0 → 4.0.2

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

@@ -2,42 +2,6 @@
  * V3 CLI RuVector Init Command
  * Initialize 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, input } from '../../prompt.js';
 /**
@@ -51,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',
     };
 }
 /**
  * Initialize RuVector in PostgreSQL
  */
-export var initCommand = {
+export const initCommand = {
     name: 'init',
     description: 'Initialize RuVector in PostgreSQL',
     options: [
@@ -66,66 +30,66 @@ export var initCommand = {
             short: 'h',
             description: 'PostgreSQL host',
             type: 'string',
-            "default": 'localhost'
+            default: 'localhost',
         },
         {
             name: 'port',
             short: 'p',
             description: 'PostgreSQL port',
             type: 'number',
-            "default": 5432
+            default: 5432,
         },
         {
             name: 'database',
             short: 'd',
             description: 'Database name',
             type: 'string',
-            required: true
+            required: true,
         },
         {
             name: 'user',
             short: 'u',
             description: 'Database user',
             type: 'string',
-            "default": 'postgres'
+            default: 'postgres',
         },
         {
             name: 'password',
             description: 'Database password (or use PGPASSWORD env)',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'ssl',
             description: 'Enable SSL connection',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'schema',
             short: 's',
             description: 'Schema name for RuVector tables',
             type: 'string',
-            "default": 'claude_flow'
+            default: 'claude_flow',
         },
         {
             name: 'force',
             short: 'f',
             description: 'Force re-initialization (drops existing schema)',
             type: 'boolean',
-            "default": false
+            default: false,
         },
         {
             name: 'dimensions',
             description: 'Default vector dimensions',
             type: 'number',
-            "default": 1536
+            default: 1536,
         },
         {
             name: 'index-type',
             description: 'Default index type (hnsw, ivfflat)',
             type: 'string',
-            "default": 'hnsw',
-            choices: ['hnsw', 'ivfflat']
+            default: 'hnsw',
+            choices: ['hnsw', 'ivfflat'],
         },
     ],
     examples: [
@@ -134,321 +98,334 @@ export var initCommand = {
         { command: 'claude-flow ruvector init -d mydb --force', description: 'Force re-initialization' },
         { command: 'claude-flow ruvector init -d mydb --dimensions 768', description: 'Custom vector dimensions' },
     ],
-    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
-        var config, _a, useRemote, _b, _c, _d, _e, _f, _g, force, dimensions, indexType, confirmDrop, spinner, pg, _h, client, extensionResult, error_1, error_2;
-        return __generator(this, function (_j) {
-            switch (_j.label) {
-                case 0:
-                    config = getConnectionConfig(ctx);
-                    output.writeln();
-                    output.writeln(output.bold('RuVector PostgreSQL Initialization'));
-                    output.writeln(output.dim('='.repeat(60)));
-                    output.writeln();
-                    if (!(!config.database && ctx.interactive)) return [3 /*break*/, 9];
-                    _a = config;
-                    return [4 /*yield*/, input({
-                            message: 'Database name:',
-                            validate: function (v) { return v.length > 0 || 'Database name is required'; }
-                        })];
-                case 1:
-                    _a.database = _j.sent();
-                    return [4 /*yield*/, confirm({
-                            message: 'Connect to remote PostgreSQL?',
-                            "default": false
-                        })];
-                case 2:
-                    useRemote = _j.sent();
-                    if (!useRemote) return [3 /*break*/, 6];
-                    _b = config;
-                    return [4 /*yield*/, input({
-                            message: 'PostgreSQL host:',
-                            "default": 'localhost'
-                        })];
-                case 3:
-                    _b.host = _j.sent();
-                    _c = config;
-                    _d = parseInt;
-                    return [4 /*yield*/, input({
-                            message: 'PostgreSQL port:',
-                            "default": '5432'
-                        })];
-                case 4:
-                    _c.port = _d.apply(void 0, [_j.sent(), 10]);
-                    _e = config;
-                    return [4 /*yield*/, confirm({
-                            message: 'Enable SSL?',
-                            "default": true
-                        })];
-                case 5:
-                    _e.ssl = _j.sent();
-                    _j.label = 6;
-                case 6:
-                    _f = config;
-                    return [4 /*yield*/, input({
-                            message: 'Database user:',
-                            "default": 'postgres'
-                        })];
-                case 7:
-                    _f.user = _j.sent();
-                    if (!!config.password) return [3 /*break*/, 9];
-                    _g = config;
-                    return [4 /*yield*/, input({
-                            message: 'Database password (or set PGPASSWORD):'
-                        })];
-                case 8:
-                    _g.password = _j.sent();
-                    _j.label = 9;
-                case 9:
-                    if (!config.database) {
-                        output.printError('Database name is required. Use --database or -d flag.');
-                        return [2 /*return*/, { success: false, exitCode: 1 }];
-                    }
-                    force = ctx.flags.force;
-                    dimensions = parseInt(ctx.flags.dimensions || '1536', 10);
-                    indexType = ctx.flags['index-type'] || 'hnsw';
-                    // Show configuration
-                    output.writeln(output.highlight('Connection Configuration:'));
-                    output.printTable({
-                        columns: [
-                            { key: 'setting', header: 'Setting', width: 20 },
-                            { key: 'value', header: 'Value', width: 40 },
-                        ],
-                        data: [
-                            { setting: 'Host', value: config.host },
-                            { setting: 'Port', value: String(config.port) },
-                            { setting: 'Database', value: config.database },
-                            { setting: 'User', value: config.user },
-                            { setting: 'SSL', value: config.ssl ? 'Enabled' : 'Disabled' },
-                            { setting: 'Schema', value: config.schema },
-                            { setting: 'Dimensions', value: String(dimensions) },
-                            { setting: 'Index Type', value: indexType.toUpperCase() },
-                        ]
-                    });
-                    output.writeln();
-                    if (!force) return [3 /*break*/, 11];
-                    output.printWarning('Force mode: existing schema will be dropped!');
-                    if (!ctx.interactive) return [3 /*break*/, 11];
-                    return [4 /*yield*/, confirm({
-                            message: "Drop and recreate schema \"" + config.schema + "\"?",
-                            "default": false
-                        })];
-                case 10:
-                    confirmDrop = _j.sent();
-                    if (!confirmDrop) {
-                        output.printInfo('Initialization cancelled');
-                        return [2 /*return*/, { success: false, exitCode: 0 }];
-                    }
-                    _j.label = 11;
-                case 11:
-                    spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-                    spinner.start();
-                    _j.label = 12;
-                case 12:
-                    _j.trys.push([12, 51, , 52]);
-                    pg = null;
-                    _j.label = 13;
-                case 13:
-                    _j.trys.push([13, 15, , 16]);
-                    return [4 /*yield*/, import('pg')];
-                case 14:
-                    pg = _j.sent();
-                    return [3 /*break*/, 16];
-                case 15:
-                    _h = _j.sent();
-                    spinner.fail('PostgreSQL driver not found');
-                    output.printError('Install pg package: npm install pg');
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 16:
-                    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 17:
-                    _j.sent();
-                    spinner.succeed('Connected to PostgreSQL');
-                    // Check pgvector extension
-                    spinner.setText('Checking pgvector extension...');
-                    spinner.start();
-                    return [4 /*yield*/, client.query("\n        SELECT extversion FROM pg_extension WHERE extname = 'vector'\n      ")];
-                case 18:
-                    extensionResult = _j.sent();
-                    if (!(extensionResult.rows.length === 0)) return [3 /*break*/, 24];
-                    spinner.succeed('pgvector not installed, attempting to create...');
-                    _j.label = 19;
-                case 19:
-                    _j.trys.push([19, 21, , 23]);
-                    return [4 /*yield*/, client.query('CREATE EXTENSION IF NOT EXISTS vector')];
-                case 20:
-                    _j.sent();
+    action: async (ctx) => {
+        let config = getConnectionConfig(ctx);
+        output.writeln();
+        output.writeln(output.bold('RuVector PostgreSQL Initialization'));
+        output.writeln(output.dim('='.repeat(60)));
+        output.writeln();
+        // Interactive mode if database not specified
+        if (!config.database && ctx.interactive) {
+            config.database = await input({
+                message: 'Database name:',
+                validate: (v) => v.length > 0 || 'Database name is required',
+            });
+            const useRemote = await confirm({
+                message: 'Connect to remote PostgreSQL?',
+                default: false,
+            });
+            if (useRemote) {
+                config.host = await input({
+                    message: 'PostgreSQL host:',
+                    default: 'localhost',
+                });
+                config.port = parseInt(await input({
+                    message: 'PostgreSQL port:',
+                    default: '5432',
+                }), 10);
+                config.ssl = await confirm({
+                    message: 'Enable SSL?',
+                    default: true,
+                });
+            }
+            config.user = await input({
+                message: 'Database user:',
+                default: 'postgres',
+            });
+            if (!config.password) {
+                config.password = await input({
+                    message: 'Database password (or set PGPASSWORD):',
+                });
+            }
+        }
+        if (!config.database) {
+            output.printError('Database name is required. Use --database or -d flag.');
+            return { success: false, exitCode: 1 };
+        }
+        const force = ctx.flags.force;
+        const dimensions = parseInt(ctx.flags.dimensions || '1536', 10);
+        const indexType = ctx.flags['index-type'] || 'hnsw';
+        // Show configuration
+        output.writeln(output.highlight('Connection Configuration:'));
+        output.printTable({
+            columns: [
+                { key: 'setting', header: 'Setting', width: 20 },
+                { key: 'value', header: 'Value', width: 40 },
+            ],
+            data: [
+                { setting: 'Host', value: config.host },
+                { setting: 'Port', value: String(config.port) },
+                { setting: 'Database', value: config.database },
+                { setting: 'User', value: config.user },
+                { setting: 'SSL', value: config.ssl ? 'Enabled' : 'Disabled' },
+                { setting: 'Schema', value: config.schema },
+                { setting: 'Dimensions', value: String(dimensions) },
+                { setting: 'Index Type', value: indexType.toUpperCase() },
+            ],
+        });
+        output.writeln();
+        if (force) {
+            output.printWarning('Force mode: existing schema will be dropped!');
+            if (ctx.interactive) {
+                const confirmDrop = await confirm({
+                    message: `Drop and recreate schema "${config.schema}"?`,
+                    default: false,
+                });
+                if (!confirmDrop) {
+                    output.printInfo('Initialization cancelled');
+                    return { success: false, exitCode: 0 };
+                }
+            }
+        }
+        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
+        spinner.start();
+        try {
+            // Check for pg module
+            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 };
+            }
+            // Connect to PostgreSQL
+            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 pgvector extension
+            spinner.setText('Checking pgvector extension...');
+            spinner.start();
+            const extensionResult = await client.query(`
+        SELECT extversion FROM pg_extension WHERE extname = 'vector'
+      `);
+            if (extensionResult.rows.length === 0) {
+                spinner.succeed('pgvector not installed, attempting to create...');
+                try {
+                    await client.query('CREATE EXTENSION IF NOT EXISTS vector');
                     spinner.succeed('pgvector extension created');
-                    return [3 /*break*/, 23];
-                case 21:
-                    error_1 = _j.sent();
+                }
+                catch (error) {
                     spinner.fail('Failed to create pgvector extension');
                     output.printError('Please install pgvector manually: https://github.com/pgvector/pgvector');
-                    return [4 /*yield*/, client.end()];
-                case 22:
-                    _j.sent();
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 23: return [3 /*break*/, 25];
-                case 24:
-                    spinner.succeed("pgvector v" + extensionResult.rows[0].extversion + " found");
-                    _j.label = 25;
-                case 25:
-                    if (!force) return [3 /*break*/, 27];
-                    spinner.setText("Dropping schema \"" + config.schema + "\"...");
-                    spinner.start();
-                    return [4 /*yield*/, client.query("DROP SCHEMA IF EXISTS " + config.schema + " CASCADE")];
-                case 26:
-                    _j.sent();
-                    spinner.succeed("Schema \"" + config.schema + "\" dropped");
-                    _j.label = 27;
-                case 27:
-                    // Create schema
-                    spinner.setText("Creating schema \"" + config.schema + "\"...");
-                    spinner.start();
-                    return [4 /*yield*/, client.query("CREATE SCHEMA IF NOT EXISTS " + config.schema)];
-                case 28:
-                    _j.sent();
-                    spinner.succeed("Schema \"" + config.schema + "\" created");
-                    // Create tables
-                    spinner.setText('Creating RuVector tables...');
-                    spinner.start();
-                    // Vector embeddings table
-                    return [4 /*yield*/, client.query("\n        CREATE TABLE IF NOT EXISTS " + config.schema + ".embeddings (\n          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n          key VARCHAR(512) NOT NULL,\n          namespace VARCHAR(128) NOT NULL DEFAULT 'default',\n          content TEXT,\n          embedding vector(" + dimensions + "),\n          metadata JSONB DEFAULT '{}',\n          created_at TIMESTAMPTZ DEFAULT NOW(),\n          updated_at TIMESTAMPTZ DEFAULT NOW(),\n          UNIQUE(key, namespace)\n        )\n      ")];
-                case 29:
-                    // Vector embeddings table
-                    _j.sent();
-                    // Attention patterns table
-                    return [4 /*yield*/, client.query("\n        CREATE TABLE IF NOT EXISTS " + config.schema + ".attention_patterns (\n          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n          pattern_name VARCHAR(256) NOT NULL,\n          query_embedding vector(" + dimensions + "),\n          key_embedding vector(" + dimensions + "),\n          value_embedding vector(" + dimensions + "),\n          attention_weights JSONB,\n          context TEXT,\n          created_at TIMESTAMPTZ DEFAULT NOW()\n        )\n      ")];
-                case 30:
-                    // Attention patterns table
-                    _j.sent();
-                    // GNN adjacency table
-                    return [4 /*yield*/, client.query("\n        CREATE TABLE IF NOT EXISTS " + config.schema + ".gnn_edges (\n          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n          source_id UUID NOT NULL,\n          target_id UUID NOT NULL,\n          edge_type VARCHAR(64) NOT NULL DEFAULT 'related',\n          weight FLOAT DEFAULT 1.0,\n          metadata JSONB DEFAULT '{}',\n          created_at TIMESTAMPTZ DEFAULT NOW(),\n          UNIQUE(source_id, target_id, edge_type)\n        )\n      ")];
-                case 31:
-                    // GNN adjacency table
-                    _j.sent();
-                    // Hyperbolic embeddings table (Poincare ball)
-                    return [4 /*yield*/, client.query("\n        CREATE TABLE IF NOT EXISTS " + config.schema + ".hyperbolic_embeddings (\n          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),\n          entity_id UUID NOT NULL,\n          embedding vector(" + dimensions + "),\n          curvature FLOAT DEFAULT -1.0,\n          hierarchy_level INTEGER DEFAULT 0,\n          parent_id UUID,\n          created_at TIMESTAMPTZ DEFAULT NOW()\n        )\n      ")];
-                case 32:
-                    // Hyperbolic embeddings table (Poincare ball)
-                    _j.sent();
-                    // Migrations tracking table
-                    return [4 /*yield*/, client.query("\n        CREATE TABLE IF NOT EXISTS " + config.schema + ".migrations (\n          id SERIAL PRIMARY KEY,\n          version VARCHAR(64) NOT NULL UNIQUE,\n          name VARCHAR(256) NOT NULL,\n          applied_at TIMESTAMPTZ DEFAULT NOW(),\n          checksum VARCHAR(64)\n        )\n      ")];
-                case 33:
-                    // Migrations tracking table
-                    _j.sent();
-                    // RuVector metadata table
-                    return [4 /*yield*/, client.query("\n        CREATE TABLE IF NOT EXISTS " + config.schema + ".metadata (\n          key VARCHAR(128) PRIMARY KEY,\n          value JSONB NOT NULL,\n          updated_at TIMESTAMPTZ DEFAULT NOW()\n        )\n      ")];
-                case 34:
-                    // RuVector metadata table
-                    _j.sent();
-                    // Store initialization metadata
-                    return [4 /*yield*/, client.query("\n        INSERT INTO " + config.schema + ".metadata (key, value)\n        VALUES ('ruvector_version', '\"1.0.0\"')\n        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()\n      ")];
-                case 35:
-                    // Store initialization metadata
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n        INSERT INTO " + config.schema + ".metadata (key, value)\n        VALUES ('dimensions', '" + dimensions + "')\n        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()\n      ")];
-                case 36:
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n        INSERT INTO " + config.schema + ".metadata (key, value)\n        VALUES ('initialized_at', '\"" + new Date().toISOString() + "\"')\n        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()\n      ")];
-                case 37:
-                    _j.sent();
-                    spinner.succeed('RuVector tables created');
-                    // Create indexes
-                    spinner.setText("Creating " + indexType.toUpperCase() + " indexes...");
-                    spinner.start();
-                    if (!(indexType === 'hnsw')) return [3 /*break*/, 41];
-                    return [4 /*yield*/, client.query("\n          CREATE INDEX IF NOT EXISTS idx_embeddings_vector_hnsw\n          ON " + config.schema + ".embeddings\n          USING hnsw (embedding vector_cosine_ops)\n          WITH (m = 16, ef_construction = 64)\n        ")];
-                case 38:
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n          CREATE INDEX IF NOT EXISTS idx_attention_query_hnsw\n          ON " + config.schema + ".attention_patterns\n          USING hnsw (query_embedding vector_cosine_ops)\n          WITH (m = 16, ef_construction = 64)\n        ")];
-                case 39:
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n          CREATE INDEX IF NOT EXISTS idx_hyperbolic_embedding_hnsw\n          ON " + config.schema + ".hyperbolic_embeddings\n          USING hnsw (embedding vector_cosine_ops)\n          WITH (m = 16, ef_construction = 64)\n        ")];
-                case 40:
-                    _j.sent();
-                    return [3 /*break*/, 44];
-                case 41: 
+                    await client.end();
+                    return { success: false, exitCode: 1 };
+                }
+            }
+            else {
+                spinner.succeed(`pgvector v${extensionResult.rows[0].extversion} found`);
+            }
+            // Drop schema if force mode
+            if (force) {
+                spinner.setText(`Dropping schema "${config.schema}"...`);
+                spinner.start();
+                await client.query(`DROP SCHEMA IF EXISTS ${config.schema} CASCADE`);
+                spinner.succeed(`Schema "${config.schema}" dropped`);
+            }
+            // Create schema
+            spinner.setText(`Creating schema "${config.schema}"...`);
+            spinner.start();
+            await client.query(`CREATE SCHEMA IF NOT EXISTS ${config.schema}`);
+            spinner.succeed(`Schema "${config.schema}" created`);
+            // Create tables
+            spinner.setText('Creating RuVector tables...');
+            spinner.start();
+            // Vector embeddings table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${config.schema}.embeddings (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          key VARCHAR(512) NOT NULL,
+          namespace VARCHAR(128) NOT NULL DEFAULT 'default',
+          content TEXT,
+          embedding vector(${dimensions}),
+          metadata JSONB DEFAULT '{}',
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          updated_at TIMESTAMPTZ DEFAULT NOW(),
+          UNIQUE(key, namespace)
+        )
+      `);
+            // Attention patterns table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${config.schema}.attention_patterns (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          pattern_name VARCHAR(256) NOT NULL,
+          query_embedding vector(${dimensions}),
+          key_embedding vector(${dimensions}),
+          value_embedding vector(${dimensions}),
+          attention_weights JSONB,
+          context TEXT,
+          created_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+            // GNN adjacency table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${config.schema}.gnn_edges (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          source_id UUID NOT NULL,
+          target_id UUID NOT NULL,
+          edge_type VARCHAR(64) NOT NULL DEFAULT 'related',
+          weight FLOAT DEFAULT 1.0,
+          metadata JSONB DEFAULT '{}',
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          UNIQUE(source_id, target_id, edge_type)
+        )
+      `);
+            // Hyperbolic embeddings table (Poincare ball)
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${config.schema}.hyperbolic_embeddings (
+          id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          entity_id UUID NOT NULL,
+          embedding vector(${dimensions}),
+          curvature FLOAT DEFAULT -1.0,
+          hierarchy_level INTEGER DEFAULT 0,
+          parent_id UUID,
+          created_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+            // Migrations tracking table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${config.schema}.migrations (
+          id SERIAL PRIMARY KEY,
+          version VARCHAR(64) NOT NULL UNIQUE,
+          name VARCHAR(256) NOT NULL,
+          applied_at TIMESTAMPTZ DEFAULT NOW(),
+          checksum VARCHAR(64)
+        )
+      `);
+            // RuVector metadata table
+            await client.query(`
+        CREATE TABLE IF NOT EXISTS ${config.schema}.metadata (
+          key VARCHAR(128) PRIMARY KEY,
+          value JSONB NOT NULL,
+          updated_at TIMESTAMPTZ DEFAULT NOW()
+        )
+      `);
+            // Store initialization metadata
+            await client.query(`
+        INSERT INTO ${config.schema}.metadata (key, value)
+        VALUES ('ruvector_version', '"1.0.0"')
+        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()
+      `);
+            await client.query(`
+        INSERT INTO ${config.schema}.metadata (key, value)
+        VALUES ('dimensions', '${dimensions}')
+        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()
+      `);
+            await client.query(`
+        INSERT INTO ${config.schema}.metadata (key, value)
+        VALUES ('initialized_at', '"${new Date().toISOString()}"')
+        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()
+      `);
+            spinner.succeed('RuVector tables created');
+            // Create indexes
+            spinner.setText(`Creating ${indexType.toUpperCase()} indexes...`);
+            spinner.start();
+            if (indexType === 'hnsw') {
+                await client.query(`
+          CREATE INDEX IF NOT EXISTS idx_embeddings_vector_hnsw
+          ON ${config.schema}.embeddings
+          USING hnsw (embedding vector_cosine_ops)
+          WITH (m = 16, ef_construction = 64)
+        `);
+                await client.query(`
+          CREATE INDEX IF NOT EXISTS idx_attention_query_hnsw
+          ON ${config.schema}.attention_patterns
+          USING hnsw (query_embedding vector_cosine_ops)
+          WITH (m = 16, ef_construction = 64)
+        `);
+                await client.query(`
+          CREATE INDEX IF NOT EXISTS idx_hyperbolic_embedding_hnsw
+          ON ${config.schema}.hyperbolic_embeddings
+          USING hnsw (embedding vector_cosine_ops)
+          WITH (m = 16, ef_construction = 64)
+        `);
+            }
+            else {
                 // IVFFlat indexes
-                return [4 /*yield*/, client.query("\n          CREATE INDEX IF NOT EXISTS idx_embeddings_vector_ivfflat\n          ON " + config.schema + ".embeddings\n          USING ivfflat (embedding vector_cosine_ops)\n          WITH (lists = 100)\n        ")];
-                case 42:
-                    // IVFFlat indexes
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n          CREATE INDEX IF NOT EXISTS idx_attention_query_ivfflat\n          ON " + config.schema + ".attention_patterns\n          USING ivfflat (query_embedding vector_cosine_ops)\n          WITH (lists = 100)\n        ")];
-                case 43:
-                    _j.sent();
-                    _j.label = 44;
-                case 44: 
-                // Additional standard indexes
-                return [4 /*yield*/, client.query("\n        CREATE INDEX IF NOT EXISTS idx_embeddings_namespace\n        ON " + config.schema + ".embeddings (namespace)\n      ")];
-                case 45:
-                    // Additional standard indexes
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n        CREATE INDEX IF NOT EXISTS idx_embeddings_key\n        ON " + config.schema + ".embeddings (key)\n      ")];
-                case 46:
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n        CREATE INDEX IF NOT EXISTS idx_gnn_source\n        ON " + config.schema + ".gnn_edges (source_id)\n      ")];
-                case 47:
-                    _j.sent();
-                    return [4 /*yield*/, client.query("\n        CREATE INDEX IF NOT EXISTS idx_gnn_target\n        ON " + config.schema + ".gnn_edges (target_id)\n      ")];
-                case 48:
-                    _j.sent();
-                    spinner.succeed(indexType.toUpperCase() + " indexes created");
-                    // Record initial migration
-                    return [4 /*yield*/, client.query("\n        INSERT INTO " + config.schema + ".migrations (version, name)\n        VALUES ('1.0.0', 'Initial RuVector setup')\n        ON CONFLICT (version) DO NOTHING\n      ")];
-                case 49:
-                    // Record initial migration
-                    _j.sent();
-                    return [4 /*yield*/, client.end()];
-                case 50:
-                    _j.sent();
-                    output.writeln();
-                    output.printSuccess('RuVector PostgreSQL Bridge initialized successfully!');
-                    output.writeln();
-                    output.printBox([
-                        'Created tables:',
-                        "  - " + config.schema + ".embeddings (vector storage)",
-                        "  - " + config.schema + ".attention_patterns (attention mechanism)",
-                        "  - " + config.schema + ".gnn_edges (graph neural network)",
-                        "  - " + config.schema + ".hyperbolic_embeddings (Poincare ball)",
-                        "  - " + config.schema + ".migrations (version tracking)",
-                        "  - " + config.schema + ".metadata (configuration)",
-                        '',
-                        'Created indexes:',
-                        "  - " + indexType.toUpperCase() + " vector similarity index",
-                        '  - B-tree indexes on key, namespace',
-                        '  - GNN edge indexes',
-                        '',
-                        'Next steps:',
-                        '  1. Run migrations: claude-flow ruvector migrate --up',
-                        '  2. Check status: claude-flow ruvector status --verbose',
-                        '  3. Run benchmark: claude-flow ruvector benchmark',
-                    ].join('\n'), 'Initialization Complete');
-                    return [2 /*return*/, {
-                            success: true,
-                            data: {
-                                schema: config.schema,
-                                dimensions: dimensions,
-                                indexType: indexType,
-                                tables: ['embeddings', 'attention_patterns', 'gnn_edges', 'hyperbolic_embeddings', 'migrations', 'metadata']
-                            }
-                        }];
-                case 51:
-                    error_2 = _j.sent();
-                    spinner.fail('Initialization failed');
-                    output.printError(error_2 instanceof Error ? error_2.message : String(error_2));
-                    return [2 /*return*/, { success: false, exitCode: 1 }];
-                case 52: return [2 /*return*/];
+                await client.query(`
+          CREATE INDEX IF NOT EXISTS idx_embeddings_vector_ivfflat
+          ON ${config.schema}.embeddings
+          USING ivfflat (embedding vector_cosine_ops)
+          WITH (lists = 100)
+        `);
+                await client.query(`
+          CREATE INDEX IF NOT EXISTS idx_attention_query_ivfflat
+          ON ${config.schema}.attention_patterns
+          USING ivfflat (query_embedding vector_cosine_ops)
+          WITH (lists = 100)
+        `);
             }
-        });
-    }); }
+            // Additional standard indexes
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_embeddings_namespace
+        ON ${config.schema}.embeddings (namespace)
+      `);
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_embeddings_key
+        ON ${config.schema}.embeddings (key)
+      `);
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_gnn_source
+        ON ${config.schema}.gnn_edges (source_id)
+      `);
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_gnn_target
+        ON ${config.schema}.gnn_edges (target_id)
+      `);
+            spinner.succeed(`${indexType.toUpperCase()} indexes created`);
+            // Record initial migration
+            await client.query(`
+        INSERT INTO ${config.schema}.migrations (version, name)
+        VALUES ('1.0.0', 'Initial RuVector setup')
+        ON CONFLICT (version) DO NOTHING
+      `);
+            await client.end();
+            output.writeln();
+            output.printSuccess('RuVector PostgreSQL Bridge initialized successfully!');
+            output.writeln();
+            output.printBox([
+                'Created tables:',
+                `  - ${config.schema}.embeddings (vector storage)`,
+                `  - ${config.schema}.attention_patterns (attention mechanism)`,
+                `  - ${config.schema}.gnn_edges (graph neural network)`,
+                `  - ${config.schema}.hyperbolic_embeddings (Poincare ball)`,
+                `  - ${config.schema}.migrations (version tracking)`,
+                `  - ${config.schema}.metadata (configuration)`,
+                '',
+                'Created indexes:',
+                `  - ${indexType.toUpperCase()} vector similarity index`,
+                '  - B-tree indexes on key, namespace',
+                '  - GNN edge indexes',
+                '',
+                'Next steps:',
+                '  1. Run migrations: claude-flow ruvector migrate --up',
+                '  2. Check status: claude-flow ruvector status --verbose',
+                '  3. Run benchmark: claude-flow ruvector benchmark',
+            ].join('\n'), 'Initialization Complete');
+            return {
+                success: true,
+                data: {
+                    schema: config.schema,
+                    dimensions,
+                    indexType,
+                    tables: ['embeddings', 'attention_patterns', 'gnn_edges', 'hyperbolic_embeddings', 'migrations', 'metadata'],
+                },
+            };
+        }
+        catch (error) {
+            spinner.fail('Initialization failed');
+            output.printError(error instanceof Error ? error.message : String(error));
+            return { success: false, exitCode: 1 };
+        }
+    },
 };
 export default initCommand;
 //# sourceMappingURL=init.js.map