@onurege3467/zerohelper 10.2.5 → 10.2.6

package/dist/bin/commands/import-export.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importCommand = exports.exportCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../utils/config");
+const prompts_1 = require("../utils/prompts");
+exports.exportCommand = new commander_1.Command().name('db');
+exports.exportCommand
+    .command('export')
+    .description('Export table data to file')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .option('-t, --table <name>', 'Table name to export')
+    .option('-f, --format <format>', 'Output format (json|csv)', 'json')
+    .option('-o, --output <file>', 'Output file path')
+    .action(async (options) => {
+    if (!options.table) {
+        console.error(chalk_1.default.red('Error: --table option is required'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)(`Exporting ${options.table}...`).start();
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const records = await db.select(options.table);
+        if (records.length === 0) {
+            spinner.warn(chalk_1.default.yellow(`⚠️  No records found in ${options.table}`));
+            await db.close();
+            return;
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+        const ext = options.format === 'csv' ? 'csv' : 'json';
+        const defaultFile = `${options.table}_export_${timestamp}.${ext}`;
+        const outputFile = options.output || path_1.default.join(process.cwd(), 'exports', defaultFile);
+        const outputDir = path_1.default.dirname(outputFile);
+        if (!fs_1.default.existsSync(outputDir)) {
+            fs_1.default.mkdirSync(outputDir, { recursive: true });
+        }
+        let content = '';
+        if (options.format === 'csv') {
+            const headers = Object.keys(records[0]);
+            const csvRows = [
+                headers.join(','),
+                ...records.map((row) => headers.map(h => {
+                    const val = row[h];
+                    return typeof val === 'string' && val.includes(',') ? `"${val}"` : val;
+                }).join(','))
+            ];
+            content = csvRows.join('\n');
+        }
+        else {
+            content = JSON.stringify(records, null, 2);
+        }
+        fs_1.default.writeFileSync(outputFile, content);
+        const fileSize = fs_1.default.statSync(outputFile).size;
+        spinner.succeed(chalk_1.default.green(`✅ Exported ${records.length} records to ${outputFile}`));
+        console.log(chalk_1.default.gray(`  Size: ${(0, config_1.formatBytes)(fileSize)}`));
+        console.log(chalk_1.default.gray(`  Format: ${options.format.toUpperCase()}`));
+        await db.close();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('❌ Export failed'));
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+});
+exports.importCommand = new commander_1.Command().name('db');
+exports.importCommand
+    .command('import')
+    .description('Import data from file to table')
+    .argument('<file>', 'Input file path')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .option('-t, --table <name>', 'Table name')
+    .option('-f, --format <format>', 'Input format (json|csv)', 'json')
+    .action(async (inputFile, options) => {
+    if (!options.table) {
+        console.error(chalk_1.default.red('Error: --table option is required'));
+        process.exit(1);
+    }
+    if (!fs_1.default.existsSync(inputFile)) {
+        console.error(chalk_1.default.red(`Error: File not found: ${inputFile}`));
+        process.exit(1);
+    }
+    const confirmed = await (0, prompts_1.confirmAction)(chalk_1.default.yellow(`⚠️  This will import data to ${options.table}. Are you sure?`));
+    if (!confirmed) {
+        console.log(chalk_1.default.yellow('Import cancelled'));
+        return;
+    }
+    const spinner = (0, ora_1.default)(`Importing to ${options.table}...`).start();
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const content = fs_1.default.readFileSync(inputFile, 'utf-8');
+        let data = [];
+        if (options.format === 'csv') {
+            const lines = content.trim().split('\n');
+            const headers = lines[0].split(',');
+            data = lines.slice(1).map((line) => {
+                const values = line.split(',');
+                const row = {};
+                headers.forEach((h, i) => {
+                    row[h] = values[i]?.replace(/"/g, '').trim();
+                });
+                return row;
+            });
+        }
+        else {
+            data = JSON.parse(content);
+        }
+        const count = await db.bulkInsert(options.table, data);
+        spinner.succeed(chalk_1.default.green(`✅ Imported ${count} records to ${options.table}`));
+        await db.close();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('❌ Import failed'));
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+});

package/dist/bin/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const initCommand: Command;

package/dist/bin/commands/init.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const package_json_1 = require("../../package.json");
+const prompts_1 = require("../utils/prompts");
+exports.initCommand = new commander_1.Command().name('init');
+exports.initCommand
+    .description('Initialize ZeroHelper in your project (Interactive)')
+    .action(async () => {
+    console.log(chalk_1.default.bold.blue(`\n🚀 Welcome to ZeroHelper v${package_json_1.version} Setup\n`));
+    try {
+        const answers = await (0, prompts_1.getInitAnswers)();
+        const extraPrompts = await (0, prompts_1.getFilePathPrompts)(answers.adapter, answers.enableCache, answers.cacheType);
+        const extraAnswers = await inquirer_1.default.prompt(extraPrompts);
+        const finalAnswers = { ...answers, ...extraAnswers };
+        const configObject = buildConfig(finalAnswers);
+        const configTemplate = formatConfigTemplate(finalAnswers, configObject);
+        fs_1.default.writeFileSync(path_1.default.join(process.cwd(), 'zero.config.ts'), configTemplate);
+        console.log(chalk_1.default.green('\n✅ zero.config.ts created successfully!'));
+        console.log(chalk_1.default.gray('\n📝 Usage example:'));
+        console.log(chalk_1.default.yellow(`import { database } from '@onurege3467/zerohelper';`));
+        console.log(chalk_1.default.yellow(`import { zeroConfig } from './zero.config';`));
+        console.log(chalk_1.default.yellow(`const db = database.createDatabase(zeroConfig);`));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+});
+function buildConfig(answers) {
+    if (['json', 'zpack', 'sqlite', 'toon'].includes(answers.adapter)) {
+        return JSON.stringify({
+            adapter: answers.adapter,
+            config: {
+                path: answers.filePath,
+                ...(answers.enableCache && {
+                    cache: {
+                        type: answers.cacheType || 'memory',
+                        ...(answers.cacheType === 'memory' && answers.cacheTtl && { ttl: answers.cacheTtl * 1000 })
+                    }
+                })
+            }
+        }, null, 2);
+    }
+    const config = {
+        adapter: answers.adapter,
+        config: {
+            host: answers.host,
+            port: answers.port,
+            ...(answers.username && { username: answers.username }),
+            ...(answers.password && { password: answers.password }),
+            database: answers.database,
+            ...(answers.adapter === 'mongodb' && { url: `mongodb://${answers.host}:${answers.port}/${answers.database}` })
+        }
+    };
+    if (answers.enableCache && answers.cacheType) {
+        config.config.cache = {
+            type: answers.cacheType
+        };
+        if (answers.cacheType === 'redis') {
+            config.config.cache.host = answers.host;
+            config.config.cache.port = 6379;
+        }
+        else if (answers.cacheTtl) {
+            config.config.cache.ttl = answers.cacheTtl * 1000;
+        }
+    }
+    return JSON.stringify(config, null, 2);
+}
+function formatConfigTemplate(answers, configObject) {
+    return `/**
+ * ZeroHelper Configuration
+ * Generated on ${new Date().toLocaleDateString()}
+ */
+export const zeroConfig = ${configObject};
+`;
+}
+const inquirer_1 = __importDefault(require("inquirer"));

package/dist/bin/commands/migrate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare const migrateCommand: Command;
+export declare const makeMigrationCommand: Command;

package/dist/bin/commands/migrate.js

@@ -0,0 +1,167 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMigrationCommand = exports.migrateCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const database = __importStar(require("../../database"));
+const config_1 = require("../utils/config");
+const prompts_1 = require("../utils/prompts");
+exports.migrateCommand = new commander_1.Command().name('migration');
+exports.migrateCommand
+    .command('migrate')
+    .description('Run pending migrations')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .option('-d, --migrations-dir <path>', 'Migrations directory path', './migrations')
+    .action(async (options) => {
+    const spinner = (0, ora_1.default)('Loading migrations...').start();
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const migration = new database.MigrationManager(db, {
+            migrationsDir: options.migrationsDir
+        });
+        const pending = await migration.getPendingMigrations();
+        if (pending.length === 0) {
+            spinner.succeed(chalk_1.default.green('✅ No pending migrations'));
+            await db.close();
+            return;
+        }
+        spinner.text = `Running ${pending.length} migration(s)...`;
+        for (const m of pending) {
+            await migration.runMigration(m, 'up');
+            spinner.text = `✅ ${m.name}`;
+        }
+        spinner.succeed(chalk_1.default.green(`✅ ${pending.length} migration(s) executed successfully`));
+        await db.close();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('❌ Migration failed'));
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+});
+exports.migrateCommand
+    .command('rollback')
+    .description('Rollback the last migration(s)')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .option('-d, --migrations-dir <path>', 'Migrations directory path', './migrations')
+    .option('-s, --steps <number>', 'Number of migrations to rollback', '1')
+    .action(async (options) => {
+    const steps = parseInt(options.steps);
+    const confirmed = await (0, prompts_1.confirmAction)(chalk_1.default.yellow(`⚠️  Are you sure you want to rollback ${steps} migration(s)?`));
+    if (!confirmed) {
+        console.log(chalk_1.default.yellow('Rollback cancelled'));
+        return;
+    }
+    const spinner = (0, ora_1.default)(`Rolling back ${steps} migration(s)...`).start();
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const migration = new database.MigrationManager(db, {
+            migrationsDir: options.migrationsDir
+        });
+        await migration.rollback(steps);
+        spinner.succeed(chalk_1.default.green(`✅ Rolled back ${steps} migration(s)`));
+        await db.close();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('❌ Rollback failed'));
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+});
+exports.migrateCommand
+    .command('status')
+    .description('Show migration status')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .option('-d, --migrations-dir <path>', 'Migrations directory path', './migrations')
+    .action(async (options) => {
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const migration = new database.MigrationManager(db, {
+            migrationsDir: options.migrationsDir
+        });
+        const all = migration.getMigrationFiles();
+        const executed = await migration.getExecutedMigrations();
+        console.log(chalk_1.default.bold('\n📋 Migration Status'));
+        console.log(chalk_1.default.gray('─'.repeat(50)));
+        if (all.length === 0) {
+            console.log(chalk_1.default.yellow('No migrations found'));
+        }
+        else {
+            all.forEach(m => {
+                const isExecuted = executed.includes(m.name);
+                const status = isExecuted ? chalk_1.default.green('✅ Done') : chalk_1.default.yellow('⏳ Pending');
+                console.log(`  ${status}  ${chalk_1.default.white(m.name)}`);
+            });
+            console.log(chalk_1.default.gray('\n' + '─'.repeat(50)));
+            console.log(`  Total: ${all.length} | Executed: ${chalk_1.default.green(executed.length)} | Pending: ${chalk_1.default.yellow(all.length - executed.length)}`);
+        }
+        await db.close();
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});
+exports.makeMigrationCommand = new commander_1.Command().name('make');
+exports.makeMigrationCommand
+    .command('migration')
+    .description('Generate a new migration template')
+    .argument('<name>', 'Name of the migration')
+    .option('-d, --migrations-dir <path>', 'Migrations directory path', './migrations')
+    .action((name, options) => {
+    const timestamp = Date.now();
+    const fileName = `${timestamp}_${name}.ts`;
+    const migrationsDir = path_1.default.join(process.cwd(), options.migrationsDir);
+    if (!fs_1.default.existsSync(migrationsDir)) {
+        fs_1.default.mkdirSync(migrationsDir, { recursive: true });
+    }
+    const template = `export const up = async (db: any) => {
+  // Write your migration logic here
+};
+
+export const down = async (db: any) => {
+  // Write your rollback logic here
+};
+`;
+    fs_1.default.writeFileSync(path_1.default.join(migrationsDir, fileName), template);
+    console.log(chalk_1.default.green(`\n✅ Migration created: ./${options.migrationsDir}/${fileName}`));
+});

package/dist/bin/commands/repl.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const replCommand: Command;

package/dist/bin/commands/repl.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../utils/config");
+exports.replCommand = new commander_1.Command().name('repl');
+exports.replCommand
+    .description('Interactive ZeroHelper REPL mode')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .action(async (options) => {
+    console.log(chalk_1.default.bold.cyan('\n🔧 ZeroHelper REPL Mode\n'));
+    console.log(chalk_1.default.gray('Type .exit to quit, .help for commands\n'));
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const readline = require('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: chalk_1.default.blue('zero> ')
+        });
+        rl.prompt();
+        rl.on('line', async (line) => {
+            const cmd = line.trim();
+            if (cmd === '.exit') {
+                await db.close();
+                rl.close();
+                console.log(chalk_1.default.green('\n👋 Goodbye!\n'));
+                process.exit(0);
+            }
+            else if (cmd === '.help') {
+                console.log(chalk_1.default.bold('\nAvailable REPL Commands:'));
+                console.log('  .exit              Exit REPL');
+                console.log('  .help              Show this help');
+                console.log('  .stats              Show database stats');
+                console.log('  .metrics            Show performance metrics');
+                console.log('  select <table>      Select all from table');
+                console.log('  count <table>       Count records in table');
+                console.log('  clear               Clear screen\n');
+            }
+            else if (cmd === '.stats') {
+                const metrics = db.getMetrics();
+                console.log(chalk_1.default.bold('\n📊 Database Stats:'));
+                console.log(`  Operations: ${metrics.database.count || 0}`);
+                console.log(`  Avg Latency: ${(metrics.database.averageDuration || 0).toFixed(2)}ms\n`);
+            }
+            else if (cmd === '.metrics') {
+                const metrics = db.getMetrics();
+                console.log(chalk_1.default.bold('\n📊 Full Metrics:'));
+                console.log(JSON.stringify(metrics, null, 2));
+                console.log('');
+            }
+            else if (cmd === '.clear') {
+                console.clear();
+            }
+            else if (cmd.startsWith('select ')) {
+                const table = cmd.replace('select ', '').trim();
+                try {
+                    const records = await db.select(table);
+                    console.log(chalk_1.default.bold(`\nFound ${records.length} records in ${table}:`));
+                    console.log(JSON.stringify(records, null, 2));
+                    console.log('');
+                }
+                catch (err) {
+                    console.error(chalk_1.default.red(`Error: ${err.message}\n`));
+                }
+            }
+            else if (cmd.startsWith('count ')) {
+                const table = cmd.replace('count ', '').trim();
+                try {
+                    const records = await db.select(table);
+                    console.log(chalk_1.default.bold(`\n${table}: ${records.length} records\n`));
+                }
+                catch (err) {
+                    console.error(chalk_1.default.red(`Error: ${err.message}\n`));
+                }
+            }
+            else if (cmd.length > 0) {
+                console.log(chalk_1.default.yellow('Unknown command. Type .help for available commands\n'));
+            }
+            rl.prompt();
+        });
+        rl.on('close', () => {
+            db.close();
+            console.log(chalk_1.default.green('\n👋 Goodbye!\n'));
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/bin/commands/seed.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const seedCommand: Command;

package/dist/bin/commands/seed.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seedCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const database = __importStar(require("../../database"));
+const config_1 = require("../utils/config");
+exports.seedCommand = new commander_1.Command().name('db');
+exports.seedCommand
+    .command('seed')
+    .description('Seed table with mock data')
+    .option('-c, --config <path>', 'Path to config file', 'zero.config.ts')
+    .option('-t, --table <name>', 'Table name')
+    .option('-n, --count <number>', 'Number of records', '10')
+    .action(async (options) => {
+    if (!options.table) {
+        console.error(chalk_1.default.red('Error: --table option is required'));
+        process.exit(1);
+    }
+    const spinner = (0, ora_1.default)(`Seeding ${options.table}...`).start();
+    try {
+        const db = await (0, config_1.getDatabase)(options.config);
+        const seeder = new database.DataSeeder(db);
+        const schema = {};
+        const fieldTypes = ['string', 'number', 'email', 'boolean', 'date'];
+        for (let i = 0; i < 3; i++) {
+            const fieldType = fieldTypes[Math.floor(Math.random() * fieldTypes.length)];
+            schema[`field_${i + 1}`] = { type: fieldType };
+        }
+        const count = await seeder.seed(options.table, parseInt(options.count), schema);
+        spinner.succeed(chalk_1.default.green(`✅ Seeded ${count} records into ${options.table}`));
+        await db.close();
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red('❌ Seeding failed'));
+        console.error(chalk_1.default.red(error.message));
+        process.exit(1);
+    }
+});

package/dist/bin/commands/zpack.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const zpackCommand: Command;

package/dist/bin/commands/zpack.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zpackCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = __importDefault(require("fs"));
+const config_1 = require("../utils/config");
+const config_2 = require("../utils/config");
+exports.zpackCommand = new commander_1.Command().name('zpack');
+exports.zpackCommand
+    .command('vacuum')
+    .description('Compact a ZPack binary file to save disk space')
+    .argument('<file>', 'ZPack file path')
+    .action(async (file) => {
+    const spinner = (0, ora_1.default)(`Vacuuming ${file}...`).start();
+    const startSize = fs_1.default.existsSync(file) ? fs_1.default.statSync(file).size : 0;
+    try {
+        const db = await (0, config_1.getDatabase)('zero.config.ts');
+        await db.vacuum();
+        await db.close();
+        const endSize = fs_1.default.statSync(file).size;
+        const reduction = startSize > 0 ? ((1 - endSize / startSize) * 100) : 0;
+        spinner.succeed(chalk_1.default.green(`✅ Vacuum complete for ${file}`));
+        console.log(chalk_1.default.gray(`  Original Size: ${(0, config_2.formatBytes)(startSize)}`));
+        console.log(chalk_1.default.gray(`  New Size:      ${(0, config_2.formatBytes)(endSize)}`));
+        console.log(chalk_1.default.bold.blue(`  Efficiency:    ${reduction.toFixed(1)}% reduction`));
+    }
+    catch (error) {
+        spinner.fail(chalk_1.default.red(`❌ Vacuum failed: ${error.message}`));
+        process.exit(1);
+    }
+});

package/dist/bin/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/index.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const package_json_1 = require("../package.json");
+const init_1 = require("./commands/init");
+const db_1 = require("./commands/db");
+const cache_1 = require("./commands/cache");
+const migrate_1 = require("./commands/migrate");
+const zpack_1 = require("./commands/zpack");
+const repl_1 = require("./commands/repl");
+const program = new commander_1.Command();
+program
+    .name('zero')
+    .description(chalk_1.default.cyan('ZeroHelper CLI - Elite Database Management Tool'))
+    .version(package_json_1.version);
+program.addCommand(init_1.initCommand);
+program.addCommand(db_1.dbCommand);
+program.addCommand(cache_1.cacheCommand);
+program.addCommand(migrate_1.migrateCommand);
+program.addCommand(migrate_1.makeMigrationCommand);
+program.addCommand(zpack_1.zpackCommand);
+program.addCommand(repl_1.replCommand);
+program.parse();

package/dist/bin/types.d.ts

@@ -0,0 +1,22 @@
+export interface CLIOptions {
+    config: string;
+}
+export interface DBOptions extends CLIOptions {
+    table?: string;
+    count?: number;
+    format?: string;
+    output?: string;
+}
+export interface MigrationOptions extends CLIOptions {
+    migrationsDir: string;
+    steps?: number;
+}
+export interface ImportOptions extends CLIOptions {
+    table: string;
+    format: string;
+}
+export interface ExportOptions extends CLIOptions {
+    table: string;
+    format: string;
+    output: string;
+}

package/dist/bin/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });