relq 1.0.0

package/dist/cjs/cli/commands/export.cjs

@@ -0,0 +1,333 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportCommand = exportCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const schema_introspect_1 = require("../utils/schema-introspect.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+const change_tracker_1 = require("../utils/change-tracker.cjs");
+const sql_generator_1 = require("../utils/sql-generator.cjs");
+async function exportCommand(context) {
+    const spinner = (0, spinner_1.createSpinner)();
+    const { args, flags } = context;
+    const projectRoot = process.cwd();
+    const changesOnly = Boolean(flags['changes']);
+    const stagedOnly = Boolean(flags['staged']);
+    const fromDb = Boolean(flags['db']);
+    if (changesOnly || stagedOnly) {
+        return exportChanges(projectRoot, flags, args, stagedOnly);
+    }
+    const outputPath = flags.output || args[0] || './schema-export.sql';
+    const absoluteOutputPath = path.resolve(outputPath);
+    const options = {
+        output: outputPath,
+        includeData: Boolean(flags['include-data']),
+        includeFunctions: Boolean(flags['include-functions']),
+        includeTriggers: Boolean(flags['include-triggers']),
+        fromDb,
+    };
+    if (fromDb) {
+        return exportFromDatabase(context, absoluteOutputPath, options);
+    }
+    return exportFromSnapshot(projectRoot, absoluteOutputPath, options);
+}
+async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
+    const spinner = (0, spinner_1.createSpinner)();
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('error:')} relq not initialized`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('first, or use')} ${spinner_1.colors.cyan('relq import')} ${spinner_1.colors.muted('to import a schema.')}`);
+        return;
+    }
+    spinner.start('Loading snapshot');
+    const snapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+    if (!snapshot) {
+        spinner.fail('No snapshot found');
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq import <file.sql>')} ${spinner_1.colors.muted('to import a schema first.')}`);
+        return;
+    }
+    spinner.succeed('Loaded snapshot');
+    const schema = normalizedToDbSchema(snapshot);
+    console.log('');
+    console.log(spinner_1.colors.cyan('Schema Summary:'));
+    console.log(`  ${spinner_1.colors.green('•')} Tables: ${schema.tables.length}`);
+    console.log(`  ${spinner_1.colors.green('•')} Enums: ${schema.enums.length}`);
+    console.log(`  ${spinner_1.colors.green('•')} Domains: ${schema.domains.length}`);
+    console.log(`  ${spinner_1.colors.green('•')} Composite Types: ${schema.compositeTypes.length}`);
+    console.log(`  ${spinner_1.colors.green('•')} Sequences: ${schema.sequences?.length || 0}`);
+    console.log(`  ${spinner_1.colors.green('•')} Extensions: ${schema.extensions.length}`);
+    if (snapshot.functions?.length) {
+        console.log(`  ${spinner_1.colors.green('•')} Functions: ${snapshot.functions.length}`);
+    }
+    if (snapshot.triggers?.length) {
+        console.log(`  ${spinner_1.colors.green('•')} Triggers: ${snapshot.triggers.length}`);
+    }
+    spinner.start('Generating SQL statements');
+    const sqlContent = generateFullSQL(schema, options);
+    spinner.succeed('Generated SQL statements');
+    const outputDir = path.dirname(absoluteOutputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
+    spinner.succeed(`Written ${options.output} (${(sqlContent.length / 1024).toFixed(1)} KB)`);
+    console.log('');
+    console.log(spinner_1.colors.green('✓ Export completed!'));
+    console.log(`  Source: ${spinner_1.colors.muted('snapshot (local)')}`);
+    console.log(`  Output: ${spinner_1.colors.muted(options.output || '')}`);
+}
+async function exportFromDatabase(context, absoluteOutputPath, options) {
+    const spinner = (0, spinner_1.createSpinner)();
+    if (!context.config || !context.config.connection) {
+        console.error(spinner_1.colors.red('Error: No database connection configured'));
+        return;
+    }
+    try {
+        spinner.start('Introspecting database schema');
+        const schema = await (0, schema_introspect_1.introspectDatabase)(context.config.connection, undefined, {
+            includeFunctions: options.includeFunctions,
+            includeTriggers: options.includeTriggers,
+        });
+        spinner.succeed(`Introspected ${schema.tables.length} tables, ${schema.enums.length} enums`);
+        console.log('');
+        console.log(spinner_1.colors.cyan('Schema Summary:'));
+        console.log(`  ${spinner_1.colors.green('•')} Tables: ${schema.tables.length}`);
+        console.log(`  ${spinner_1.colors.green('•')} Enums: ${schema.enums.length}`);
+        console.log(`  ${spinner_1.colors.green('•')} Domains: ${schema.domains.length}`);
+        console.log(`  ${spinner_1.colors.green('•')} Composite Types: ${schema.compositeTypes.length}`);
+        console.log(`  ${spinner_1.colors.green('•')} Extensions: ${schema.extensions.length}`);
+        if (options.includeFunctions) {
+            console.log(`  ${spinner_1.colors.green('•')} Functions: ${schema.functions.length}`);
+        }
+        if (options.includeTriggers) {
+            console.log(`  ${spinner_1.colors.green('•')} Triggers: ${schema.triggers.length}`);
+        }
+        spinner.start('Generating SQL statements');
+        const sqlContent = generateFullSQL(schema, options);
+        spinner.succeed('Generated SQL statements');
+        const outputDir = path.dirname(absoluteOutputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
+        spinner.succeed(`Written ${options.output} (${(sqlContent.length / 1024).toFixed(1)} KB)`);
+        console.log('');
+        console.log(spinner_1.colors.green('✓ Export completed!'));
+        console.log(`  Source: ${spinner_1.colors.muted('database (live)')}`);
+        console.log(`  Output: ${spinner_1.colors.muted(options.output || '')}`);
+    }
+    catch (error) {
+        spinner.fail('Export failed');
+        throw error;
+    }
+}
+function normalizedToDbSchema(normalized) {
+    return {
+        tables: normalized.tables.map(t => ({
+            name: t.name,
+            schema: t.schema,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                dataType: c.type,
+                isNullable: c.nullable,
+                defaultValue: c.default,
+                isPrimaryKey: c.primaryKey,
+                isUnique: c.unique,
+                maxLength: null,
+                precision: null,
+                scale: null,
+                references: c.references ? {
+                    table: c.references.table,
+                    column: c.references.column,
+                    onDelete: c.references.onDelete,
+                    onUpdate: c.references.onUpdate,
+                } : null,
+                check: c.check ?? undefined,
+                comment: c.comment ?? undefined,
+                isGenerated: c.isGenerated || false,
+                generationExpression: c.generationExpression ?? null,
+                identityGeneration: c.identity?.type ?? null,
+            })),
+            indexes: t.indexes.map(i => ({
+                name: i.name,
+                columns: i.columns,
+                isUnique: i.unique,
+                isPrimary: i.isPrimary || false,
+                type: i.type || 'btree',
+                definition: i.definition,
+                whereClause: i.whereClause ?? null,
+                expression: i.columnDefs?.find(cd => cd.expression)?.expression ?? null,
+            })),
+            constraints: t.constraints.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: c.columns || [],
+                definition: c.definition || '',
+                referencedTable: c.referencedTable,
+                referencedColumns: c.referencedColumns,
+                checkExpression: c.checkExpression,
+            })),
+            rowCount: 0,
+            isPartitioned: t.isPartitioned || t.partitionType !== undefined,
+            partitionType: t.partitionType,
+            partitionKey: t.partitionKey,
+        })),
+        enums: normalized.enums.map(e => ({
+            name: e.name,
+            values: e.values,
+        })),
+        domains: normalized.domains.map(d => ({
+            name: d.name,
+            baseType: d.baseType,
+            isNotNull: d.notNull,
+            defaultValue: d.default,
+            checkExpression: d.check,
+        })),
+        compositeTypes: normalized.compositeTypes.map(c => ({
+            name: c.name,
+            attributes: c.attributes,
+        })),
+        sequences: normalized.sequences.map(s => ({
+            name: s.name,
+            dataType: s.dataType,
+            start: s.startValue,
+            increment: s.increment,
+            minValue: s.minValue,
+            maxValue: s.maxValue,
+            cache: s.cache,
+            cycle: s.cycle,
+            ownedBy: s.ownedBy || undefined,
+        })),
+        extensions: normalized.extensions.map(e => e.name),
+        functions: (normalized.functions || []).map(f => ({
+            name: f.name,
+            schema: f.schema || 'public',
+            returnType: f.returnType,
+            argTypes: f.argTypes || [],
+            language: f.language,
+            definition: f.body || '',
+            isAggregate: false,
+            volatility: f.volatility || 'VOLATILE',
+        })),
+        triggers: (normalized.triggers || []).map(t => ({
+            name: t.name,
+            tableName: t.table,
+            event: t.events.join(' OR '),
+            timing: t.timing,
+            functionName: t.functionName,
+            definition: '',
+            isEnabled: t.isEnabled !== false,
+        })),
+        partitions: [],
+        policies: [],
+        foreignServers: [],
+        foreignTables: [],
+    };
+}
+async function exportChanges(projectRoot, flags, args, stagedOnly) {
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('error:')} relq not initialized`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('first.')}`);
+        return;
+    }
+    let changes;
+    let modeLabel;
+    if (stagedOnly) {
+        changes = (0, repo_manager_1.getStagedChanges)(projectRoot);
+        modeLabel = 'staged';
+    }
+    else {
+        const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+        const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+        changes = [...staged, ...unstaged];
+        modeLabel = 'uncommitted';
+    }
+    if (changes.length === 0) {
+        console.log(`${spinner_1.colors.yellow('⚠')} No ${modeLabel} changes to export`);
+        console.log('');
+        if (stagedOnly) {
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq add .')} ${spinner_1.colors.muted('to stage changes.')}`);
+        }
+        else {
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq pull')} ${spinner_1.colors.muted('or')} ${spinner_1.colors.cyan('relq import')} ${spinner_1.colors.muted('to detect changes.')}`);
+        }
+        return;
+    }
+    const outputPath = flags.output || args[0] || `./${modeLabel}-changes.sql`;
+    const absoluteOutputPath = path.resolve(outputPath);
+    console.log(`${spinner_1.colors.cyan(`Exporting ${modeLabel} changes:`)} ${changes.length}`);
+    console.log('');
+    for (const change of changes) {
+        const display = (0, change_tracker_1.getChangeDisplayName)(change);
+        const color = change.type === 'CREATE' ? spinner_1.colors.green :
+            change.type === 'DROP' ? spinner_1.colors.red :
+                spinner_1.colors.yellow;
+        console.log(`   ${color(display)}`);
+    }
+    console.log('');
+    const sortedChanges = (0, change_tracker_1.sortChangesByDependency)(changes);
+    const sqlContent = (0, change_tracker_1.generateCombinedSQL)(sortedChanges);
+    const outputDir = path.dirname(absoluteOutputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
+    console.log(`${spinner_1.colors.green('✓')} Exported ${changes.length} ${modeLabel} change(s) to ${outputPath}`);
+    console.log(`${spinner_1.colors.muted(`${(sqlContent.length / 1024).toFixed(1)} KB`)}`);
+    console.log('');
+}
+function generateFullSQL(schema, options) {
+    const header = `-- PostgreSQL Database Schema Export\n-- Generated: ${new Date().toISOString()}\n-- Relq CLI`;
+    return (0, sql_generator_1.generateFullSchemaSQL)(schema, {
+        includeExtensions: true,
+        includeEnums: true,
+        includeDomains: true,
+        includeCompositeTypes: true,
+        includeSequences: true,
+        includeTables: true,
+        includePartitions: true,
+        includeIndexes: true,
+        includeConstraints: true,
+        includeFunctions: options.includeFunctions,
+        includeTriggers: options.includeTriggers,
+        headerComment: header,
+    });
+}
+exports.default = exportCommand;

package/dist/cjs/cli/commands/fetch.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCommand = fetchCommand;
+const config_loader_1 = require("../utils/config-loader.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+async function fetchCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_1.requireValidConfig)(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('to initialize.')}`);
+        return;
+    }
+    const spinner = (0, spinner_1.createSpinner)();
+    spinner.start(`Fetching from ${(0, env_loader_1.getConnectionDescription)(connection)}...`);
+    try {
+        await (0, repo_manager_1.ensureRemoteTable)(connection);
+        const remoteCommits = await (0, repo_manager_1.fetchRemoteCommits)(connection, 100);
+        if (remoteCommits.length === 0) {
+            spinner.succeed('No remote commits found');
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq push')} ${spinner_1.colors.muted('to push your commits.')}`);
+            return;
+        }
+        let newCommits = 0;
+        for (const commit of remoteCommits) {
+            const existing = (0, repo_manager_1.loadCommit)(commit.hash, projectRoot);
+            if (!existing) {
+                (0, repo_manager_1.saveCommit)(commit, projectRoot);
+                newCommits++;
+            }
+        }
+        const latestRemote = remoteCommits[0];
+        (0, repo_manager_1.setFetchHead)(latestRemote.hash, projectRoot);
+        spinner.succeed(`Fetched ${remoteCommits.length} commits (${newCommits} new)`);
+        const localHead = (0, repo_manager_1.getHead)(projectRoot);
+        if (localHead && latestRemote.hash !== localHead) {
+            console.log('');
+            console.log(`${spinner_1.colors.muted('From')} ${(0, env_loader_1.getConnectionDescription)(connection)}`);
+            console.log(`   ${(0, repo_manager_1.shortHash)(localHead)}..${(0, repo_manager_1.shortHash)(latestRemote.hash)}  ${spinner_1.colors.muted('main -> origin/main')}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Fetch failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+    console.log('');
+}

package/dist/cjs/cli/commands/generate.cjs

@@ -0,0 +1,242 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const config_loader_1 = require("../utils/config-loader.cjs");
+const schema_introspect_1 = require("../utils/schema-introspect.cjs");
+const snapshot_manager_1 = require("../utils/snapshot-manager.cjs");
+const schema_diff_1 = require("../utils/schema-diff.cjs");
+const schema_hash_1 = require("../utils/schema-hash.cjs");
+const migration_generator_1 = require("../utils/migration-generator.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+function askConfirm(question, defaultYes = false) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
+    return new Promise((resolve) => {
+        rl.question(`${question} ${suffix}: `, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+function askInput(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function generateCommand(context) {
+    const { config, args, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_1.requireValidConfig)(config);
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
+    const ignorePatterns = config.sync?.ignore || ['_relq_*'];
+    const format = config.migrations?.format || 'sequential';
+    const message = flags['m'] || flags['message'];
+    const autoStage = flags['a'] === true || flags['am'] !== undefined;
+    const isEmpty = flags['empty'] === true;
+    const interactive = flags['interactive'] === true;
+    const noDown = flags['no-down'] === true;
+    const dryRun = flags['dry-run'] === true;
+    let migrationName = args[0] || '';
+    if (flags['am']) {
+        const amMessage = flags['am'];
+        if (typeof amMessage === 'string') {
+            migrationName = amMessage.replace(/\s+/g, '_').toLowerCase();
+        }
+    }
+    if (!migrationName && message) {
+        migrationName = message.replace(/\s+/g, '_').toLowerCase();
+    }
+    if (!migrationName && !isEmpty) {
+        migrationName = await askInput(`${colors.cyan}Migration name:${colors.reset} `);
+        if (!migrationName) {
+            console.error('Error: Migration name is required.');
+            process.exit(1);
+        }
+    }
+    if (isEmpty) {
+        migrationName = migrationName || 'empty';
+        await createEmptyMigration(migrationsDir, migrationName, format, dryRun);
+        return;
+    }
+    console.log(`${colors.bold}Generating migration...${colors.reset}`);
+    console.log(`   Connection: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
+    console.log('');
+    try {
+        const dbSchema = await (0, schema_introspect_1.introspectDatabase)(connection);
+        const snapshot = (0, snapshot_manager_1.loadSnapshot)(snapshotPath);
+        if (!snapshot) {
+            console.log(`${colors.yellow}No snapshot found.${colors.reset}`);
+            console.log(`Run "${colors.cyan}relq pull${colors.reset}" first to create initial snapshot.`);
+            return;
+        }
+        const localSchema = (0, snapshot_manager_1.snapshotToDatabaseSchema)(snapshot);
+        const diff = (0, schema_diff_1.diffSchemas)((0, schema_hash_1.normalizeSchema)(localSchema), (0, schema_hash_1.normalizeSchema)(dbSchema));
+        const filteredDiff = (0, schema_diff_1.filterDiff)(diff, ignorePatterns);
+        if (!filteredDiff.hasChanges) {
+            console.log(`${colors.green}No changes to generate.${colors.reset}`);
+            return;
+        }
+        const s = filteredDiff.summary;
+        console.log(`${colors.bold}Changes to include:${colors.reset}`);
+        if (s.tablesAdded > 0)
+            console.log(`  ${colors.green}+ ${s.tablesAdded} table(s)${colors.reset}`);
+        if (s.tablesRemoved > 0)
+            console.log(`  ${colors.red}- ${s.tablesRemoved} table(s)${colors.reset}`);
+        if (s.tablesModified > 0)
+            console.log(`  ${colors.yellow}~ ${s.tablesModified} table(s) modified${colors.reset}`);
+        if (s.columnsAdded > 0)
+            console.log(`  ${colors.green}+ ${s.columnsAdded} column(s)${colors.reset}`);
+        if (s.columnsRemoved > 0)
+            console.log(`  ${colors.red}- ${s.columnsRemoved} column(s)${colors.reset}`);
+        if (s.columnsModified > 0)
+            console.log(`  ${colors.yellow}~ ${s.columnsModified} column(s)${colors.reset}`);
+        console.log('');
+        if ((0, schema_diff_1.hasDestructiveChanges)(filteredDiff)) {
+            const tables = (0, schema_diff_1.getDestructiveTables)(filteredDiff);
+            console.log(`${colors.red}${colors.bold}⚠️  Destructive changes:${colors.reset}`);
+            for (const t of tables) {
+                console.log(`   ${colors.red}• ${t}${colors.reset}`);
+            }
+            console.log('');
+            if (!autoStage) {
+                const proceed = await askConfirm('Include destructive changes?', false);
+                if (!proceed) {
+                    console.log('Cancelled.');
+                    return;
+                }
+            }
+        }
+        const migrationFile = (0, migration_generator_1.generateMigrationFile)(filteredDiff, migrationName, {
+            includeDown: !noDown,
+            includeComments: true,
+            message: message,
+        });
+        let fileName;
+        if (format === 'timestamp') {
+            fileName = (0, migration_generator_1.generateTimestampedName)(migrationName) + '.sql';
+        }
+        else {
+            const num = (0, migration_generator_1.getNextMigrationNumber)(migrationsDir);
+            fileName = `${num}_${migrationName.replace(/\s+/g, '_').toLowerCase()}.sql`;
+        }
+        const filePath = path.join(migrationsDir, fileName);
+        if (dryRun) {
+            console.log(`${colors.cyan}[dry-run] Would create: ${filePath}${colors.reset}`);
+            console.log('');
+            console.log('--- Generated SQL ---');
+            console.log(migrationFile.content);
+            console.log('--- End ---');
+        }
+        else {
+            if (!fs.existsSync(migrationsDir)) {
+                fs.mkdirSync(migrationsDir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, migrationFile.content, 'utf-8');
+            console.log(`${colors.green}✓ Created:${colors.reset} ${filePath}`);
+            (0, snapshot_manager_1.saveSnapshot)(dbSchema, snapshotPath, connection.database);
+            console.log(`${colors.dim}Updated snapshot.${colors.reset}`);
+        }
+        console.log('');
+        console.log(`${colors.dim}Run "relq push" to apply this migration.${colors.reset}`);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+async function createEmptyMigration(migrationsDir, name, format, dryRun) {
+    let fileName;
+    if (format === 'timestamp') {
+        fileName = (0, migration_generator_1.generateTimestampedName)(name) + '.sql';
+    }
+    else {
+        const num = (0, migration_generator_1.getNextMigrationNumber)(migrationsDir);
+        fileName = `${num}_${name.replace(/\s+/g, '_').toLowerCase()}.sql`;
+    }
+    const filePath = path.join(migrationsDir, fileName);
+    const content = `-- Migration: ${name}
+-- Generated: ${new Date().toISOString()}
+
+-- UP
+-- Add your schema changes here
+
+
+-- DOWN
+-- Add rollback statements here
+
+`;
+    if (dryRun) {
+        console.log(`${colors.cyan}[dry-run] Would create: ${filePath}${colors.reset}`);
+    }
+    else {
+        if (!fs.existsSync(migrationsDir)) {
+            fs.mkdirSync(migrationsDir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, content, 'utf-8');
+        console.log(`${colors.green}✓ Created empty migration:${colors.reset} ${filePath}`);
+    }
+}