relq 1.0.0 → 1.0.2

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

@@ -1,9 +1,12 @@
 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";
 import { colors, createSpinner } from "../utils/spinner.js";
-import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, } from "../utils/repo-manager.js";
+import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
+import { loadRelqignore, isTableIgnored, isColumnIgnored, isEnumIgnored, isDomainIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
+import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, } from "../utils/repo-manager.js";
 export async function pushCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -16,6 +19,11 @@ export async function pushCommand(context) {
     const force = flags['force'] === true;
     const dryRun = flags['dry-run'] === true;
     const applySQL = flags['apply'] === true;
+    const noVerify = flags['no-verify'] === true;
+    const skipPrompt = flags['yes'] === true || flags['y'] === true;
+    const includeFunctions = config.includeFunctions ?? false;
+    const includeTriggers = config.includeTriggers ?? false;
+    const includeViews = config.includeViews ?? false;
     console.log('');
     if (!isInitialized(projectRoot)) {
         console.log(`${colors.red('fatal:')} not a relq repository`);
@@ -35,32 +43,101 @@ export async function pushCommand(context) {
         spinner.start('Connecting to remote...');
         await ensureRemoteTable(connection);
         spinner.succeed(`Connected to ${colors.cyan(getConnectionDescription(connection))}`);
-        spinner.start('Checking remote...');
+        spinner.start('Checking remote commits...');
         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`);
+        const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
+        spinner.succeed('Checked remote commits');
+        spinner.start('Introspecting remote database...');
+        const remoteDb = await fastIntrospectDatabase(connection, undefined, {
+            includeFunctions,
+            includeTriggers,
+        });
+        spinner.succeed(`Found ${remoteDb.tables.length} tables in remote`);
+        const localSnapshot = loadSnapshot(projectRoot);
+        if (!localSnapshot) {
+            console.log(`${colors.red('error:')} No local snapshot found`);
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('or')} ${colors.cyan('relq import')} ${colors.muted('first.')}`);
+            return;
+        }
+        const ignorePatterns = loadRelqignore(projectRoot);
+        const analysis = analyzeSync(localSnapshot, remoteDb, ignorePatterns, { includeFunctions, includeTriggers, includeViews });
+        const hasRemoteAhead = remoteMissing.length > 0;
+        const hasObjectsToDrop = analysis.objectsToDrop.length > 0;
+        const hasSchemaDrift = analysis.schemaDrift.length > 0;
+        if (hasRemoteAhead && !force) {
+            console.log('');
+            console.log(`${colors.red('error:')} Remote has ${remoteMissing.length} commit(s) you don't have locally`);
+            console.log('');
+            for (const commit of remoteMissing.slice(0, 3)) {
+                console.log(`   ${colors.yellow(shortHash(commit.hash))} ${commit.message}`);
+            }
+            if (remoteMissing.length > 3) {
+                console.log(`   ${colors.muted(`... and ${remoteMissing.length - 3} more`)}`);
+            }
+            console.log('');
+            console.log(`${colors.yellow('hint:')} Run ${colors.cyan('relq pull')} to integrate remote changes.`);
+            console.log(`${colors.yellow('hint:')} Use ${colors.cyan('relq push --force')} to override (may cause data loss).`);
             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`);
+        if (hasObjectsToDrop) {
+            console.log('');
+            console.log(`${colors.yellow('⚠')} Remote has ${analysis.objectsToDrop.length} object(s) not in your local schema:`);
+            console.log('');
+            for (const obj of analysis.objectsToDrop.slice(0, 10)) {
+                console.log(`   ${colors.red('DROP')} ${obj.type.toLowerCase()}: ${obj.name}`);
+            }
+            if (analysis.objectsToDrop.length > 10) {
+                console.log(`   ${colors.muted(`... and ${analysis.objectsToDrop.length - 10} more`)}`);
+            }
             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.`);
+            if (!force) {
+                console.log(`${colors.red('error:')} Cannot push - remote has objects not in your history`);
+                console.log('');
+                console.log(`${colors.yellow('hint:')} Run ${colors.cyan('relq pull')} first to sync your local schema.`);
+                console.log(`${colors.yellow('hint:')} Use ${colors.cyan('relq push --force')} to DROP these objects from remote.`);
+                console.log('');
+                return;
+            }
+            const dependencyErrors = checkDropDependencies(analysis.objectsToDrop, remoteDb, ignorePatterns);
+            if (dependencyErrors.length > 0) {
+                console.log(`${colors.red('error:')} Cannot drop objects due to dependencies:`);
+                console.log('');
+                for (const err of dependencyErrors) {
+                    console.log(`   ${colors.red('✗')} ${err}`);
+                }
+                console.log('');
+                console.log(`${colors.muted('These objects are used by non-ignored objects in your schema.')}`);
+                console.log(`${colors.muted('Either add them to .relqignore or import them with')} ${colors.cyan('relq pull')}`);
+                console.log('');
+                return;
+            }
+            if (!skipPrompt && !dryRun) {
+                console.log(`${colors.red('⚠  WARNING: This will DROP data from your database!')}`);
+                console.log('');
+                const confirmed = await askConfirmation(`Drop ${analysis.objectsToDrop.length} object(s) from remote? [y/N] `);
+                if (!confirmed) {
+                    console.log(`${colors.muted('Cancelled.')}`);
+                    console.log('');
+                    return;
+                }
+            }
+        }
+        if (toPush.length === 0 && !hasObjectsToDrop) {
+            console.log(`${colors.green('✓')} Everything up-to-date`);
             console.log('');
             return;
         }
+        console.log('');
         console.log(`Pushing to ${colors.cyan(getConnectionDescription(connection))}`);
         console.log('');
-        if (dryRun) {
-            console.log(`${colors.yellow('Would push')} ${toPush.length} commit(s):`);
+        if (toPush.length > 0) {
+            console.log(`${colors.cyan('Commits:')} ${toPush.length}`);
             for (const commit of toPush.slice(0, 5)) {
                 console.log(`   ${colors.yellow(shortHash(commit.hash))} ${commit.message}`);
             }
@@ -68,17 +145,25 @@ export async function pushCommand(context) {
                 console.log(`   ${colors.muted(`... and ${toPush.length - 5} more`)}`);
             }
             console.log('');
+        }
+        if (dryRun) {
+            console.log(`${colors.yellow('Dry run')} - no changes applied`);
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq push --apply')} ${colors.muted('to execute.')}`);
+            console.log('');
             return;
         }
-        const commitsToProcess = [...toPush].reverse();
-        spinner.start(`Pushing ${toPush.length} commit(s)...`);
-        for (const commit of commitsToProcess) {
-            await pushCommit(connection, commit);
+        if (toPush.length > 0) {
+            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)`);
         }
-        spinner.succeed(`Pushed ${toPush.length} commit(s)`);
         if (applySQL) {
             spinner.start('Applying SQL changes...');
-            const pg = await import("../../addon/pg.js");
+            const pg = await import("../../addon/pg/index.js");
             const client = new pg.Client({
                 host: connection.host,
                 port: connection.port,
@@ -88,18 +173,42 @@ export async function pushCommand(context) {
             });
             try {
                 await client.connect();
+                await client.query('BEGIN');
                 let sqlExecuted = 0;
+                let statementsRun = 0;
+                if (hasObjectsToDrop && force) {
+                    for (const obj of analysis.objectsToDrop) {
+                        const dropSQL = generateDropSQL(obj);
+                        if (dropSQL) {
+                            await client.query(dropSQL);
+                            statementsRun++;
+                        }
+                    }
+                }
+                const commitsToProcess = [...toPush].reverse();
                 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) {
+                        if (enhancedCommit.sql && enhancedCommit.sql.trim()) {
                             await client.query(enhancedCommit.sql);
                             sqlExecuted++;
+                            statementsRun += enhancedCommit.sql.split(';').filter(s => s.trim()).length;
                         }
                     }
                 }
-                spinner.succeed(`Applied SQL from ${sqlExecuted} commit(s)`);
+                await client.query('COMMIT');
+                spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+            }
+            catch (error) {
+                try {
+                    await client.query('ROLLBACK');
+                    spinner.fail('SQL execution failed - rolled back');
+                }
+                catch {
+                    spinner.fail('SQL execution failed');
+                }
+                throw error;
             }
             finally {
                 await client.end();
@@ -108,22 +217,129 @@ export async function pushCommand(context) {
         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;
-        })) {
+        if (hasObjectsToDrop && force && applySQL) {
+            console.log('');
+            console.log(`${colors.yellow('⚠')} Dropped ${analysis.objectsToDrop.length} object(s) from remote`);
+        }
+        if (!applySQL) {
             console.log('');
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq push --apply')} ${colors.muted('to also execute SQL against database.')}`);
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq push --apply')} ${colors.muted('to execute SQL.')}`);
         }
+        console.log('');
     }
     catch (error) {
         spinner.fail('Push failed');
         console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
         process.exit(1);
     }
-    console.log('');
 }
+function analyzeSync(local, remote, patterns, options) {
+    const objectsToDrop = [];
+    const schemaDrift = [];
+    const localTables = new Set(local.tables.map(t => t.name));
+    const localEnums = new Set(local.enums.map(e => e.name));
+    const localDomains = new Set(local.domains.map(d => d.name));
+    const localSequences = new Set(local.sequences.map(s => s.name));
+    const localFunctions = new Set((local.functions || []).map(f => f.name));
+    const localViews = new Set((local.views || []).map(v => v.name));
+    const localMViews = new Set((local.materializedViews || []).map(v => v.name));
+    for (const table of remote.tables) {
+        if (isTableIgnored(table.name, patterns).ignored)
+            continue;
+        if (!localTables.has(table.name)) {
+            objectsToDrop.push({ type: 'TABLE', name: table.name });
+        }
+    }
+    for (const enumType of remote.enums) {
+        if (isEnumIgnored(enumType.name, patterns).ignored)
+            continue;
+        if (!localEnums.has(enumType.name)) {
+            objectsToDrop.push({ type: 'ENUM', name: enumType.name });
+        }
+    }
+    for (const domain of remote.domains) {
+        if (isDomainIgnored(domain.name, patterns).ignored)
+            continue;
+        if (!localDomains.has(domain.name)) {
+            objectsToDrop.push({ type: 'DOMAIN', name: domain.name });
+        }
+    }
+    if (options.includeFunctions) {
+        for (const func of remote.functions || []) {
+            if (isFunctionIgnored(func.name, patterns).ignored)
+                continue;
+            if (!localFunctions.has(func.name)) {
+                objectsToDrop.push({ type: 'FUNCTION', name: func.name });
+            }
+        }
+    }
+    return {
+        toPush: [],
+        objectsToDrop,
+        schemaDrift,
+        remoteAhead: false,
+    };
+}
+function checkDropDependencies(objectsToDrop, remoteDb, patterns) {
+    const errors = [];
+    const droppingTables = new Set(objectsToDrop.filter(o => o.type === 'TABLE').map(o => o.name));
+    const droppingEnums = new Set(objectsToDrop.filter(o => o.type === 'ENUM').map(o => o.name));
+    const droppingDomains = new Set(objectsToDrop.filter(o => o.type === 'DOMAIN').map(o => o.name));
+    const droppingSequences = new Set(objectsToDrop.filter(o => o.type === 'SEQUENCE').map(o => o.name));
+    for (const table of remoteDb.tables) {
+        if (droppingTables.has(table.name))
+            continue;
+        if (isTableIgnored(table.name, patterns).ignored)
+            continue;
+        for (const col of table.columns) {
+            if (isColumnIgnored(table.name, col.name, patterns).ignored)
+                continue;
+            const colType = (col.dataType || '').toLowerCase();
+            for (const enumName of droppingEnums) {
+                if (colType.includes(enumName.toLowerCase())) {
+                    errors.push(`Cannot drop ENUM "${enumName}" - used by column "${table.name}.${col.name}"`);
+                }
+            }
+            for (const domainName of droppingDomains) {
+                if (colType.includes(domainName.toLowerCase())) {
+                    errors.push(`Cannot drop DOMAIN "${domainName}" - used by column "${table.name}.${col.name}"`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+function generateDropSQL(obj) {
+    switch (obj.type) {
+        case 'TABLE':
+            return `DROP TABLE IF EXISTS "${obj.name}" CASCADE;`;
+        case 'ENUM':
+            return `DROP TYPE IF EXISTS "${obj.name}" CASCADE;`;
+        case 'DOMAIN':
+            return `DROP DOMAIN IF EXISTS "${obj.name}" CASCADE;`;
+        case 'FUNCTION':
+            return `DROP FUNCTION IF EXISTS "${obj.name}" CASCADE;`;
+        case 'VIEW':
+            return `DROP VIEW IF EXISTS "${obj.name}" CASCADE;`;
+        case 'MATERIALIZED_VIEW':
+            return `DROP MATERIALIZED VIEW IF EXISTS "${obj.name}" CASCADE;`;
+        case 'SEQUENCE':
+            return `DROP SEQUENCE IF EXISTS "${obj.name}" CASCADE;`;
+        default:
+            return '';
+    }
+}
+function askConfirmation(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+export default pushCommand;

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

@@ -0,0 +1,13 @@
+export async function remoteCommand(context) {
+    console.log('');
+    console.log('⚠️  Remote tracking is coming soon.');
+    console.log('');
+    console.log('This will allow you to:');
+    console.log('  • Track multiple remote databases');
+    console.log('  • Push/pull to different environments');
+    console.log('  • Switch between staging/production');
+    console.log('');
+    console.log('For now, configure your remote in relq.config.ts');
+    console.log('');
+}
+export default remoteCommand;

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

@@ -0,0 +1,133 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, getHead, setHead, loadCommit, saveSnapshot, shortHash, getAllCommits, } from "../utils/repo-manager.js";
+export async function resetCommand(context) {
+    const { flags, args } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    const hard = flags['hard'] === true;
+    const soft = flags['soft'] === true;
+    const target = args[0];
+    if (!target) {
+        console.log(`${colors.red('error:')} Please specify a target`);
+        console.log('');
+        console.log('Usage:');
+        console.log(`  ${colors.cyan('relq reset --hard HEAD~1')}   Reset to previous commit`);
+        console.log(`  ${colors.cyan('relq reset --hard <hash>')}   Reset to specific commit`);
+        console.log('');
+        return;
+    }
+    if (!hard && !soft) {
+        console.log(`${colors.red('error:')} Please specify --hard or --soft`);
+        console.log('');
+        console.log(`  ${colors.cyan('--hard')}  Discard all changes (DANGEROUS)`);
+        console.log(`  ${colors.cyan('--soft')}  Keep changes unstaged`);
+        console.log('');
+        return;
+    }
+    const currentHead = getHead(projectRoot);
+    if (!currentHead) {
+        console.log(`${colors.red('error:')} No commits yet`);
+        return;
+    }
+    const allCommits = getAllCommits(projectRoot);
+    let targetHash = null;
+    if (target.startsWith('HEAD~')) {
+        const n = parseInt(target.slice(5)) || 1;
+        const headIndex = allCommits.findIndex(c => c.hash === currentHead);
+        if (headIndex >= 0 && headIndex + n < allCommits.length) {
+            targetHash = allCommits[headIndex + n].hash;
+        }
+    }
+    else if (target === 'HEAD') {
+        targetHash = currentHead;
+    }
+    else {
+        const match = allCommits.find(c => c.hash.startsWith(target));
+        if (match) {
+            targetHash = match.hash;
+        }
+    }
+    if (!targetHash) {
+        console.log(`${colors.red('error:')} Cannot find commit: ${target}`);
+        console.log('');
+        console.log('Available commits:');
+        for (const c of allCommits.slice(0, 5)) {
+            console.log(`   ${colors.yellow(shortHash(c.hash))} ${c.message}`);
+        }
+        return;
+    }
+    const targetCommit = loadCommit(targetHash, projectRoot);
+    if (!targetCommit) {
+        console.log(`${colors.red('error:')} Cannot load commit: ${targetHash}`);
+        return;
+    }
+    if (hard) {
+        console.log(`${colors.red('⚠  WARNING: This will discard all local changes!')}`);
+        console.log('');
+        console.log(`Reset to: ${colors.yellow(shortHash(targetHash))} ${targetCommit.message}`);
+        console.log('');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const confirmed = await new Promise((resolve) => {
+            rl.question(`Continue? [y/N] `, (answer) => {
+                rl.close();
+                resolve(answer.trim().toLowerCase() === 'y');
+            });
+        });
+        if (!confirmed) {
+            console.log(`${colors.muted('Cancelled.')}`);
+            console.log('');
+            return;
+        }
+    }
+    const spinner = createSpinner();
+    try {
+        spinner.start(`Resetting to ${shortHash(targetHash)}...`);
+        const commitPath = path.join(projectRoot, '.relq', 'commits', `${targetHash}.json`);
+        if (!fs.existsSync(commitPath)) {
+            spinner.fail('Cannot find commit data');
+            return;
+        }
+        const commitData = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+        const targetSnapshot = commitData.snapshot;
+        if (!targetSnapshot) {
+            spinner.fail('Commit has no snapshot data');
+            return;
+        }
+        if (hard) {
+            saveSnapshot(targetSnapshot, projectRoot);
+            setHead(targetHash, projectRoot);
+            const stagedPath = path.join(projectRoot, '.relq', 'staged.json');
+            const unstagedPath = path.join(projectRoot, '.relq', 'unstaged.json');
+            if (fs.existsSync(stagedPath))
+                fs.unlinkSync(stagedPath);
+            if (fs.existsSync(unstagedPath))
+                fs.unlinkSync(unstagedPath);
+            const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+            if (fs.existsSync(mergeStatePath))
+                fs.unlinkSync(mergeStatePath);
+        }
+        spinner.succeed(`Reset to ${colors.yellow(shortHash(targetHash))}`);
+        console.log('');
+        console.log(`HEAD is now at ${colors.yellow(shortHash(targetHash))} ${targetCommit.message}`);
+        console.log('');
+        if (soft) {
+            console.log(`${colors.muted('Changes are unstaged. Use')} ${colors.cyan('relq status')} ${colors.muted('to see.')}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Reset failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+}
+export default resetCommand;

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

@@ -0,0 +1,157 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors } from "../utils/spinner.js";
+import { isInitialized, loadSnapshot, saveSnapshot, } from "../utils/repo-manager.js";
+export async function resolveCommand(context) {
+    const { flags, args } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+    if (!fs.existsSync(mergeStatePath)) {
+        console.log(`${colors.green('✓')} No conflicts to resolve`);
+        console.log('');
+        return;
+    }
+    const mergeState = JSON.parse(fs.readFileSync(mergeStatePath, 'utf-8'));
+    if (mergeState.conflicts.length === 0) {
+        fs.unlinkSync(mergeStatePath);
+        console.log(`${colors.green('✓')} All conflicts resolved`);
+        console.log('');
+        return;
+    }
+    const allTheirs = flags['all-theirs'] === true;
+    const allOurs = flags['all-ours'] === true;
+    const theirs = flags['theirs'] === true;
+    const ours = flags['ours'] === true;
+    const objectName = args[0];
+    if (allTheirs) {
+        console.log(`Resolving ${mergeState.conflicts.length} conflict(s) with --all-theirs`);
+        console.log('');
+        saveSnapshot(mergeState.remoteSnapshot, projectRoot);
+        fs.unlinkSync(mergeStatePath);
+        console.log(`${colors.green('✓')} Applied remote versions for all conflicts`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "Merge remote changes"')} ${colors.muted('to complete.')}`);
+        console.log('');
+        return;
+    }
+    if (allOurs) {
+        console.log(`Resolving ${mergeState.conflicts.length} conflict(s) with --all-ours`);
+        console.log('');
+        fs.unlinkSync(mergeStatePath);
+        console.log(`${colors.green('✓')} Kept local versions for all conflicts`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "Keep local changes"')} ${colors.muted('to complete.')}`);
+        console.log('');
+        return;
+    }
+    if ((theirs || ours) && objectName) {
+        const conflict = mergeState.conflicts.find(c => c.objectName === objectName ||
+            `${c.parentName}.${c.objectName}` === objectName);
+        if (!conflict) {
+            console.log(`${colors.red('error:')} No conflict found for '${objectName}'`);
+            console.log('');
+            console.log('Conflicts:');
+            for (const c of mergeState.conflicts) {
+                const name = c.parentName ? `${c.parentName}.${c.objectName}` : c.objectName;
+                console.log(`   ${c.objectType}: ${name}`);
+            }
+            console.log('');
+            return;
+        }
+        const localSnapshot = loadSnapshot(projectRoot);
+        if (!localSnapshot) {
+            console.log(`${colors.red('error:')} No local snapshot found`);
+            return;
+        }
+        if (theirs) {
+            applyResolution(localSnapshot, conflict, mergeState.remoteSnapshot, 'theirs');
+            saveSnapshot(localSnapshot, projectRoot);
+        }
+        mergeState.conflicts = mergeState.conflicts.filter(c => c !== conflict);
+        if (mergeState.conflicts.length === 0) {
+            fs.unlinkSync(mergeStatePath);
+            console.log(`${colors.green('✓')} All conflicts resolved`);
+        }
+        else {
+            fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
+            console.log(`${colors.green('✓')} Resolved: ${conflict.objectType} ${objectName}`);
+            console.log(`${colors.yellow(String(mergeState.conflicts.length))} conflict(s) remaining`);
+        }
+        console.log('');
+        return;
+    }
+    console.log(`${colors.yellow('⚠')} You have ${mergeState.conflicts.length} unresolved conflict(s):`);
+    console.log('');
+    for (const conflict of mergeState.conflicts) {
+        const name = conflict.parentName
+            ? `${conflict.parentName}.${conflict.objectName}`
+            : conflict.objectName;
+        console.log(`   ${colors.red('conflict:')} ${conflict.objectType.toLowerCase()} ${colors.bold(name)}`);
+        console.log(`     ${colors.muted(conflict.description)}`);
+    }
+    console.log('');
+    console.log('To resolve:');
+    console.log(`  ${colors.cyan('relq resolve --theirs <name>')}  Take remote version`);
+    console.log(`  ${colors.cyan('relq resolve --ours <name>')}    Keep local version`);
+    console.log(`  ${colors.cyan('relq resolve --all-theirs')}     Take all remote`);
+    console.log(`  ${colors.cyan('relq resolve --all-ours')}       Keep all local`);
+    console.log('');
+}
+function applyResolution(local, conflict, remote, resolution) {
+    if (resolution !== 'theirs')
+        return;
+    switch (conflict.objectType) {
+        case 'TABLE': {
+            const remoteTable = remote.tables.find(t => t.name === conflict.objectName);
+            const localIdx = local.tables.findIndex(t => t.name === conflict.objectName);
+            if (remoteTable) {
+                if (localIdx >= 0) {
+                    local.tables[localIdx] = remoteTable;
+                }
+                else {
+                    local.tables.push(remoteTable);
+                }
+            }
+            break;
+        }
+        case 'COLUMN': {
+            const [tableName, colName] = conflict.objectName.includes('.')
+                ? conflict.objectName.split('.')
+                : [conflict.parentName, conflict.objectName];
+            const remoteTable = remote.tables.find(t => t.name === tableName);
+            const localTable = local.tables.find(t => t.name === tableName);
+            if (remoteTable && localTable) {
+                const remoteCol = remoteTable.columns.find(c => c.name === colName);
+                const localIdx = localTable.columns.findIndex(c => c.name === colName);
+                if (remoteCol) {
+                    if (localIdx >= 0) {
+                        localTable.columns[localIdx] = remoteCol;
+                    }
+                    else {
+                        localTable.columns.push(remoteCol);
+                    }
+                }
+            }
+            break;
+        }
+        case 'ENUM': {
+            const remoteEnum = remote.enums.find(e => e.name === conflict.objectName);
+            const localIdx = local.enums.findIndex(e => e.name === conflict.objectName);
+            if (remoteEnum) {
+                if (localIdx >= 0) {
+                    local.enums[localIdx] = remoteEnum;
+                }
+                else {
+                    local.enums.push(remoteEnum);
+                }
+            }
+            break;
+        }
+    }
+}
+export default resolveCommand;

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

@@ -49,7 +49,7 @@ export async function rollbackCommand(context) {
     console.log(`   Connection: ${getConnectionDescription(connection)}`);
     console.log('');
     try {
-        const { Pool } = await import("../../addon/pg.js");
+        const { Pool } = await import("../../addon/pg/index.js");
         const pool = new Pool({
             host: connection.host,
             port: connection.port || 5432,