relq 1.0.0

package/dist/esm/cli/commands/migrate.js

@@ -0,0 +1,131 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { requireValidConfig } from "../utils/config-loader.js";
+import { getConnectionDescription } from "../utils/env-loader.js";
+function parseMigration(content) {
+    const upMatch = content.match(/--\s*UP\s*\n([\s\S]*?)(?=--\s*DOWN|$)/i);
+    const downMatch = content.match(/--\s*DOWN\s*\n([\s\S]*?)$/i);
+    return {
+        up: upMatch?.[1]?.trim() || '',
+        down: downMatch?.[1]?.trim() || '',
+    };
+}
+function askConfirm(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} [y/N]: `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+export async function migrateCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const dryRun = flags['dry-run'] === true;
+    const force = flags['force'] === true;
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const tableName = config.migrations?.tableName || '_relq_migrations';
+    console.log('🔄 Running migrations...');
+    console.log(`   Connection: ${getConnectionDescription(connection)}`);
+    console.log(`   Migrations: ${migrationsDir}\n`);
+    try {
+        const { Pool } = await import("../../addon/pg.js");
+        const pool = new Pool({
+            host: connection.host,
+            port: connection.port || 5432,
+            database: connection.database,
+            user: connection.user,
+            password: connection.password,
+            connectionString: connection.url,
+        });
+        try {
+            await pool.query(`
+                CREATE TABLE IF NOT EXISTS "${tableName}" (
+                    id SERIAL PRIMARY KEY,
+                    name VARCHAR(255) NOT NULL UNIQUE,
+                    applied_at TIMESTAMPTZ DEFAULT NOW()
+                );
+            `);
+            const appliedResult = await pool.query(`
+                SELECT name FROM "${tableName}" ORDER BY id;
+            `);
+            const appliedMigrations = new Set(appliedResult.rows.map(r => r.name));
+            if (!fs.existsSync(migrationsDir)) {
+                console.log('No migrations directory found.');
+                return;
+            }
+            const migrationFiles = fs.readdirSync(migrationsDir)
+                .filter(f => f.endsWith('.sql'))
+                .sort();
+            const pending = migrationFiles.filter(f => !appliedMigrations.has(f));
+            if (pending.length === 0) {
+                console.log('✅ No pending migrations.');
+                return;
+            }
+            console.log(`📋 Pending migrations (${pending.length}):`);
+            for (const file of pending) {
+                console.log(`   • ${file}`);
+            }
+            console.log('');
+            if (!force && !dryRun) {
+                if (!await askConfirm('Apply these migrations?')) {
+                    console.log('Cancelled.');
+                    return;
+                }
+            }
+            for (const file of pending) {
+                const filePath = path.join(migrationsDir, file);
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const { up } = parseMigration(content);
+                if (!up) {
+                    console.log(`⚠️  Skipping ${file} (no UP section)`);
+                    continue;
+                }
+                if (dryRun) {
+                    console.log(`Would apply: ${file}`);
+                    console.log('---');
+                    console.log(up);
+                    console.log('---\n');
+                }
+                else {
+                    console.log(`Applying: ${file}...`);
+                    const client = await pool.connect();
+                    try {
+                        await client.query('BEGIN');
+                        await client.query(up);
+                        await client.query(`INSERT INTO "${tableName}" (name) VALUES ($1)`, [file]);
+                        await client.query('COMMIT');
+                        console.log(`   ✅ Applied`);
+                    }
+                    catch (error) {
+                        await client.query('ROLLBACK');
+                        throw error;
+                    }
+                    finally {
+                        client.release();
+                    }
+                }
+            }
+            if (!dryRun) {
+                console.log(`\n✅ Applied ${pending.length} migration(s).`);
+            }
+        }
+        finally {
+            await pool.end();
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/esm/cli/commands/pull.js

@@ -0,0 +1,374 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { requireValidConfig } from "../utils/config-loader.js";
+import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
+import { generateTypeScript } from "../utils/type-generator.js";
+import { getConnectionDescription } from "../utils/env-loader.js";
+import { createSpinner, colors, formatBytes } from "../utils/spinner.js";
+import { getIgnorePatterns, filterIgnored } from "../utils/relqignore.js";
+import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+function toCamelCase(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function parseSchemaFileForSnapshot(schemaPath) {
+    if (!fs.existsSync(schemaPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(schemaPath, 'utf-8');
+    const tables = [];
+    const tableRegex = /defineTable\s*\(\s*['"]([^'"]+)['"],\s*\{([\s\S]*?)\}(?:\s*,\s*\{([\s\S]*?)\})?\s*\)/g;
+    let tableMatch;
+    while ((tableMatch = tableRegex.exec(content)) !== null) {
+        const tableName = tableMatch[1];
+        const columnsBlock = tableMatch[2];
+        const optionsBlock = tableMatch[3] || '';
+        const columns = [];
+        const typePattern = 'varchar|text|uuid|integer|bigint|boolean|timestamp|date|jsonb|json|numeric|serial|bigserial|smallserial|tsvector|smallint|real|doublePrecision|char|inet|cidr|macaddr|macaddr8|interval|time|point|line|lseg|box|path|polygon|circle|bytea|bit|varbit|money|xml|oid';
+        const columnRegex = new RegExp(`^\\s*(\\w+):\\s*(${typePattern})(?:\\([^)]*\\))?((?:\\.[a-zA-Z]+\\([^)]*\\))*)`, 'gm');
+        let colMatch;
+        while ((colMatch = columnRegex.exec(columnsBlock)) !== null) {
+            const tsName = colMatch[1];
+            const type = colMatch[2];
+            const modifiers = colMatch[3] || '';
+            const explicitNameMatch = columnsBlock.match(new RegExp(`${tsName}:\\s*${type}\\s*\\(['\"]([^'"]+)['\"]`));
+            const dbColName = explicitNameMatch ? explicitNameMatch[1] : tsName;
+            columns.push({
+                name: dbColName,
+                tsName: tsName,
+                type: modifiers.includes('.array()') ? `${type}[]` : type,
+                nullable: !modifiers.includes('.notNull()') && !modifiers.includes('.primaryKey()'),
+                default: null,
+                primaryKey: modifiers.includes('.primaryKey()'),
+                unique: modifiers.includes('.unique()'),
+            });
+        }
+        const indexes = [];
+        const indexRegex = /index\s*\(\s*['"]([^'"]+)['"]\s*\)\.on\(([^)]+)\)/g;
+        let idxMatch;
+        while ((idxMatch = indexRegex.exec(optionsBlock)) !== null) {
+            const indexName = idxMatch[1];
+            const indexCols = idxMatch[2].split(',').map(c => c.trim().replace(/table\.\s*/, ''));
+            const isUnique = optionsBlock.includes(`index('${indexName}')`) &&
+                optionsBlock.substring(optionsBlock.indexOf(`index('${indexName}')`)).split('\n')[0].includes('.unique()');
+            indexes.push({
+                name: indexName,
+                columns: indexCols,
+                unique: isUnique,
+                type: 'btree',
+            });
+        }
+        const hasPartition = optionsBlock.includes('partitionBy');
+        let partitionType;
+        let partitionKey = [];
+        let partitions = [];
+        if (hasPartition) {
+            const partitionByMatch = optionsBlock.match(/partitionBy:\s*\([^)]+\)\s*=>\s*\w+\.(list|range|hash)\(([^)]+)\)/i);
+            if (partitionByMatch) {
+                partitionType = partitionByMatch[1].toUpperCase();
+                const colMatch = partitionByMatch[2].match(/table\.(\w+)/);
+                if (colMatch) {
+                    partitionKey = [colMatch[1]];
+                }
+            }
+            const partitionsMatch = optionsBlock.match(/partitions:\s*\(partition\)\s*=>\s*\[([\s\S]*?)\]/);
+            if (partitionsMatch) {
+                const partitionsBlock = partitionsMatch[1];
+                const partitionRegex = /partition\s*\(\s*['"]([^'"]+)['"]\s*\)\.([^,\n]+)/g;
+                let pMatch;
+                while ((pMatch = partitionRegex.exec(partitionsBlock)) !== null) {
+                    partitions.push({
+                        name: pMatch[1],
+                        bound: pMatch[2].trim(),
+                    });
+                }
+            }
+        }
+        tables.push({
+            name: tableName,
+            schema: 'public',
+            columns,
+            indexes,
+            constraints: [],
+            ...(hasPartition && {
+                isPartitioned: true,
+                partitionType,
+                partitionKey,
+                partitions,
+            }),
+        });
+    }
+    const enums = [];
+    const enumRegex = /pgEnum\s*\(\s*['"]([^'"]+)['"]]/g;
+    let enumMatch;
+    while ((enumMatch = enumRegex.exec(content)) !== null) {
+        enums.push(enumMatch[1]);
+    }
+    return {
+        tables,
+        enums: [],
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        collations: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+    };
+}
+function askConfirm(question, defaultYes = true) {
+    const suffix = defaultYes ? colors.muted('[Y/n]') : colors.muted('[y/N]');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    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');
+        });
+    });
+}
+export async function pullCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    const force = flags['force'] === true;
+    const dryRun = flags['dry-run'] === true;
+    const author = config.author || 'Relq CLI';
+    const schemaPath = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
+    const includeFunctions = config.generate?.includeFunctions ?? false;
+    const includeTriggers = config.generate?.includeTriggers ?? false;
+    const spinner = createSpinner();
+    const startTime = Date.now();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        initRepository(projectRoot);
+        console.log(`${colors.cyan('ℹ')}  Initialized .relq folder`);
+    }
+    if (!force) {
+        const stagedChanges = getStagedChanges(projectRoot);
+        const unstagedChanges = getUnstagedChanges(projectRoot);
+        if (stagedChanges.length > 0 || unstagedChanges.length > 0) {
+            const hasUnstaged = unstagedChanges.length > 0;
+            const hasStaged = stagedChanges.length > 0;
+            if (hasUnstaged && hasStaged) {
+                console.error(colors.red('Error: You have uncommitted and unstaged changes.'));
+            }
+            else if (hasStaged) {
+                console.error(colors.red('Error: You have uncommitted changes.'));
+            }
+            else {
+                console.error(colors.red('Error: You have unstaged changes.'));
+            }
+            console.log('');
+            if (hasStaged) {
+                console.log(`  ${colors.green('Staged (uncommitted):')} ${stagedChanges.length} change(s)`);
+            }
+            if (hasUnstaged) {
+                console.log(`  ${colors.red('Unstaged:')} ${unstagedChanges.length} change(s)`);
+            }
+            console.log('');
+            if (hasUnstaged && !hasStaged) {
+                console.log('Please stage and commit, or reset your changes:');
+                console.log(`  ${colors.cyan('relq add .')}              - stage all changes`);
+                console.log(`  ${colors.cyan('relq commit -m "message"')}  - then commit`);
+            }
+            else {
+                console.log('Please commit or reset your changes:');
+                console.log(`  ${colors.cyan('relq commit -m "message"')}  - commit staged changes`);
+            }
+            console.log(`  ${colors.cyan('relq reset')}               - discard all changes`);
+            console.log(`  ${colors.cyan('relq pull --force')}        - force pull (overwrites local changes)`);
+            return;
+        }
+    }
+    try {
+        spinner.start('Connecting to database...');
+        await ensureRemoteTable(connection);
+        spinner.succeed(`Connected to ${colors.cyan(getConnectionDescription(connection))}`);
+        spinner.start('Fetching remote commits...');
+        const remoteCommits = await fetchRemoteCommits(connection, 100);
+        const remoteHead = remoteCommits.length > 0 ? remoteCommits[0].hash : null;
+        if (remoteHead) {
+            setFetchHead(remoteHead, projectRoot);
+        }
+        spinner.succeed(`Fetched ${remoteCommits.length} remote commits`);
+        spinner.start('Introspecting database...');
+        const dbSchema = await fastIntrospectDatabase(connection, undefined, {
+            includeFunctions,
+            includeTriggers,
+        });
+        spinner.succeed(`Found ${dbSchema.tables.length} tables`);
+        const ignorePatterns = getIgnorePatterns(projectRoot);
+        const filteredTables = filterIgnored(dbSchema.tables, ignorePatterns);
+        const localHead = getHead(projectRoot);
+        const localSnapshot = loadSnapshot(projectRoot);
+        const schemaExists = fs.existsSync(schemaPath);
+        const currentSchema = {
+            tables: filteredTables.map(t => ({
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    tsName: toCamelCase(c.name),
+                    type: c.dataType,
+                    nullable: c.isNullable,
+                    default: c.defaultValue,
+                    primaryKey: c.isPrimaryKey,
+                    unique: c.isUnique,
+                })),
+                indexes: t.indexes.map(i => ({
+                    name: i.name,
+                    columns: i.columns,
+                    unique: i.isUnique,
+                    type: i.type,
+                })),
+                constraints: t.constraints.map(c => ({
+                    name: c.name,
+                    type: c.type,
+                    definition: c.definition,
+                })),
+            })),
+            enums: dbSchema.enums.map(e => ({
+                name: e.name,
+                schema: 'public',
+                values: e.values,
+            })),
+            domains: dbSchema.domains.map(d => ({
+                name: d.name,
+                schema: 'public',
+                baseType: d.baseType,
+                notNull: d.isNotNull || false,
+                default: d.defaultValue || null,
+                check: d.checkExpression || null,
+            })),
+            compositeTypes: dbSchema.compositeTypes.map(c => ({
+                name: c.name,
+                schema: 'public',
+                attributes: c.attributes,
+            })),
+            sequences: [],
+            collations: [],
+            functions: dbSchema.functions.map(f => ({
+                name: f.name,
+                returnType: f.returnType,
+                argTypes: f.argTypes,
+                language: f.language,
+            })),
+            triggers: dbSchema.triggers.map(t => ({
+                name: t.name,
+                table: t.tableName,
+                events: [t.event],
+                timing: t.timing,
+                forEach: 'STATEMENT',
+                functionName: t.functionName || '',
+            })),
+            extensions: dbSchema.extensions.map(ext => ({ name: ext })),
+        };
+        console.log('');
+        if (schemaExists && localSnapshot && !force) {
+            const localTables = new Set(localSnapshot.tables.map(t => t.name));
+            const remoteTables = new Set(currentSchema.tables.map(t => t.name));
+            const added = [...remoteTables].filter(t => !localTables.has(t));
+            const removed = [...localTables].filter(t => !remoteTables.has(t));
+            if (added.length === 0 && removed.length === 0) {
+                console.log(`${colors.green('✓')} Already up to date with remote`);
+                console.log('');
+                return;
+            }
+            console.log(`${colors.yellow('Remote has changes:')}`);
+            if (added.length > 0) {
+                console.log(`   ${colors.green(`+${added.length}`)} tables added`);
+            }
+            if (removed.length > 0) {
+                console.log(`   ${colors.red(`-${removed.length}`)} tables removed`);
+            }
+            console.log('');
+            if (!dryRun) {
+                const proceed = await askConfirm(`${colors.bold('Pull these changes?')}`, true);
+                if (!proceed) {
+                    console.log('');
+                    console.log(`${colors.muted('Cancelled.')}`);
+                    return;
+                }
+                console.log('');
+            }
+        }
+        else if (schemaExists && !force) {
+            console.log(`${colors.yellow('⚠')}  ${colors.bold('Local schema exists but not tracked')}`);
+            console.log('');
+            console.log(`   ${colors.cyan(schemaPath)}`);
+            console.log('');
+            if (!dryRun) {
+                const proceed = await askConfirm(`${colors.bold('Overwrite local schema?')}`, false);
+                if (!proceed) {
+                    console.log('');
+                    console.log(`${colors.muted('Cancelled. Run')} ${colors.cyan('relq status')} ${colors.muted('to see current state.')}`);
+                    return;
+                }
+                console.log('');
+            }
+        }
+        else if (!schemaExists) {
+            console.log(`${colors.cyan('ℹ')}  ${colors.bold('First pull - creating schema')}`);
+            console.log('');
+            console.log(`📊 ${colors.bold('Schema Summary')}`);
+            console.log(`   ${colors.green(String(filteredTables.length))} tables`);
+            console.log(`   ${colors.green(String(dbSchema.extensions.length))} extensions`);
+            console.log('');
+        }
+        if (dryRun) {
+            console.log(`${colors.yellow('⚠')} Dry run - no files written`);
+            console.log('');
+            return;
+        }
+        spinner.start('Generating TypeScript schema...');
+        const typescript = generateTypeScript(dbSchema, {
+            includeDefineTables: true,
+            includeSchema: true,
+            includeIndexes: true,
+            includeFunctions,
+            includeTriggers,
+            camelCase: config.generate?.camelCase ?? true,
+        });
+        spinner.succeed('Generated TypeScript schema');
+        const schemaDir = path.dirname(schemaPath);
+        if (!fs.existsSync(schemaDir)) {
+            fs.mkdirSync(schemaDir, { recursive: true });
+        }
+        spinner.start('Writing schema file...');
+        fs.writeFileSync(schemaPath, typescript, 'utf-8');
+        const fileSize = Buffer.byteLength(typescript, 'utf8');
+        spinner.succeed(`Written ${colors.cyan(schemaPath)} ${colors.muted(`(${formatBytes(fileSize)})`)}`);
+        const snapshotFromFile = parseSchemaFileForSnapshot(schemaPath);
+        if (snapshotFromFile) {
+            saveSnapshot(snapshotFromFile, projectRoot);
+        }
+        else {
+            saveSnapshot(currentSchema, projectRoot);
+        }
+        spinner.start('Creating commit...');
+        const message = localHead ? 'Pulled schema from database' : 'Initial schema pull';
+        const commit = createCommit(currentSchema, author, message, projectRoot);
+        spinner.succeed(`Created commit ${colors.yellow(shortHash(commit.hash))}`);
+        const duration = Date.now() - startTime;
+        console.log('');
+        console.log(`${colors.green('✓')} Pull completed in ${colors.cyan(`${duration}ms`)}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Pull failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+}

package/dist/esm/cli/commands/push.js

@@ -0,0 +1,129 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { requireValidConfig } from "../utils/config-loader.js";
+import { getConnectionDescription } from "../utils/env-loader.js";
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, } from "../utils/repo-manager.js";
+export async function pushCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    const force = flags['force'] === true;
+    const dryRun = flags['dry-run'] === true;
+    const applySQL = flags['apply'] === true;
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('to initialize.')}`);
+        return;
+    }
+    const localHead = getHead(projectRoot);
+    if (!localHead) {
+        console.log(`${colors.red('error:')} no commits to push`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to create a commit.')}`);
+        return;
+    }
+    const spinner = createSpinner();
+    try {
+        spinner.start('Connecting to remote...');
+        await ensureRemoteTable(connection);
+        spinner.succeed(`Connected to ${colors.cyan(getConnectionDescription(connection))}`);
+        spinner.start('Checking remote...');
+        const remoteCommits = await fetchRemoteCommits(connection, 100);
+        const remoteHead = remoteCommits.length > 0 ? remoteCommits[0].hash : null;
+        spinner.stop();
+        const localCommits = getAllCommits(projectRoot);
+        const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+        const localHashes = new Set(localCommits.map(c => c.hash));
+        const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
+        if (toPush.length === 0) {
+            console.log(`${colors.green('✓')} Everything up-to-date`);
+            console.log('');
+            return;
+        }
+        const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
+        if (remoteMissing.length > 0 && !force) {
+            console.log(`${colors.red('error:')} failed to push`);
+            console.log('');
+            console.log(`${colors.yellow('hint:')} Updates were rejected because the remote contains work that you do not have locally.`);
+            console.log(`${colors.yellow('hint:')} Run ${colors.cyan('relq pull')} to integrate the remote changes before pushing.`);
+            console.log('');
+            return;
+        }
+        console.log(`Pushing to ${colors.cyan(getConnectionDescription(connection))}`);
+        console.log('');
+        if (dryRun) {
+            console.log(`${colors.yellow('Would push')} ${toPush.length} commit(s):`);
+            for (const commit of toPush.slice(0, 5)) {
+                console.log(`   ${colors.yellow(shortHash(commit.hash))} ${commit.message}`);
+            }
+            if (toPush.length > 5) {
+                console.log(`   ${colors.muted(`... and ${toPush.length - 5} more`)}`);
+            }
+            console.log('');
+            return;
+        }
+        const commitsToProcess = [...toPush].reverse();
+        spinner.start(`Pushing ${toPush.length} commit(s)...`);
+        for (const commit of commitsToProcess) {
+            await pushCommit(connection, commit);
+        }
+        spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+        if (applySQL) {
+            spinner.start('Applying SQL changes...');
+            const pg = await import("../../addon/pg.js");
+            const client = new pg.Client({
+                host: connection.host,
+                port: connection.port,
+                database: connection.database,
+                user: connection.user,
+                password: connection.password,
+            });
+            try {
+                await client.connect();
+                let sqlExecuted = 0;
+                for (const commit of commitsToProcess) {
+                    const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
+                    if (fs.existsSync(commitPath)) {
+                        const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                        if (enhancedCommit.sql) {
+                            await client.query(enhancedCommit.sql);
+                            sqlExecuted++;
+                        }
+                    }
+                }
+                spinner.succeed(`Applied SQL from ${sqlExecuted} commit(s)`);
+            }
+            finally {
+                await client.end();
+            }
+        }
+        const oldHash = remoteHead ? shortHash(remoteHead) : '(none)';
+        const newHash = shortHash(localHead);
+        console.log(`   ${oldHash}..${newHash}  ${colors.muted('main -> main')}`);
+        if (!applySQL && toPush.some(c => {
+            const commitPath = path.join(projectRoot, '.relq', 'commits', `${c.hash}.json`);
+            if (fs.existsSync(commitPath)) {
+                const ec = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                return ec.sql && ec.sql.trim().length > 0;
+            }
+            return false;
+        })) {
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq push --apply')} ${colors.muted('to also execute SQL against database.')}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Push failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+    console.log('');
+}