kynjal-cli 4.0.0 → 4.0.1

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

@@ -2,42 +2,6 @@
  * 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';
 /**
@@ -51,7 +15,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',
     };
 }
 /**
@@ -60,15 +24,15 @@ function getConnectionConfig(ctx) {
 function formatBytes(bytes) {
     if (bytes === 0)
         return '0 B';
-    var k = 1024;
-    var sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
-    var i = Math.floor(Math.log(bytes) / Math.log(k));
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
     return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
 }
 /**
  * RuVector backup subcommand
  */
-var backupSubcommand = {
+const backupSubcommand = {
     name: 'create',
     description: 'Create a backup of RuVector data',
     options: [
@@ -77,78 +41,78 @@ var 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: [
@@ -156,275 +120,246 @@ var 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: 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 + ";");
-                            }
+    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(', ')});`);
                         }
-                        content = lines.join('\n');
+                        lines.push('');
                     }
-                    else if (format === 'json') {
-                        content = JSON.stringify(backupData, null, 2);
+                }
+                // Add indexes
+                if (includeIndexes && backupData.indexes.length > 0) {
+                    lines.push('-- Indexes');
+                    for (const idx of backupData.indexes) {
+                        lines.push(`${idx};`);
                     }
-                    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');
+                }
+                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(','));
                     }
-                    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*/];
+                    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);
             }
-        });
-    }); }
+            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
  */
-var restoreSubcommand = {
+const restoreSubcommand = {
     name: 'restore',
     description: 'Restore RuVector data from backup',
     options: [
@@ -433,63 +368,63 @@ var 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: [
@@ -497,315 +432,236 @@ var 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: 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' });
+    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}...`);
                     spinner.start();
-                    _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) },
-                                ]
-                            });
+                    // 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++;
                         }
-                        else {
-                            insertCount = (content.match(/INSERT INTO/gi) || []).length;
-                            createCount = (content.match(/CREATE (TABLE|INDEX)/gi) || []).length;
-                            output.writeln("SQL statements: " + insertCount + " inserts, " + createCount + " creates");
+                        catch {
+                            // Skip conflicts
                         }
-                        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)");
-                    _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 ${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 indexes...');
                     spinner.start();
-                    _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++;
+                    for (const indexDef of data.indexes) {
+                        try {
+                            await client.query(indexDef);
+                            restoredIndexes++;
+                        }
+                        catch {
+                            // Index may already exist
+                        }
                     }
-                    else if (stmt.toUpperCase().includes('CREATE INDEX')) {
-                        restoredIndexes++;
+                    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++;
+                        }
                     }
-                    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));
+                    catch (error) {
+                        // 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}`);
                     }
-                    _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*/];
+                }
+                spinner.succeed(`Executed ${executed} SQL statements`);
             }
-        });
-    }); }
+            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 var backupCommand = {
+export const backupCommand = {
     name: 'backup',
     description: 'Backup and restore RuVector data',
     subcommands: [backupSubcommand, restoreSubcommand],
@@ -815,78 +671,76 @@ export var 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: 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 }];
-        });
-    }); }
+    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 };
+    },
 };
 export default backupCommand;
 //# sourceMappingURL=backup.js.map