relq 1.0.0

package/dist/bin/relq.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../esm/cli/index.js');

package/dist/cjs/cache/index.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTableCache = exports.withCache = exports.createQueryCacheMiddleware = exports.CacheKeyBuilder = exports.QueryCache = void 0;
+var query_cache_1 = require("./query-cache.cjs");
+Object.defineProperty(exports, "QueryCache", { enumerable: true, get: function () { return query_cache_1.QueryCache; } });
+Object.defineProperty(exports, "CacheKeyBuilder", { enumerable: true, get: function () { return query_cache_1.CacheKeyBuilder; } });
+Object.defineProperty(exports, "createQueryCacheMiddleware", { enumerable: true, get: function () { return query_cache_1.createQueryCacheMiddleware; } });
+Object.defineProperty(exports, "withCache", { enumerable: true, get: function () { return query_cache_1.withCache; } });
+Object.defineProperty(exports, "createTableCache", { enumerable: true, get: function () { return query_cache_1.createTableCache; } });

package/dist/cjs/cache/query-cache.cjs

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheKeyBuilder = exports.QueryCache = void 0;
+exports.createQueryCacheMiddleware = createQueryCacheMiddleware;
+exports.withCache = withCache;
+exports.createTableCache = createTableCache;
+class QueryCache {
+    cache = new Map();
+    options;
+    stats = { hits: 0, misses: 0, evictions: 0 };
+    constructor(options = {}) {
+        this.options = {
+            strategy: options.strategy ?? 'lru',
+            maxSize: options.maxSize ?? 100 * 1024 * 1024,
+            maxItems: options.maxItems ?? 1000,
+            ttl: options.ttl ?? 60000,
+            onEvict: options.onEvict ?? (() => { }),
+            keyGenerator: options.keyGenerator ?? this.defaultKeyGenerator
+        };
+    }
+    defaultKeyGenerator(query, params) {
+        const normalized = query.replace(/\s+/g, ' ').trim().toLowerCase();
+        const paramStr = params ? JSON.stringify(params) : '';
+        return `${normalized}::${paramStr}`;
+    }
+    generateKey(query, params) {
+        return this.options.keyGenerator(query, params);
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return undefined;
+        }
+        if (this.options.strategy === 'ttl' || this.options.strategy === 'lru') {
+            const now = Date.now();
+            if (this.options.ttl > 0 && now - entry.createdAt > this.options.ttl) {
+                this.delete(key);
+                this.stats.misses++;
+                return undefined;
+            }
+        }
+        entry.accessedAt = Date.now();
+        entry.accessCount++;
+        this.stats.hits++;
+        if (this.options.strategy === 'lru') {
+            this.cache.delete(key);
+            this.cache.set(key, entry);
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        const size = this.estimateSize(value);
+        this.evictIfNeeded(size);
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            accessedAt: Date.now(),
+            accessCount: 1,
+            size
+        };
+        this.cache.set(key, entry);
+    }
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (this.options.strategy === 'ttl' || this.options.strategy === 'lru') {
+            const now = Date.now();
+            if (this.options.ttl > 0 && now - entry.createdAt > this.options.ttl) {
+                this.delete(key);
+                return false;
+            }
+        }
+        return true;
+    }
+    delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.options.onEvict(key, entry);
+            this.stats.evictions++;
+            return this.cache.delete(key);
+        }
+        return false;
+    }
+    clear() {
+        this.cache.forEach((entry, key) => {
+            this.options.onEvict(key, entry);
+        });
+        this.cache.clear();
+        this.stats.evictions = 0;
+    }
+    invalidateByPattern(pattern) {
+        let count = 0;
+        const keysToDelete = [];
+        this.cache.forEach((_, key) => {
+            if (pattern.test(key)) {
+                keysToDelete.push(key);
+            }
+        });
+        keysToDelete.forEach(key => {
+            this.delete(key);
+            count++;
+        });
+        return count;
+    }
+    invalidateByTable(tableName) {
+        const pattern = new RegExp(`\\b${tableName.toLowerCase()}\\b`, 'i');
+        return this.invalidateByPattern(pattern);
+    }
+    getStats() {
+        const totalSize = Array.from(this.cache.values()).reduce((sum, e) => sum + e.size, 0);
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            evictions: this.stats.evictions,
+            size: totalSize,
+            itemCount: this.cache.size,
+            hitRate: total > 0 ? this.stats.hits / total : 0
+        };
+    }
+    resetStats() {
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+    }
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+    values() {
+        return Array.from(this.cache.values()).map(e => e.value);
+    }
+    entries() {
+        return Array.from(this.cache.entries());
+    }
+    evictIfNeeded(incomingSize) {
+        if (this.options.strategy === 'none')
+            return;
+        while (this.cache.size >= this.options.maxItems) {
+            this.evictOne();
+        }
+        if (this.options.strategy === 'size') {
+            const currentSize = Array.from(this.cache.values()).reduce((sum, e) => sum + e.size, 0);
+            while (currentSize + incomingSize > this.options.maxSize && this.cache.size > 0) {
+                this.evictOne();
+            }
+        }
+    }
+    evictOne() {
+        if (this.cache.size === 0)
+            return;
+        let keyToEvict;
+        let entryToEvict;
+        switch (this.options.strategy) {
+            case 'lru':
+                keyToEvict = this.cache.keys().next().value;
+                break;
+            case 'ttl':
+                let oldestTime = Infinity;
+                this.cache.forEach((entry, key) => {
+                    if (entry.createdAt < oldestTime) {
+                        oldestTime = entry.createdAt;
+                        keyToEvict = key;
+                        entryToEvict = entry;
+                    }
+                });
+                break;
+            case 'size':
+                let largestSize = -1;
+                this.cache.forEach((entry, key) => {
+                    if (entry.size > largestSize) {
+                        largestSize = entry.size;
+                        keyToEvict = key;
+                        entryToEvict = entry;
+                    }
+                });
+                break;
+            default:
+                keyToEvict = this.cache.keys().next().value;
+        }
+        if (keyToEvict) {
+            this.delete(keyToEvict);
+        }
+    }
+    estimateSize(value) {
+        if (value === null || value === undefined)
+            return 8;
+        if (typeof value === 'boolean')
+            return 4;
+        if (typeof value === 'number')
+            return 8;
+        if (typeof value === 'string')
+            return value.length * 2;
+        if (Array.isArray(value)) {
+            return value.reduce((sum, item) => sum + this.estimateSize(item), 16);
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value).length * 2;
+        }
+        return 64;
+    }
+}
+exports.QueryCache = QueryCache;
+class CacheKeyBuilder {
+    parts = [];
+    table(name) {
+        this.parts.push(`t:${name}`);
+        return this;
+    }
+    operation(op) {
+        this.parts.push(`o:${op}`);
+        return this;
+    }
+    columns(...cols) {
+        if (cols.length > 0) {
+            this.parts.push(`c:${cols.sort().join(',')}`);
+        }
+        return this;
+    }
+    where(condition) {
+        this.parts.push(`w:${condition}`);
+        return this;
+    }
+    orderBy(order) {
+        this.parts.push(`ob:${order}`);
+        return this;
+    }
+    limit(n) {
+        this.parts.push(`l:${n}`);
+        return this;
+    }
+    offset(n) {
+        this.parts.push(`of:${n}`);
+        return this;
+    }
+    params(...values) {
+        if (values.length > 0) {
+            this.parts.push(`p:${JSON.stringify(values)}`);
+        }
+        return this;
+    }
+    custom(key, value) {
+        this.parts.push(`${key}:${value}`);
+        return this;
+    }
+    build() {
+        return this.parts.join('|');
+    }
+    static from(query, params) {
+        const normalized = query.replace(/\s+/g, ' ').trim();
+        const hash = this.simpleHash(normalized + (params ? JSON.stringify(params) : ''));
+        return `q:${hash}`;
+    }
+    static simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+}
+exports.CacheKeyBuilder = CacheKeyBuilder;
+function createQueryCacheMiddleware(options) {
+    const { cache, keyPrefix = '', invalidateOn = [] } = options;
+    return {
+        beforeQuery: (query, params) => {
+            const key = keyPrefix + CacheKeyBuilder.from(query, params);
+            const cached = cache.get(key);
+            if (cached !== undefined) {
+                return { cached: true, value: cached, key };
+            }
+            return { cached: false, key };
+        },
+        afterQuery: (key, result) => {
+            cache.set(key, result);
+        },
+        afterMutation: (tableName) => {
+            cache.invalidateByTable(tableName);
+            invalidateOn.forEach(pattern => {
+                if (pattern.includes(tableName)) {
+                    cache.invalidateByPattern(new RegExp(pattern, 'i'));
+                }
+            });
+        }
+    };
+}
+function withCache(cache, key, fn, ttl) {
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    if (result instanceof Promise) {
+        return result.then(value => {
+            cache.set(key, value);
+            return value;
+        });
+    }
+    cache.set(key, result);
+    return result;
+}
+function createTableCache(tableName, options = {}) {
+    const cache = new QueryCache({
+        ...options,
+        keyGenerator: (query, params) => {
+            return `${tableName}::${query.replace(/\s+/g, ' ').trim()}::${params ? JSON.stringify(params) : ''}`;
+        }
+    });
+    return Object.assign(cache, { table: tableName });
+}

package/dist/cjs/cli/commands/add.cjs

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addCommand = addCommand;
+exports.getRelatedChanges = getRelatedChanges;
+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");
+async function addCommand(context) {
+    const { args } = context;
+    const projectRoot = process.cwd();
+    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;
+    }
+    const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    if (unstaged.length === 0) {
+        if (staged.length > 0) {
+            console.log(`${spinner_1.colors.green('✓')} All changes are already staged`);
+            console.log(`${spinner_1.colors.muted(`${staged.length} change(s) ready to commit`)}`);
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to commit.')}`);
+        }
+        else {
+            console.log(`${spinner_1.colors.green('✓')} No changes to stage`);
+            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.')}`);
+        }
+        console.log('');
+        return;
+    }
+    const patterns = args.length > 0 ? args : ['.'];
+    const addAll = patterns.includes('.') || patterns.includes('*');
+    console.log(`${spinner_1.colors.cyan('Unstaged changes:')} ${unstaged.length}`);
+    console.log('');
+    for (const change of unstaged) {
+        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 stagedNow = (0, repo_manager_1.stageChanges)(patterns, projectRoot);
+    if (stagedNow.length === 0) {
+        console.log(`${spinner_1.colors.yellow('⚠')} No changes matched the pattern(s): ${patterns.join(', ')}`);
+        console.log('');
+        return;
+    }
+    console.log(`${spinner_1.colors.green('✓')} Staged ${stagedNow.length} change(s):`);
+    console.log('');
+    for (const change of stagedNow) {
+        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 remainingUnstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    if (remainingUnstaged.length > 0) {
+        console.log(`${spinner_1.colors.muted(`${remainingUnstaged.length} change(s) still unstaged`)}`);
+        console.log('');
+    }
+    console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to commit.')}`);
+    console.log('');
+}
+function getRelatedChanges(tableName, changes) {
+    return changes.filter(c => {
+        if (c.objectName === tableName)
+            return true;
+        if (c.parentName === tableName)
+            return true;
+        const data = c.after;
+        if (data?.tableName === tableName)
+            return true;
+        return false;
+    });
+}
+exports.default = addCommand;

package/dist/cjs/cli/commands/commit.cjs

@@ -0,0 +1,145 @@
+"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.commitCommand = commitCommand;
+const crypto = __importStar(require("crypto"));
+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 fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+async function commitCommand(context) {
+    const { config, flags, args } = context;
+    const projectRoot = process.cwd();
+    const author = config?.author || 'Developer <dev@example.com>';
+    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;
+    }
+    const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    if (staged.length === 0) {
+        console.log(`${spinner_1.colors.yellow('Nothing to commit')}`);
+        console.log('');
+        const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+        if (unstaged.length > 0) {
+            console.log(`${spinner_1.colors.muted(`${unstaged.length} unstaged change(s).`)}`);
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq add .')} ${spinner_1.colors.muted('to stage all changes.')}`);
+        }
+        else {
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq add <table>')} ${spinner_1.colors.muted('to stage changes.')}`);
+        }
+        return;
+    }
+    let message = flags['m'] || flags['message'];
+    if (!message) {
+        if (args.length > 0) {
+            message = args.join(' ');
+        }
+        else {
+            console.log(`${spinner_1.colors.red('error:')} commit message required`);
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Usage:')} relq commit -m "message"`);
+            return;
+        }
+    }
+    const sortedChanges = (0, change_tracker_1.sortChangesByDependency)(staged);
+    const sql = (0, change_tracker_1.generateCombinedSQL)(sortedChanges);
+    const creates = staged.filter(c => c.type === 'CREATE').length;
+    const alters = staged.filter(c => c.type === 'ALTER').length;
+    const drops = staged.filter(c => c.type === 'DROP').length;
+    const parentHash = (0, repo_manager_1.getHead)(projectRoot);
+    const hashInput = JSON.stringify({
+        changes: staged.map(c => c.id),
+        message,
+        timestamp: new Date().toISOString(),
+        parent: parentHash,
+    });
+    const hash = crypto.createHash('sha1').update(hashInput).digest('hex');
+    const commit = {
+        hash,
+        parentHash,
+        author,
+        message,
+        timestamp: new Date().toISOString(),
+        changes: sortedChanges,
+        sql,
+        snapshotHash: hash.substring(0, 12),
+        stats: {
+            creates,
+            alters,
+            drops,
+            total: staged.length,
+        },
+    };
+    const commitsDir = path.join(projectRoot, '.relq', 'commits');
+    if (!fs.existsSync(commitsDir)) {
+        fs.mkdirSync(commitsDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(commitsDir, `${hash}.json`), JSON.stringify(commit, null, 2), 'utf-8');
+    fs.writeFileSync(path.join(projectRoot, '.relq', 'HEAD'), hash, 'utf-8');
+    const workingPath = path.join(projectRoot, '.relq', 'working.json');
+    const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    if (unstaged.length > 0) {
+        fs.writeFileSync(workingPath, JSON.stringify({
+            timestamp: new Date().toISOString(),
+            staged: [],
+            unstaged,
+        }, null, 2), 'utf-8');
+    }
+    else {
+        if (fs.existsSync(workingPath)) {
+            fs.unlinkSync(workingPath);
+        }
+    }
+    console.log(`${spinner_1.colors.yellow(`[${(0, repo_manager_1.shortHash)(hash)}]`)} ${message}`);
+    console.log('');
+    if (creates > 0) {
+        console.log(` ${spinner_1.colors.green(`${creates} created`)}`);
+    }
+    if (alters > 0) {
+        console.log(` ${spinner_1.colors.yellow(`${alters} altered`)}`);
+    }
+    if (drops > 0) {
+        console.log(` ${spinner_1.colors.red(`${drops} dropped`)}`);
+    }
+    console.log('');
+    console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq push')} ${spinner_1.colors.muted('to apply changes to database.')}`);
+    console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq export')} ${spinner_1.colors.muted('to export as SQL file.')}`);
+    console.log('');
+}
+exports.default = commitCommand;

package/dist/cjs/cli/commands/diff.cjs

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffCommand = diffCommand;
+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 schema_diff_2 = require("../utils/schema-diff.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',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+};
+function filterDiff(diff, ignorePatterns) {
+    const patterns = ignorePatterns.map(p => {
+        const regexStr = p.replace(/\*/g, '.*').replace(/\?/g, '.');
+        return new RegExp(`^${regexStr}$`, 'i');
+    });
+    const matchesPattern = (name) => patterns.some(p => p.test(name));
+    const tables = diff.tables.filter(t => !matchesPattern(t.name));
+    const hasChanges = tables.length > 0 || diff.extensions.length > 0;
+    return {
+        ...diff,
+        tables,
+        hasChanges,
+    };
+}
+async function diffCommand(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 snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
+    const ignorePatterns = config.sync?.ignore || ['_relq_*'];
+    const showSQL = flags['sql'] === true;
+    console.log(`${colors.bold}Comparing:${colors.reset} local snapshot ↔ ${(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}" to create initial snapshot.`);
+            return;
+        }
+        const localSchema = (0, snapshot_manager_1.snapshotToDatabaseSchema)(snapshot);
+        const normalizedLocal = (0, schema_hash_1.normalizeSchema)(localSchema);
+        const normalizedDb = (0, schema_hash_1.normalizeSchema)(dbSchema);
+        const diff = (0, schema_diff_2.diffSchemas)(normalizedLocal, normalizedDb);
+        const filteredDiff = filterDiff(diff, ignorePatterns);
+        if (!filteredDiff.hasChanges) {
+            console.log(`${colors.green}No differences.${colors.reset}`);
+            return;
+        }
+        console.log((0, schema_diff_1.formatDiff)(filteredDiff));
+        if (showSQL) {
+            console.log('');
+            console.log(`${colors.bold}Generated SQL:${colors.reset}`);
+            console.log('');
+            const { up } = (0, migration_generator_1.generateMigration)(filteredDiff, { includeDown: false });
+            for (const sql of up) {
+                console.log(`${colors.cyan}${sql}${colors.reset}`);
+            }
+        }
+        console.log('');
+        console.log(`${colors.dim}Use "relq diff --sql" to see generated SQL statements.${colors.reset}`);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}