kynjal-cli 3.1.3 → 4.0.0

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

@@ -2,6 +2,42 @@
  * V3 CLI RuVector Backup Command
  * Backup and restore for RuVector PostgreSQL data
  */
+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';
 /**
@@ -15,7 +51,7 @@ function getConnectionConfig(ctx) {
         user: ctx.flags.user || process.env.PGUSER || 'postgres',
         password: ctx.flags.password || process.env.PGPASSWORD || '',
         ssl: ctx.flags.ssl || process.env.PGSSLMODE === 'require',
-        schema: ctx.flags.schema || 'claude_flow',
+        schema: ctx.flags.schema || 'claude_flow'
     };
 }
 /**
@@ -24,15 +60,15 @@ function getConnectionConfig(ctx) {
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    const k = 1024;
-    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    var k = 1024;
+    var sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    var i = Math.floor(Math.log(bytes) / Math.log(k));
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 /**
  * RuVector backup subcommand
  */
-const backupSubcommand = {
+var backupSubcommand = {
     name: 'create',
     description: 'Create a backup of RuVector data',
     options: [
@@ -41,78 +77,78 @@ const backupSubcommand = {
             short: 'o',
             description: 'Output file path',
             type: 'string',
-            required: true,
+            required: true
         },
         {
             name: 'tables',
             short: 't',
             description: 'Specific tables (comma-separated)',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'format',
             short: 'f',
             description: 'Output format',
             type: 'string',
-            default: 'sql',
-            choices: ['sql', 'json', 'csv'],
+            "default": 'sql',
+            choices: ['sql', 'json', 'csv']
         },
         {
             name: 'compress',
             short: 'c',
             description: 'Compress output (gzip)',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'include-indexes',
             description: 'Include index definitions',
             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',
             short: 'd',
             description: 'Database name',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'user',
             short: 'u',
             description: 'Database user',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'password',
             description: 'Database password',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'ssl',
             description: 'Enable SSL',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'schema',
             short: 's',
             description: 'Schema name',
             type: 'string',
-            default: 'claude_flow',
+            "default": 'claude_flow'
         },
     ],
     examples: [
@@ -120,246 +156,275 @@ const backupSubcommand = {
         { command: 'claude-flow ruvector backup create -o backup.json --format json', description: 'Create JSON backup' },
         { command: 'claude-flow ruvector backup create -o backup.sql.gz --compress', description: 'Compressed backup' },
     ],
-    action: async (ctx) => {
-        const config = getConnectionConfig(ctx);
-        let outputPath = ctx.flags.output;
-        const tablesFilter = ctx.flags.tables;
-        const format = ctx.flags.format || 'sql';
-        const compress = ctx.flags.compress;
-        const includeIndexes = ctx.flags['include-indexes'] !== false;
-        output.writeln();
-        output.writeln(output.bold('RuVector Backup'));
-        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 };
-        }
-        // Interactive mode
-        if (!outputPath && ctx.interactive) {
-            outputPath = await input({
-                message: 'Output file path:',
-                default: `ruvector_backup_${new Date().toISOString().split('T')[0]}.${format}`,
-                validate: (v) => v.length > 0 || 'Output path is required',
-            });
-        }
-        if (!outputPath) {
-            output.printError('Output path is required. Use --output or -o flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
-        spinner.start();
-        try {
-            // Import dependencies
-            const fs = await import('fs');
-            const path = await import('path');
-            const { promisify } = await import('util');
-            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');
-            // Get tables to backup
-            spinner.setText('Discovering tables...');
-            spinner.start();
-            let tables = [];
-            if (tablesFilter) {
-                tables = tablesFilter.split(',').map(t => t.trim());
-            }
-            else {
-                const tablesResult = await client.query(`
-          SELECT table_name FROM information_schema.tables
-          WHERE table_schema = $1 AND table_type = 'BASE TABLE'
-          ORDER BY table_name
-        `, [config.schema]);
-                tables = tablesResult.rows.map(r => r.table_name);
-            }
-            spinner.succeed(`Found ${tables.length} tables to backup`);
-            // Prepare backup data
-            const backupData = {
-                metadata: {
-                    backupDate: new Date().toISOString(),
-                    database: config.database,
-                    schema: config.schema,
-                    format,
-                    version: '1.0.0',
-                },
-                schema: config.schema,
-                tables: [],
-                indexes: [],
-            };
-            let totalRows = 0;
-            // Export each table
-            for (const tableName of tables) {
-                spinner.setText(`Exporting ${tableName}...`);
-                spinner.start();
-                // Get columns
-                const columnsResult = await client.query(`
-          SELECT column_name, data_type
-          FROM information_schema.columns
-          WHERE table_schema = $1 AND table_name = $2
-          ORDER BY ordinal_position
-        `, [config.schema, tableName]);
-                const columns = columnsResult.rows.map(r => r.column_name);
-                // Get data
-                const dataResult = await client.query(`
-          SELECT * FROM ${config.schema}.${tableName}
-        `);
-                backupData.tables.push({
-                    name: tableName,
-                    columns,
-                    rows: dataResult.rows,
-                });
-                totalRows += dataResult.rows.length;
-                spinner.setText(`Exporting ${tableName}... (${dataResult.rows.length} rows)`);
-            }
-            spinner.succeed(`Exported ${totalRows.toLocaleString()} rows from ${tables.length} tables`);
-            // Get indexes
-            if (includeIndexes) {
-                spinner.setText('Exporting index definitions...');
-                spinner.start();
-                const indexResult = await client.query(`
-          SELECT pg_get_indexdef(i.oid) as indexdef
-          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
-          WHERE n.nspname = $1
-            AND NOT idx.indisprimary
-        `, [config.schema]);
-                backupData.indexes = indexResult.rows.map(r => r.indexdef);
-                spinner.succeed(`Exported ${backupData.indexes.length} index definitions`);
-            }
-            await client.end();
-            // Write backup file
-            spinner.setText(`Writing backup to ${outputPath}...`);
-            spinner.start();
-            let content;
-            if (format === 'sql') {
-                // Generate SQL format
-                const lines = [];
-                lines.push(`-- RuVector Backup`);
-                lines.push(`-- Generated: ${backupData.metadata.backupDate}`);
-                lines.push(`-- Database: ${config.database}`);
-                lines.push(`-- Schema: ${config.schema}`);
-                lines.push('');
-                lines.push(`CREATE SCHEMA IF NOT EXISTS ${config.schema};`);
-                lines.push('');
-                for (const table of backupData.tables) {
-                    lines.push(`-- Table: ${table.name}`);
-                    lines.push(`-- Rows: ${table.rows.length}`);
-                    lines.push('');
-                    if (table.rows.length > 0) {
-                        for (const row of table.rows) {
-                            const values = table.columns.map(col => {
-                                const val = row[col];
-                                if (val === null || val === undefined)
-                                    return 'NULL';
-                                if (typeof val === 'string')
-                                    return `'${val.replace(/'/g, "''")}'`;
-                                if (typeof val === 'object')
-                                    return `'${JSON.stringify(val).replace(/'/g, "''")}'`;
-                                return String(val);
-                            });
-                            lines.push(`INSERT INTO ${config.schema}.${table.name} (${table.columns.join(', ')}) VALUES (${values.join(', ')});`);
-                        }
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var config, outputPath, tablesFilter, format, compress, includeIndexes, spinner, fs, path, promisify, pg, _a, client, tables, tablesResult, backupData, totalRows, _i, tables_1, tableName, columnsResult, columns, dataResult, indexResult, content, lines, _b, _c, table, _loop_1, _d, _e, row, _f, _g, idx, lines, _h, _j, table, _loop_2, _k, _l, row, zlib, gzip, compressed, fileSize, error_1;
+        return __generator(this, function (_m) {
+            switch (_m.label) {
+                case 0:
+                    config = getConnectionConfig(ctx);
+                    outputPath = ctx.flags.output;
+                    tablesFilter = ctx.flags.tables;
+                    format = ctx.flags.format || 'sql';
+                    compress = ctx.flags.compress;
+                    includeIndexes = ctx.flags['include-indexes'] !== false;
+                    output.writeln();
+                    output.writeln(output.bold('RuVector Backup'));
+                    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 }];
+                    }
+                    if (!(!outputPath && ctx.interactive)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, input({
+                            message: 'Output file path:',
+                            "default": "ruvector_backup_" + new Date().toISOString().split('T')[0] + "." + format,
+                            validate: function (v) { return v.length > 0 || 'Output path is required'; }
+                        })];
+                case 1:
+                    outputPath = _m.sent();
+                    _m.label = 2;
+                case 2:
+                    if (!outputPath) {
+                        output.printError('Output path is required. Use --output or -o flag.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Connecting to PostgreSQL...', spinner: 'dots' });
+                    spinner.start();
+                    _m.label = 3;
+                case 3:
+                    _m.trys.push([3, 27, , 28]);
+                    return [4 /*yield*/, import('fs')];
+                case 4:
+                    fs = _m.sent();
+                    return [4 /*yield*/, import('path')];
+                case 5:
+                    path = _m.sent();
+                    return [4 /*yield*/, import('util')];
+                case 6:
+                    promisify = (_m.sent()).promisify;
+                    pg = null;
+                    _m.label = 7;
+                case 7:
+                    _m.trys.push([7, 9, , 10]);
+                    return [4 /*yield*/, import('pg')];
+                case 8:
+                    pg = _m.sent();
+                    return [3 /*break*/, 10];
+                case 9:
+                    _a = _m.sent();
+                    spinner.fail('PostgreSQL driver not found');
+                    output.printError('Install pg package: npm install pg');
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 10:
+                    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 11:
+                    _m.sent();
+                    spinner.succeed('Connected to PostgreSQL');
+                    // Get tables to backup
+                    spinner.setText('Discovering tables...');
+                    spinner.start();
+                    tables = [];
+                    if (!tablesFilter) return [3 /*break*/, 12];
+                    tables = tablesFilter.split(',').map(function (t) { return t.trim(); });
+                    return [3 /*break*/, 14];
+                case 12: return [4 /*yield*/, client.query("\n          SELECT table_name FROM information_schema.tables\n          WHERE table_schema = $1 AND table_type = 'BASE TABLE'\n          ORDER BY table_name\n        ", [config.schema])];
+                case 13:
+                    tablesResult = _m.sent();
+                    tables = tablesResult.rows.map(function (r) { return r.table_name; });
+                    _m.label = 14;
+                case 14:
+                    spinner.succeed("Found " + tables.length + " tables to backup");
+                    backupData = {
+                        metadata: {
+                            backupDate: new Date().toISOString(),
+                            database: config.database,
+                            schema: config.schema,
+                            format: format,
+                            version: '1.0.0'
+                        },
+                        schema: config.schema,
+                        tables: [],
+                        indexes: []
+                    };
+                    totalRows = 0;
+                    _i = 0, tables_1 = tables;
+                    _m.label = 15;
+                case 15:
+                    if (!(_i < tables_1.length)) return [3 /*break*/, 19];
+                    tableName = tables_1[_i];
+                    spinner.setText("Exporting " + tableName + "...");
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n          SELECT column_name, data_type\n          FROM information_schema.columns\n          WHERE table_schema = $1 AND table_name = $2\n          ORDER BY ordinal_position\n        ", [config.schema, tableName])];
+                case 16:
+                    columnsResult = _m.sent();
+                    columns = columnsResult.rows.map(function (r) { return r.column_name; });
+                    return [4 /*yield*/, client.query("\n          SELECT * FROM " + config.schema + "." + tableName + "\n        ")];
+                case 17:
+                    dataResult = _m.sent();
+                    backupData.tables.push({
+                        name: tableName,
+                        columns: columns,
+                        rows: dataResult.rows
+                    });
+                    totalRows += dataResult.rows.length;
+                    spinner.setText("Exporting " + tableName + "... (" + dataResult.rows.length + " rows)");
+                    _m.label = 18;
+                case 18:
+                    _i++;
+                    return [3 /*break*/, 15];
+                case 19:
+                    spinner.succeed("Exported " + totalRows.toLocaleString() + " rows from " + tables.length + " tables");
+                    if (!includeIndexes) return [3 /*break*/, 21];
+                    spinner.setText('Exporting index definitions...');
+                    spinner.start();
+                    return [4 /*yield*/, client.query("\n          SELECT pg_get_indexdef(i.oid) as indexdef\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          WHERE n.nspname = $1\n            AND NOT idx.indisprimary\n        ", [config.schema])];
+                case 20:
+                    indexResult = _m.sent();
+                    backupData.indexes = indexResult.rows.map(function (r) { return r.indexdef; });
+                    spinner.succeed("Exported " + backupData.indexes.length + " index definitions");
+                    _m.label = 21;
+                case 21: return [4 /*yield*/, client.end()];
+                case 22:
+                    _m.sent();
+                    // Write backup file
+                    spinner.setText("Writing backup to " + outputPath + "...");
+                    spinner.start();
+                    content = void 0;
+                    if (format === 'sql') {
+                        lines = [];
+                        lines.push("-- RuVector Backup");
+                        lines.push("-- Generated: " + backupData.metadata.backupDate);
+                        lines.push("-- Database: " + config.database);
+                        lines.push("-- Schema: " + config.schema);
                         lines.push('');
+                        lines.push("CREATE SCHEMA IF NOT EXISTS " + config.schema + ";");
+                        lines.push('');
+                        for (_b = 0, _c = backupData.tables; _b < _c.length; _b++) {
+                            table = _c[_b];
+                            lines.push("-- Table: " + table.name);
+                            lines.push("-- Rows: " + table.rows.length);
+                            lines.push('');
+                            if (table.rows.length > 0) {
+                                _loop_1 = function (row) {
+                                    var values = table.columns.map(function (col) {
+                                        var val = row[col];
+                                        if (val === null || val === undefined)
+                                            return 'NULL';
+                                        if (typeof val === 'string')
+                                            return "'" + val.replace(/'/g, "''") + "'";
+                                        if (typeof val === 'object')
+                                            return "'" + JSON.stringify(val).replace(/'/g, "''") + "'";
+                                        return String(val);
+                                    });
+                                    lines.push("INSERT INTO " + config.schema + "." + table.name + " (" + table.columns.join(', ') + ") VALUES (" + values.join(', ') + ");");
+                                };
+                                for (_d = 0, _e = table.rows; _d < _e.length; _d++) {
+                                    row = _e[_d];
+                                    _loop_1(row);
+                                }
+                                lines.push('');
+                            }
+                        }
+                        // Add indexes
+                        if (includeIndexes && backupData.indexes.length > 0) {
+                            lines.push('-- Indexes');
+                            for (_f = 0, _g = backupData.indexes; _f < _g.length; _f++) {
+                                idx = _g[_f];
+                                lines.push(idx + ";");
+                            }
+                        }
+                        content = lines.join('\n');
                     }
-                }
-                // Add indexes
-                if (includeIndexes && backupData.indexes.length > 0) {
-                    lines.push('-- Indexes');
-                    for (const idx of backupData.indexes) {
-                        lines.push(`${idx};`);
+                    else if (format === 'json') {
+                        content = JSON.stringify(backupData, null, 2);
                     }
-                }
-                content = lines.join('\n');
-            }
-            else if (format === 'json') {
-                content = JSON.stringify(backupData, null, 2);
-            }
-            else {
-                // CSV format - one file per table would be better, but we'll concatenate
-                const lines = [];
-                for (const table of backupData.tables) {
-                    lines.push(`# Table: ${table.name}`);
-                    lines.push(table.columns.join(','));
-                    for (const row of table.rows) {
-                        const values = table.columns.map(col => {
-                            const val = row[col];
-                            if (val === null || val === undefined)
-                                return '';
-                            const str = typeof val === 'object' ? JSON.stringify(val) : String(val);
-                            return str.includes(',') || str.includes('"') ? `"${str.replace(/"/g, '""')}"` : str;
-                        });
-                        lines.push(values.join(','));
+                    else {
+                        lines = [];
+                        for (_h = 0, _j = backupData.tables; _h < _j.length; _h++) {
+                            table = _j[_h];
+                            lines.push("# Table: " + table.name);
+                            lines.push(table.columns.join(','));
+                            _loop_2 = function (row) {
+                                var values = table.columns.map(function (col) {
+                                    var val = row[col];
+                                    if (val === null || val === undefined)
+                                        return '';
+                                    var str = typeof val === 'object' ? JSON.stringify(val) : String(val);
+                                    return str.includes(',') || str.includes('"') ? "\"" + str.replace(/"/g, '""') + "\"" : str;
+                                });
+                                lines.push(values.join(','));
+                            };
+                            for (_k = 0, _l = table.rows; _k < _l.length; _k++) {
+                                row = _l[_k];
+                                _loop_2(row);
+                            }
+                            lines.push('');
+                        }
+                        content = lines.join('\n');
                     }
-                    lines.push('');
-                }
-                content = lines.join('\n');
-            }
-            // Compress if requested
-            if (compress) {
-                const zlib = await import('zlib');
-                const gzip = promisify(zlib.gzip);
-                const compressed = await gzip(Buffer.from(content, 'utf-8'));
-                outputPath = outputPath.endsWith('.gz') ? outputPath : `${outputPath}.gz`;
-                fs.writeFileSync(outputPath, compressed);
+                    if (!compress) return [3 /*break*/, 25];
+                    return [4 /*yield*/, import('zlib')];
+                case 23:
+                    zlib = _m.sent();
+                    gzip = promisify(zlib.gzip);
+                    return [4 /*yield*/, gzip(Buffer.from(content, 'utf-8'))];
+                case 24:
+                    compressed = _m.sent();
+                    outputPath = outputPath.endsWith('.gz') ? outputPath : outputPath + ".gz";
+                    fs.writeFileSync(outputPath, compressed);
+                    return [3 /*break*/, 26];
+                case 25:
+                    fs.writeFileSync(outputPath, content, 'utf-8');
+                    _m.label = 26;
+                case 26:
+                    fileSize = fs.statSync(outputPath).size;
+                    spinner.succeed("Backup written to " + outputPath + " (" + formatBytes(fileSize) + ")");
+                    output.writeln();
+                    output.printSuccess('Backup completed successfully!');
+                    output.writeln();
+                    output.printBox([
+                        "Output: " + outputPath,
+                        "Format: " + format.toUpperCase() + (compress ? ' (gzip compressed)' : ''),
+                        "Size: " + formatBytes(fileSize),
+                        "Tables: " + tables.length,
+                        "Total Rows: " + totalRows.toLocaleString(),
+                        "Indexes: " + backupData.indexes.length,
+                    ].join('\n'), 'Backup Summary');
+                    return [2 /*return*/, {
+                            success: true,
+                            data: {
+                                outputPath: outputPath,
+                                format: format,
+                                compressed: compress,
+                                tables: tables.length,
+                                totalRows: totalRows,
+                                indexes: backupData.indexes.length,
+                                fileSize: fileSize
+                            }
+                        }];
+                case 27:
+                    error_1 = _m.sent();
+                    spinner.fail('Backup failed');
+                    output.printError(error_1 instanceof Error ? error_1.message : String(error_1));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 28: return [2 /*return*/];
             }
-            else {
-                fs.writeFileSync(outputPath, content, 'utf-8');
-            }
-            const fileSize = fs.statSync(outputPath).size;
-            spinner.succeed(`Backup written to ${outputPath} (${formatBytes(fileSize)})`);
-            output.writeln();
-            output.printSuccess('Backup completed successfully!');
-            output.writeln();
-            output.printBox([
-                `Output: ${outputPath}`,
-                `Format: ${format.toUpperCase()}${compress ? ' (gzip compressed)' : ''}`,
-                `Size: ${formatBytes(fileSize)}`,
-                `Tables: ${tables.length}`,
-                `Total Rows: ${totalRows.toLocaleString()}`,
-                `Indexes: ${backupData.indexes.length}`,
-            ].join('\n'), 'Backup Summary');
-            return {
-                success: true,
-                data: {
-                    outputPath,
-                    format,
-                    compressed: compress,
-                    tables: tables.length,
-                    totalRows,
-                    indexes: backupData.indexes.length,
-                    fileSize,
-                },
-            };
-        }
-        catch (error) {
-            spinner.fail('Backup failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * RuVector restore subcommand
  */
-const restoreSubcommand = {
+var restoreSubcommand = {
     name: 'restore',
     description: 'Restore RuVector data from backup',
     options: [
@@ -368,63 +433,63 @@ const restoreSubcommand = {
             short: 'i',
             description: 'Input file path',
             type: 'string',
-            required: true,
+            required: true
         },
         {
             name: 'clean',
             description: 'Drop existing tables first',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'dry-run',
             description: 'Show what would be restored without executing',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'host',
             short: 'h',
             description: 'PostgreSQL host',
             type: 'string',
-            default: 'localhost',
+            "default": 'localhost'
         },
         {
             name: 'port',
             short: 'p',
             description: 'PostgreSQL port',
             type: 'number',
-            default: 5432,
+            "default": 5432
         },
         {
             name: 'database',
             short: 'd',
             description: 'Database name',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'user',
             short: 'u',
             description: 'Database user',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'password',
             description: 'Database password',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'ssl',
             description: 'Enable SSL',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'schema',
             short: 's',
             description: 'Schema name',
             type: 'string',
-            default: 'claude_flow',
+            "default": 'claude_flow'
         },
     ],
     examples: [
@@ -432,236 +497,315 @@ const restoreSubcommand = {
         { command: 'claude-flow ruvector backup restore -i backup.json --clean', description: 'Clean restore' },
         { command: 'claude-flow ruvector backup restore -i backup.sql --dry-run', description: 'Preview restore' },
     ],
-    action: async (ctx) => {
-        const config = getConnectionConfig(ctx);
-        const inputPath = ctx.flags.input;
-        const clean = ctx.flags.clean;
-        const dryRun = ctx.flags['dry-run'];
-        output.writeln();
-        output.writeln(output.bold('RuVector Restore'));
-        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 };
-        }
-        if (!inputPath) {
-            output.printError('Input path is required. Use --input or -i flag.');
-            return { success: false, exitCode: 1 };
-        }
-        const spinner = output.createSpinner({ text: 'Reading backup file...', spinner: 'dots' });
-        spinner.start();
-        try {
-            const fs = await import('fs');
-            const path = await import('path');
-            const { promisify } = await import('util');
-            // Check file exists
-            if (!fs.existsSync(inputPath)) {
-                spinner.fail('Backup file not found');
-                output.printError(`File not found: ${inputPath}`);
-                return { success: false, exitCode: 1 };
-            }
-            // Read file
-            let content;
-            if (inputPath.endsWith('.gz')) {
-                const zlib = await import('zlib');
-                const gunzip = promisify(zlib.gunzip);
-                const compressed = fs.readFileSync(inputPath);
-                const decompressed = await gunzip(compressed);
-                content = decompressed.toString('utf-8');
-            }
-            else {
-                content = fs.readFileSync(inputPath, 'utf-8');
-            }
-            const fileSize = fs.statSync(inputPath).size;
-            spinner.succeed(`Read backup file (${formatBytes(fileSize)})`);
-            // Determine format
-            const isJson = content.trim().startsWith('{');
-            const format = isJson ? 'json' : 'sql';
-            if (dryRun) {
-                output.printInfo('Dry run mode: showing what would be restored');
-                output.writeln();
-                if (isJson) {
-                    const data = JSON.parse(content);
-                    output.writeln(output.highlight('Backup metadata:'));
-                    output.printTable({
-                        columns: [
-                            { key: 'property', header: 'Property', width: 20 },
-                            { key: 'value', header: 'Value', width: 40 },
-                        ],
-                        data: [
-                            { property: 'Backup Date', value: data.metadata?.backupDate || 'Unknown' },
-                            { property: 'Database', value: data.metadata?.database || 'Unknown' },
-                            { property: 'Schema', value: data.schema || 'Unknown' },
-                            { property: 'Tables', value: String(data.tables?.length || 0) },
-                            { property: 'Total Rows', value: String(data.tables?.reduce((sum, t) => sum + t.rows.length, 0) || 0) },
-                            { property: 'Indexes', value: String(data.indexes?.length || 0) },
-                        ],
-                    });
-                }
-                else {
-                    // Count SQL statements
-                    const insertCount = (content.match(/INSERT INTO/gi) || []).length;
-                    const createCount = (content.match(/CREATE (TABLE|INDEX)/gi) || []).length;
-                    output.writeln(`SQL statements: ${insertCount} inserts, ${createCount} creates`);
-                }
-                return { success: true, data: { dryRun: true } };
-            }
-            // Confirm clean operation
-            if (clean && ctx.interactive) {
-                const confirmClean = await confirm({
-                    message: 'This will drop existing tables. Continue?',
-                    default: false,
-                });
-                if (!confirmClean) {
-                    output.printInfo('Restore cancelled');
-                    return { success: false, exitCode: 0 };
-                }
-            }
-            // Connect and restore
-            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');
-            // Clean if requested
-            if (clean) {
-                spinner.setText(`Dropping schema "${config.schema}"...`);
-                spinner.start();
-                await client.query(`DROP SCHEMA IF EXISTS ${config.schema} CASCADE`);
-                await client.query(`CREATE SCHEMA ${config.schema}`);
-                spinner.succeed('Schema cleaned');
-            }
-            // Restore
-            let restoredRows = 0;
-            let restoredTables = 0;
-            let restoredIndexes = 0;
-            if (isJson) {
-                // Restore from JSON
-                const data = JSON.parse(content);
-                for (const table of data.tables || []) {
-                    spinner.setText(`Restoring ${table.name}...`);
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var config, inputPath, clean, dryRun, spinner, fs, path, promisify, content, zlib, gunzip, compressed, decompressed, fileSize, isJson, format, data, insertCount, createCount, confirmClean, pg, _a, client, restoredRows, restoredTables, restoredIndexes, data, _i, _b, table, _loop_3, _c, _d, row, _e, _f, indexDef, _g, statements, executed, _h, statements_1, stmt, error_2, error_3;
+        var _j, _k, _l, _m, _o;
+        return __generator(this, function (_p) {
+            switch (_p.label) {
+                case 0:
+                    config = getConnectionConfig(ctx);
+                    inputPath = ctx.flags.input;
+                    clean = ctx.flags.clean;
+                    dryRun = ctx.flags['dry-run'];
+                    output.writeln();
+                    output.writeln(output.bold('RuVector Restore'));
+                    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 }];
+                    }
+                    if (!inputPath) {
+                        output.printError('Input path is required. Use --input or -i flag.');
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    spinner = output.createSpinner({ text: 'Reading backup file...', spinner: 'dots' });
                     spinner.start();
-                    // Create table if needed (assuming schema matches)
-                    for (const row of table.rows) {
-                        const columns = Object.keys(row);
-                        const values = columns.map((col, idx) => `$${idx + 1}`);
-                        const params = columns.map(col => {
-                            const val = row[col];
-                            return typeof val === 'object' ? JSON.stringify(val) : val;
-                        });
-                        try {
-                            await client.query(`
-                INSERT INTO ${config.schema}.${table.name} (${columns.join(', ')})
-                VALUES (${values.join(', ')})
-                ON CONFLICT DO NOTHING
-              `, params);
-                            restoredRows++;
+                    _p.label = 1;
+                case 1:
+                    _p.trys.push([1, 43, , 44]);
+                    return [4 /*yield*/, import('fs')];
+                case 2:
+                    fs = _p.sent();
+                    return [4 /*yield*/, import('path')];
+                case 3:
+                    path = _p.sent();
+                    return [4 /*yield*/, import('util')];
+                case 4:
+                    promisify = (_p.sent()).promisify;
+                    // Check file exists
+                    if (!fs.existsSync(inputPath)) {
+                        spinner.fail('Backup file not found');
+                        output.printError("File not found: " + inputPath);
+                        return [2 /*return*/, { success: false, exitCode: 1 }];
+                    }
+                    content = void 0;
+                    if (!inputPath.endsWith('.gz')) return [3 /*break*/, 7];
+                    return [4 /*yield*/, import('zlib')];
+                case 5:
+                    zlib = _p.sent();
+                    gunzip = promisify(zlib.gunzip);
+                    compressed = fs.readFileSync(inputPath);
+                    return [4 /*yield*/, gunzip(compressed)];
+                case 6:
+                    decompressed = _p.sent();
+                    content = decompressed.toString('utf-8');
+                    return [3 /*break*/, 8];
+                case 7:
+                    content = fs.readFileSync(inputPath, 'utf-8');
+                    _p.label = 8;
+                case 8:
+                    fileSize = fs.statSync(inputPath).size;
+                    spinner.succeed("Read backup file (" + formatBytes(fileSize) + ")");
+                    isJson = content.trim().startsWith('{');
+                    format = isJson ? 'json' : 'sql';
+                    if (dryRun) {
+                        output.printInfo('Dry run mode: showing what would be restored');
+                        output.writeln();
+                        if (isJson) {
+                            data = JSON.parse(content);
+                            output.writeln(output.highlight('Backup metadata:'));
+                            output.printTable({
+                                columns: [
+                                    { key: 'property', header: 'Property', width: 20 },
+                                    { key: 'value', header: 'Value', width: 40 },
+                                ],
+                                data: [
+                                    { property: 'Backup Date', value: ((_j = data.metadata) === null || _j === void 0 ? void 0 : _j.backupDate) || 'Unknown' },
+                                    { property: 'Database', value: ((_k = data.metadata) === null || _k === void 0 ? void 0 : _k.database) || 'Unknown' },
+                                    { property: 'Schema', value: data.schema || 'Unknown' },
+                                    { property: 'Tables', value: String(((_l = data.tables) === null || _l === void 0 ? void 0 : _l.length) || 0) },
+                                    { property: 'Total Rows', value: String(((_m = data.tables) === null || _m === void 0 ? void 0 : _m.reduce(function (sum, t) { return sum + t.rows.length; }, 0)) || 0) },
+                                    { property: 'Indexes', value: String(((_o = data.indexes) === null || _o === void 0 ? void 0 : _o.length) || 0) },
+                                ]
+                            });
                         }
-                        catch {
-                            // Skip conflicts
+                        else {
+                            insertCount = (content.match(/INSERT INTO/gi) || []).length;
+                            createCount = (content.match(/CREATE (TABLE|INDEX)/gi) || []).length;
+                            output.writeln("SQL statements: " + insertCount + " inserts, " + createCount + " creates");
                         }
+                        return [2 /*return*/, { success: true, data: { dryRun: true } }];
                     }
+                    if (!(clean && ctx.interactive)) return [3 /*break*/, 10];
+                    return [4 /*yield*/, confirm({
+                            message: 'This will drop existing tables. Continue?',
+                            "default": false
+                        })];
+                case 9:
+                    confirmClean = _p.sent();
+                    if (!confirmClean) {
+                        output.printInfo('Restore cancelled');
+                        return [2 /*return*/, { success: false, exitCode: 0 }];
+                    }
+                    _p.label = 10;
+                case 10:
+                    pg = null;
+                    _p.label = 11;
+                case 11:
+                    _p.trys.push([11, 13, , 14]);
+                    return [4 /*yield*/, import('pg')];
+                case 12:
+                    pg = _p.sent();
+                    return [3 /*break*/, 14];
+                case 13:
+                    _a = _p.sent();
+                    spinner.fail('PostgreSQL driver not found');
+                    output.printError('Install pg package: npm install pg');
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 14:
+                    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 15:
+                    _p.sent();
+                    spinner.succeed('Connected to PostgreSQL');
+                    if (!clean) return [3 /*break*/, 18];
+                    spinner.setText("Dropping schema \"" + config.schema + "\"...");
+                    spinner.start();
+                    return [4 /*yield*/, client.query("DROP SCHEMA IF EXISTS " + config.schema + " CASCADE")];
+                case 16:
+                    _p.sent();
+                    return [4 /*yield*/, client.query("CREATE SCHEMA " + config.schema)];
+                case 17:
+                    _p.sent();
+                    spinner.succeed('Schema cleaned');
+                    _p.label = 18;
+                case 18:
+                    restoredRows = 0;
+                    restoredTables = 0;
+                    restoredIndexes = 0;
+                    if (!isJson) return [3 /*break*/, 33];
+                    data = JSON.parse(content);
+                    _i = 0, _b = data.tables || [];
+                    _p.label = 19;
+                case 19:
+                    if (!(_i < _b.length)) return [3 /*break*/, 25];
+                    table = _b[_i];
+                    spinner.setText("Restoring " + table.name + "...");
+                    spinner.start();
+                    _loop_3 = function (row) {
+                        var columns, values, params, _q;
+                        return __generator(this, function (_r) {
+                            switch (_r.label) {
+                                case 0:
+                                    columns = Object.keys(row);
+                                    values = columns.map(function (col, idx) { return "$" + (idx + 1); });
+                                    params = columns.map(function (col) {
+                                        var val = row[col];
+                                        return typeof val === 'object' ? JSON.stringify(val) : val;
+                                    });
+                                    _r.label = 1;
+                                case 1:
+                                    _r.trys.push([1, 3, , 4]);
+                                    return [4 /*yield*/, client.query("\n                INSERT INTO " + config.schema + "." + table.name + " (" + columns.join(', ') + ")\n                VALUES (" + values.join(', ') + ")\n                ON CONFLICT DO NOTHING\n              ", params)];
+                                case 2:
+                                    _r.sent();
+                                    restoredRows++;
+                                    return [3 /*break*/, 4];
+                                case 3:
+                                    _q = _r.sent();
+                                    return [3 /*break*/, 4];
+                                case 4: return [2 /*return*/];
+                            }
+                        });
+                    };
+                    _c = 0, _d = table.rows;
+                    _p.label = 20;
+                case 20:
+                    if (!(_c < _d.length)) return [3 /*break*/, 23];
+                    row = _d[_c];
+                    return [5 /*yield**/, _loop_3(row)];
+                case 21:
+                    _p.sent();
+                    _p.label = 22;
+                case 22:
+                    _c++;
+                    return [3 /*break*/, 20];
+                case 23:
                     restoredTables++;
-                    spinner.setText(`Restoring ${table.name}... (${table.rows.length} rows)`);
-                }
-                spinner.succeed(`Restored ${restoredTables} tables, ${restoredRows} rows`);
-                // Restore indexes
-                if (data.indexes && data.indexes.length > 0) {
+                    spinner.setText("Restoring " + table.name + "... (" + table.rows.length + " rows)");
+                    _p.label = 24;
+                case 24:
+                    _i++;
+                    return [3 /*break*/, 19];
+                case 25:
+                    spinner.succeed("Restored " + restoredTables + " tables, " + restoredRows + " rows");
+                    if (!(data.indexes && data.indexes.length > 0)) return [3 /*break*/, 32];
                     spinner.setText('Restoring indexes...');
                     spinner.start();
-                    for (const indexDef of data.indexes) {
-                        try {
-                            await client.query(indexDef);
-                            restoredIndexes++;
-                        }
-                        catch {
-                            // Index may already exist
-                        }
+                    _e = 0, _f = data.indexes;
+                    _p.label = 26;
+                case 26:
+                    if (!(_e < _f.length)) return [3 /*break*/, 31];
+                    indexDef = _f[_e];
+                    _p.label = 27;
+                case 27:
+                    _p.trys.push([27, 29, , 30]);
+                    return [4 /*yield*/, client.query(indexDef)];
+                case 28:
+                    _p.sent();
+                    restoredIndexes++;
+                    return [3 /*break*/, 30];
+                case 29:
+                    _g = _p.sent();
+                    return [3 /*break*/, 30];
+                case 30:
+                    _e++;
+                    return [3 /*break*/, 26];
+                case 31:
+                    spinner.succeed("Restored " + restoredIndexes + " indexes");
+                    _p.label = 32;
+                case 32: return [3 /*break*/, 41];
+                case 33:
+                    // Restore from SQL
+                    spinner.setText('Executing SQL restore...');
+                    spinner.start();
+                    statements = content
+                        .split(';')
+                        .map(function (s) { return s.trim(); })
+                        .filter(function (s) { return s.length > 0 && !s.startsWith('--'); });
+                    executed = 0;
+                    _h = 0, statements_1 = statements;
+                    _p.label = 34;
+                case 34:
+                    if (!(_h < statements_1.length)) return [3 /*break*/, 40];
+                    stmt = statements_1[_h];
+                    _p.label = 35;
+                case 35:
+                    _p.trys.push([35, 37, , 38]);
+                    return [4 /*yield*/, client.query(stmt)];
+                case 36:
+                    _p.sent();
+                    executed++;
+                    if (stmt.toUpperCase().includes('INSERT INTO')) {
+                        restoredRows++;
                     }
-                    spinner.succeed(`Restored ${restoredIndexes} indexes`);
-                }
-            }
-            else {
-                // Restore from SQL
-                spinner.setText('Executing SQL restore...');
-                spinner.start();
-                // Split by semicolons and execute
-                const statements = content
-                    .split(';')
-                    .map(s => s.trim())
-                    .filter(s => s.length > 0 && !s.startsWith('--'));
-                let executed = 0;
-                for (const stmt of statements) {
-                    try {
-                        await client.query(stmt);
-                        executed++;
-                        if (stmt.toUpperCase().includes('INSERT INTO')) {
-                            restoredRows++;
-                        }
-                        else if (stmt.toUpperCase().includes('CREATE INDEX')) {
-                            restoredIndexes++;
-                        }
+                    else if (stmt.toUpperCase().includes('CREATE INDEX')) {
+                        restoredIndexes++;
                     }
-                    catch (error) {
-                        // Log but continue
-                        if (process.env.DEBUG) {
-                            console.error('Statement failed:', stmt.substring(0, 100));
-                        }
+                    return [3 /*break*/, 38];
+                case 37:
+                    error_2 = _p.sent();
+                    // Log but continue
+                    if (process.env.DEBUG) {
+                        console.error('Statement failed:', stmt.substring(0, 100));
                     }
+                    return [3 /*break*/, 38];
+                case 38:
                     if (executed % 100 === 0) {
-                        spinner.setText(`Executing SQL restore... ${executed}/${statements.length}`);
+                        spinner.setText("Executing SQL restore... " + executed + "/" + statements.length);
                     }
-                }
-                spinner.succeed(`Executed ${executed} SQL statements`);
+                    _p.label = 39;
+                case 39:
+                    _h++;
+                    return [3 /*break*/, 34];
+                case 40:
+                    spinner.succeed("Executed " + executed + " SQL statements");
+                    _p.label = 41;
+                case 41: return [4 /*yield*/, client.end()];
+                case 42:
+                    _p.sent();
+                    output.writeln();
+                    output.printSuccess('Restore completed successfully!');
+                    output.writeln();
+                    output.printBox([
+                        "Source: " + inputPath,
+                        "Format: " + format.toUpperCase(),
+                        "Tables Restored: " + restoredTables,
+                        "Rows Restored: " + restoredRows.toLocaleString(),
+                        "Indexes Restored: " + restoredIndexes,
+                    ].join('\n'), 'Restore Summary');
+                    return [2 /*return*/, {
+                            success: true,
+                            data: {
+                                inputPath: inputPath,
+                                format: format,
+                                restoredTables: restoredTables,
+                                restoredRows: restoredRows,
+                                restoredIndexes: restoredIndexes
+                            }
+                        }];
+                case 43:
+                    error_3 = _p.sent();
+                    spinner.fail('Restore failed');
+                    output.printError(error_3 instanceof Error ? error_3.message : String(error_3));
+                    return [2 /*return*/, { success: false, exitCode: 1 }];
+                case 44: return [2 /*return*/];
             }
-            await client.end();
-            output.writeln();
-            output.printSuccess('Restore completed successfully!');
-            output.writeln();
-            output.printBox([
-                `Source: ${inputPath}`,
-                `Format: ${format.toUpperCase()}`,
-                `Tables Restored: ${restoredTables}`,
-                `Rows Restored: ${restoredRows.toLocaleString()}`,
-                `Indexes Restored: ${restoredIndexes}`,
-            ].join('\n'), 'Restore Summary');
-            return {
-                success: true,
-                data: {
-                    inputPath,
-                    format,
-                    restoredTables,
-                    restoredRows,
-                    restoredIndexes,
-                },
-            };
-        }
-        catch (error) {
-            spinner.fail('Restore failed');
-            output.printError(error instanceof Error ? error.message : String(error));
-            return { success: false, exitCode: 1 };
-        }
-    },
+        });
+    }); }
 };
 /**
  * RuVector backup main command
  */
-export const backupCommand = {
+export var backupCommand = {
     name: 'backup',
     description: 'Backup and restore RuVector data',
     subcommands: [backupSubcommand, restoreSubcommand],
@@ -671,76 +815,78 @@ export const backupCommand = {
             short: 'h',
             description: 'PostgreSQL host',
             type: 'string',
-            default: 'localhost',
+            "default": 'localhost'
         },
         {
             name: 'port',
             short: 'p',
             description: 'PostgreSQL port',
             type: 'number',
-            default: 5432,
+            "default": 5432
         },
         {
             name: 'database',
             short: 'd',
             description: 'Database name',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'user',
             short: 'u',
             description: 'Database user',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'password',
             description: 'Database password',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'ssl',
             description: 'Enable SSL',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'schema',
             short: 's',
             description: 'Schema name',
             type: 'string',
-            default: 'claude_flow',
+            "default": 'claude_flow'
         },
     ],
     examples: [
         { command: 'claude-flow ruvector backup create -o backup.sql', description: 'Create backup' },
         { command: 'claude-flow ruvector backup restore -i backup.sql', description: 'Restore backup' },
     ],
-    action: async (ctx) => {
-        output.writeln();
-        output.writeln(output.bold('RuVector Backup'));
-        output.writeln(output.dim('='.repeat(60)));
-        output.writeln();
-        output.printBox([
-            'RuVector Backup provides data backup and restore capabilities:',
-            '',
-            '  create   Create a backup of RuVector data',
-            '  restore  Restore RuVector data from backup',
-            '',
-            'Supported formats:',
-            '  SQL   - PostgreSQL-compatible SQL statements',
-            '  JSON  - Portable JSON format with metadata',
-            '  CSV   - Comma-separated values',
-            '',
-            'Features:',
-            '  - Selective table backup',
-            '  - Gzip compression',
-            '  - Index preservation',
-            '  - Incremental restore',
-        ].join('\n'), 'Backup Commands');
-        output.writeln();
-        output.printInfo('Run `claude-flow ruvector backup <command> --help` for details');
-        return { success: true };
-    },
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        return __generator(this, function (_a) {
+            output.writeln();
+            output.writeln(output.bold('RuVector Backup'));
+            output.writeln(output.dim('='.repeat(60)));
+            output.writeln();
+            output.printBox([
+                'RuVector Backup provides data backup and restore capabilities:',
+                '',
+                '  create   Create a backup of RuVector data',
+                '  restore  Restore RuVector data from backup',
+                '',
+                'Supported formats:',
+                '  SQL   - PostgreSQL-compatible SQL statements',
+                '  JSON  - Portable JSON format with metadata',
+                '  CSV   - Comma-separated values',
+                '',
+                'Features:',
+                '  - Selective table backup',
+                '  - Gzip compression',
+                '  - Index preservation',
+                '  - Incremental restore',
+            ].join('\n'), 'Backup Commands');
+            output.writeln();
+            output.printInfo('Run `claude-flow ruvector backup <command> --help` for details');
+            return [2 /*return*/, { success: true }];
+        });
+    }); }
 };
 export default backupCommand;
 //# sourceMappingURL=backup.js.map