relq 1.0.0 → 1.0.2

package/dist/cjs/cli/commands/import.cjs

@@ -41,6 +41,7 @@ const type_generator_1 = require("../utils/type-generator.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 const schema_comparator_1 = require("../utils/schema-comparator.cjs");
 const change_tracker_1 = require("../utils/change-tracker.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
 const git_utils_1 = require("../utils/git-utils.cjs");
 async function importCommand(sqlFilePath, options = {}) {
     const { includeFunctions = false, includeTriggers = false, force = false, dryRun = false } = options;
@@ -144,26 +145,143 @@ async function importCommand(sqlFilePath, options = {}) {
         }
     }
     console.log('');
+    const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+    let ignoredCount = 0;
+    const filteredTables = parsedSchema.tables.filter(table => {
+        if ((0, relqignore_1.isTableIgnored)(table.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    }).map(table => {
+        const filteredColumns = table.columns.filter(col => {
+            if ((0, relqignore_1.isColumnIgnored)(table.name, col.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        const filteredIndexes = table.indexes.filter(idx => {
+            if ((0, relqignore_1.isIndexIgnored)(table.name, idx.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        const filteredConstraints = table.constraints.filter(con => {
+            if ((0, relqignore_1.isConstraintIgnored)(table.name, con.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        return {
+            ...table,
+            columns: filteredColumns,
+            indexes: filteredIndexes,
+            constraints: filteredConstraints,
+        };
+    });
+    const filteredEnums = parsedSchema.enums.filter(e => {
+        if ((0, relqignore_1.isEnumIgnored)(e.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredDomains = parsedSchema.domains.filter(d => {
+        if ((0, relqignore_1.isDomainIgnored)(d.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredCompositeTypes = parsedSchema.compositeTypes.filter(c => {
+        if ((0, relqignore_1.isCompositeTypeIgnored)(c.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredSequences = parsedSchema.sequences.filter(s => {
+        if ((0, relqignore_1.isSequenceIgnored)(s.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredFunctions = functions.filter(f => {
+        if ((0, relqignore_1.isFunctionIgnored)(f.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredSchema = {
+        tables: filteredTables,
+        enums: filteredEnums,
+        domains: filteredDomains,
+        compositeTypes: filteredCompositeTypes,
+        sequences: filteredSequences,
+        collations: parsedSchema.collations,
+        foreignTables: parsedSchema.foreignTables,
+        views: parsedSchema.views,
+        materializedViews: parsedSchema.materializedViews,
+        foreignServers: parsedSchema.foreignServers,
+        extensions: parsedSchema.extensions,
+        partitions: parsedSchema.partitions,
+    };
+    if (ignoredCount > 0) {
+        console.log(`${git_utils_1.colors.gray(`ℹ ${ignoredCount} object(s) ignored by .relqignore`)}`);
+    }
+    const dependencyErrors = (0, relqignore_1.validateIgnoreDependencies)({
+        tables: filteredTables.map(t => ({
+            name: t.name,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                type: c.dataType,
+                default: c.defaultValue,
+            })),
+        })),
+        enums: parsedSchema.enums,
+        domains: parsedSchema.domains,
+        sequences: parsedSchema.sequences,
+        compositeTypes: parsedSchema.compositeTypes,
+    }, ignorePatterns);
+    if (dependencyErrors.length > 0) {
+        spinner.stop();
+        (0, git_utils_1.error)('Dependency validation failed:');
+        console.log('');
+        for (const depError of dependencyErrors) {
+            console.log(`  ${git_utils_1.colors.red('✗')} ${depError.message}`);
+        }
+        console.log('');
+        (0, git_utils_1.hint)('Either un-ignore the type or add the column to .relqignore');
+        process.exit(1);
+    }
     spinner.start('Generating TypeScript schema');
-    const dbSchema = convertToDbSchema(parsedSchema, functions, triggers, comments);
+    const dbSchema = convertToDbSchema(filteredSchema, filteredFunctions, triggers, comments);
     const typescriptContent = (0, type_generator_1.generateTypeScript)(dbSchema, {
         camelCase: true,
         includeFunctions,
         includeTriggers,
     });
     spinner.succeed('Generated TypeScript schema');
-    const normalizedSchema = convertToNormalizedSchema(parsedSchema, functions, triggers);
+    const incomingSchema = convertToNormalizedSchema(filteredSchema, filteredFunctions, triggers);
     const existingSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+    const replaceAll = options.theirs === true;
+    let mergedSchema;
     let changes = [];
     if (existingSnapshot) {
         spinner.start('Detecting changes');
+        mergedSchema = mergeSchemas(existingSnapshot, incomingSchema, replaceAll);
         const beforeSchema = snapshotToDbSchema(existingSnapshot);
-        const afterSchema = snapshotToDbSchema(normalizedSchema);
+        const afterSchema = snapshotToDbSchema(mergedSchema);
         changes = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
         spinner.stop();
         if (changes.length > 0) {
             console.log('');
-            console.log(`${git_utils_1.colors.bold('Changes detected:')}`);
+            console.log(`${git_utils_1.colors.bold('Changes detected:')}${replaceAll ? git_utils_1.colors.yellow(' (--theirs: full replacement)') : ''}`);
             console.log('');
             const creates = changes.filter(c => c.type === 'CREATE');
             const alters = changes.filter(c => c.type === 'ALTER');
@@ -185,11 +303,17 @@ async function importCommand(sqlFilePath, options = {}) {
                 }
             }
             if (drops.length > 0) {
-                for (const change of drops.slice(0, 10)) {
-                    console.log(`\t${git_utils_1.colors.red((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                if (replaceAll) {
+                    for (const change of drops.slice(0, 10)) {
+                        console.log(`\t${git_utils_1.colors.red((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                    }
+                    if (drops.length > 10) {
+                        console.log(`\t${git_utils_1.colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                    }
                 }
-                if (drops.length > 10) {
-                    console.log(`\t${git_utils_1.colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                else {
+                    console.log('');
+                    console.log(`${git_utils_1.colors.gray(`ℹ ${drops.length} object(s) only in existing schema (preserved)`)}`);
                 }
             }
             console.log('');
@@ -201,15 +325,22 @@ async function importCommand(sqlFilePath, options = {}) {
         }
     }
     else {
+        mergedSchema = incomingSchema;
         changes = [];
         console.log(`${git_utils_1.colors.cyan('First import')} - creating initial snapshot`);
     }
+    const mergedDbSchema = snapshotToDbSchemaForGeneration(mergedSchema);
+    const finalTypescriptContent = (0, type_generator_1.generateTypeScript)(mergedDbSchema, {
+        camelCase: true,
+        includeFunctions,
+        includeTriggers,
+    });
     if (dryRun) {
         console.log('');
         console.log(`${git_utils_1.colors.yellow('Dry run mode')} - no files written`);
         console.log('');
         console.log('Would write:');
-        console.log(`  ${git_utils_1.colors.cyan(options.output || './db/schema.ts')} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(typescriptContent.length)})`)}`);
+        console.log(`  ${git_utils_1.colors.cyan(options.output || './db/schema.ts')} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(finalTypescriptContent.length)})`)}`);
         console.log(`  ${git_utils_1.colors.cyan('.relq/snapshot.json')}`);
         if (changes.length > 0) {
             console.log(`  Stage ${changes.length} change(s)`);
@@ -223,9 +354,9 @@ async function importCommand(sqlFilePath, options = {}) {
     if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
-    fs.writeFileSync(absoluteOutputPath, typescriptContent, 'utf-8');
-    console.log(`Written ${git_utils_1.colors.cyan(outputPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(typescriptContent.length)})`)}`);
-    (0, repo_manager_1.saveSnapshot)(normalizedSchema, projectRoot);
+    fs.writeFileSync(absoluteOutputPath, finalTypescriptContent, 'utf-8');
+    console.log(`Written ${git_utils_1.colors.cyan(outputPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(finalTypescriptContent.length)})`)}`);
+    (0, repo_manager_1.saveSnapshot)(mergedSchema, projectRoot);
     if (changes.length > 0) {
         (0, repo_manager_1.addUnstagedChanges)(changes, projectRoot);
         (0, repo_manager_1.stageChanges)(['.'], projectRoot);
@@ -442,6 +573,17 @@ function convertToNormalizedSchema(parsed, functions = [], triggers = []) {
             forEach: 'STATEMENT',
             functionName: t.functionName || '',
         })),
+        views: parsed.views.map(v => ({
+            name: v.name,
+            schema: v.schema || 'public',
+            definition: v.definition,
+        })),
+        materializedViews: parsed.materializedViews.map(mv => ({
+            name: mv.name,
+            schema: mv.schema || 'public',
+            definition: mv.definition,
+            withData: mv.withData ?? true,
+        })),
     };
 }
 function snapshotToDbSchema(snapshot) {
@@ -521,4 +663,133 @@ function snapshotToDbSchema(snapshot) {
         sequences: [],
     });
 }
+function snapshotToDbSchemaForGeneration(snapshot) {
+    return {
+        tables: snapshot.tables.map(t => ({
+            name: t.name,
+            schema: t.schema || 'public',
+            comment: null,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                dataType: c.type,
+                udtName: c.type,
+                isNullable: c.nullable,
+                defaultValue: c.default ?? null,
+                isPrimaryKey: c.primaryKey || false,
+                isUnique: c.unique || false,
+                maxLength: null,
+                precision: null,
+                scale: null,
+                references: null,
+                comment: null,
+                isGenerated: c.isGenerated || false,
+                generationExpression: c.generationExpression || null,
+                identityGeneration: c.identity?.type || null,
+            })),
+            indexes: t.indexes.map(i => ({
+                name: i.name,
+                columns: Array.isArray(i.columns) ? i.columns : [i.columns],
+                isUnique: i.unique || false,
+                isPrimary: false,
+                type: i.type || 'btree',
+                definition: i.definition,
+                whereClause: i.whereClause,
+                comment: null,
+            })),
+            constraints: t.constraints?.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: [],
+                definition: c.definition,
+            })) || [],
+            rowCount: 0,
+            isPartitioned: t.isPartitioned || false,
+            partitionType: t.partitionType,
+            partitionKey: t.partitionKey ? [t.partitionKey].flat() : undefined,
+        })),
+        enums: snapshot.enums?.map(e => ({
+            name: e.name,
+            values: e.values,
+        })) || [],
+        domains: snapshot.domains?.map(d => ({
+            name: d.name,
+            baseType: d.baseType,
+            isNotNull: d.notNull || false,
+            defaultValue: d.default || null,
+            checkExpression: d.check || null,
+            check: d.check,
+            default: d.default,
+            notNull: d.notNull,
+        })) || [],
+        compositeTypes: snapshot.compositeTypes?.map(c => ({
+            name: c.name,
+            attributes: c.attributes || [],
+        })) || [],
+        sequences: snapshot.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: (snapshot.extensions || []).map(e => typeof e === 'string' ? e : e.name),
+        partitions: [],
+        functions: snapshot.functions?.map(f => ({
+            name: f.name,
+            schema: 'public',
+            returnType: f.returnType,
+            argTypes: f.argTypes || [],
+            language: f.language,
+            definition: '',
+            isAggregate: false,
+            volatility: 'VOLATILE',
+        })) || [],
+        triggers: snapshot.triggers?.map(t => ({
+            name: t.name,
+            tableName: t.table,
+            timing: t.timing,
+            event: t.events?.[0] || '',
+            functionName: t.functionName || '',
+            definition: '',
+            isEnabled: t.isEnabled ?? true,
+        })) || [],
+        policies: [],
+        foreignServers: [],
+        foreignTables: [],
+    };
+}
+function mergeSchemas(existing, incoming, replaceAll = false) {
+    if (replaceAll) {
+        return incoming;
+    }
+    function mergeByName(existingArr, incomingArr) {
+        const incomingMap = new Map(incomingArr.map(item => [item.name, item]));
+        const resultMap = new Map();
+        for (const item of existingArr) {
+            resultMap.set(item.name, item);
+        }
+        for (const item of incomingArr) {
+            resultMap.set(item.name, item);
+        }
+        return Array.from(resultMap.values());
+    }
+    return {
+        extensions: mergeByName(existing.extensions || [], incoming.extensions || []),
+        enums: mergeByName(existing.enums || [], incoming.enums || []),
+        domains: mergeByName(existing.domains || [], incoming.domains || []),
+        compositeTypes: mergeByName(existing.compositeTypes || [], incoming.compositeTypes || []),
+        sequences: mergeByName(existing.sequences || [], incoming.sequences || []),
+        collations: mergeByName(existing.collations || [], incoming.collations || []),
+        tables: mergeByName(existing.tables || [], incoming.tables || []),
+        functions: mergeByName(existing.functions || [], incoming.functions || []),
+        triggers: mergeByName(existing.triggers || [], incoming.triggers || []),
+        views: mergeByName(existing.views || [], incoming.views || []),
+        materializedViews: mergeByName(existing.materializedViews || [], incoming.materializedViews || []),
+        foreignTables: mergeByName(existing.foreignTables || [], incoming.foreignTables || []),
+    };
+}
 exports.default = importCommand;

package/dist/cjs/cli/commands/log.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.logCommand = logCommand;
 exports.historyCommand = logCommand;
+exports.showCommand = showCommand;
 const spinner_1 = require("../utils/spinner.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 function formatDate(timestamp) {
@@ -60,3 +61,77 @@ async function logCommand(context) {
         console.log('');
     }
 }
+async function showCommand(context) {
+    const { args } = context;
+    const projectRoot = process.cwd();
+    const target = args[0];
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    if (!target) {
+        console.log(`${spinner_1.colors.red('error:')} Please specify a commit or tag`);
+        console.log('');
+        console.log(`Usage: ${spinner_1.colors.cyan('relq show <commit|tag>')}`);
+        console.log('');
+        return;
+    }
+    const fs = require('fs');
+    const path = require('path');
+    const { resolveRef, loadCommit } = require("../utils/repo-manager.cjs");
+    const hash = resolveRef(target, projectRoot);
+    if (!hash) {
+        console.log(`${spinner_1.colors.red('error:')} Commit or tag not found: ${target}`);
+        console.log('');
+        console.log('Available commits:');
+        const commitsDir = path.join(projectRoot, '.relq', 'commits');
+        if (fs.existsSync(commitsDir)) {
+            const files = fs.readdirSync(commitsDir);
+            for (const f of files.slice(0, 5)) {
+                console.log(`   ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(f.replace('.json', '')))}`);
+            }
+        }
+        return;
+    }
+    const commitPath = path.join(projectRoot, '.relq', 'commits', `${hash}.json`);
+    if (!fs.existsSync(commitPath)) {
+        console.log(`${spinner_1.colors.red('error:')} Commit not found: ${hash}`);
+        return;
+    }
+    const commitData = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+    console.log(`${spinner_1.colors.yellow(`commit ${commitData.hash}`)}`);
+    console.log(`Author: ${commitData.author}`);
+    console.log(`Date:   ${formatDate(commitData.timestamp)}`);
+    console.log('');
+    console.log(`    ${commitData.message}`);
+    console.log('');
+    if (commitData.stats) {
+        console.log(`${spinner_1.colors.bold('Stats:')}`);
+        console.log(`    Tables:  ${commitData.stats.tables}`);
+        console.log(`    Columns: ${commitData.stats.columns}`);
+        console.log(`    Indexes: ${commitData.stats.indexes || 0}`);
+        console.log('');
+    }
+    if (commitData.changes && commitData.changes.length > 0) {
+        console.log(`${spinner_1.colors.bold('Changes:')}`);
+        for (const change of commitData.changes.slice(0, 20)) {
+            const symbol = change.action === 'CREATE'
+                ? spinner_1.colors.green('+')
+                : change.action === 'DROP'
+                    ? spinner_1.colors.red('-')
+                    : spinner_1.colors.yellow('~');
+            console.log(`    ${symbol} ${change.objectType.toLowerCase()}: ${change.name}`);
+        }
+        if (commitData.changes.length > 20) {
+            console.log(`    ${spinner_1.colors.muted(`... and ${commitData.changes.length - 20} more`)}`);
+        }
+        console.log('');
+    }
+    if (commitData.sql && commitData.sql.trim()) {
+        console.log(`${spinner_1.colors.bold('SQL:')}`);
+        console.log('');
+        console.log(`${spinner_1.colors.cyan(commitData.sql)}`);
+        console.log('');
+    }
+}

package/dist/cjs/cli/commands/merge.cjs

@@ -0,0 +1,224 @@
+"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.mergeCommand = mergeCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+function loadBranchState(projectRoot) {
+    const branchPath = path.join(projectRoot, '.relq', 'branches.json');
+    if (fs.existsSync(branchPath)) {
+        return JSON.parse(fs.readFileSync(branchPath, 'utf-8'));
+    }
+    const head = require("../utils/repo-manager.cjs").getHead(projectRoot);
+    return { current: 'main', branches: { main: head || '' } };
+}
+function saveBranchState(state, projectRoot) {
+    const branchPath = path.join(projectRoot, '.relq', 'branches.json');
+    fs.writeFileSync(branchPath, JSON.stringify(state, null, 2));
+}
+async function mergeCommand(context) {
+    const { config, args, flags } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    const branchName = args[0];
+    const abort = flags['abort'] === true;
+    const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+    if (abort) {
+        if (fs.existsSync(mergeStatePath)) {
+            fs.unlinkSync(mergeStatePath);
+            console.log(`${spinner_1.colors.green('✓')} Merge aborted`);
+        }
+        else {
+            console.log(`${spinner_1.colors.muted('No merge in progress.')}`);
+        }
+        console.log('');
+        return;
+    }
+    if (fs.existsSync(mergeStatePath)) {
+        const mergeState = JSON.parse(fs.readFileSync(mergeStatePath, 'utf-8'));
+        console.log(`${spinner_1.colors.red('error:')} Merge in progress from '${mergeState.fromBranch}'`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq resolve')} ${spinner_1.colors.muted('to resolve conflicts')}`);
+        console.log(`${spinner_1.colors.muted('Or')} ${spinner_1.colors.cyan('relq merge --abort')} ${spinner_1.colors.muted('to cancel')}`);
+        console.log('');
+        return;
+    }
+    if (!branchName) {
+        console.log(`${spinner_1.colors.red('error:')} Please specify a branch to merge`);
+        console.log('');
+        console.log(`Usage: ${spinner_1.colors.cyan('relq merge <branch>')}`);
+        console.log('');
+        return;
+    }
+    const state = loadBranchState(projectRoot);
+    if (!state.branches[branchName]) {
+        console.log(`${spinner_1.colors.red('error:')} Branch not found: ${branchName}`);
+        return;
+    }
+    if (branchName === state.current) {
+        console.log(`${spinner_1.colors.red('error:')} Cannot merge branch into itself`);
+        return;
+    }
+    const spinner = (0, spinner_1.createSpinner)();
+    spinner.start(`Merging '${branchName}' into '${state.current}'...`);
+    try {
+        const currentHash = (0, repo_manager_1.getHead)(projectRoot);
+        const incomingHash = state.branches[branchName];
+        if (!currentHash || !incomingHash) {
+            spinner.fail('No commits to merge');
+            return;
+        }
+        if (currentHash === incomingHash) {
+            spinner.succeed('Already up to date');
+            console.log('');
+            return;
+        }
+        const currentCommit = (0, repo_manager_1.loadCommit)(currentHash, projectRoot);
+        const incomingCommit = (0, repo_manager_1.loadCommit)(incomingHash, projectRoot);
+        if (!currentCommit || !incomingCommit) {
+            spinner.fail('Cannot load commit data');
+            return;
+        }
+        const currentSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot) || currentCommit.schema;
+        const incomingSnapshot = incomingCommit.schema;
+        if (!currentSnapshot || !incomingSnapshot) {
+            spinner.fail('No snapshot data');
+            return;
+        }
+        const conflicts = detectMergeConflicts(currentSnapshot, incomingSnapshot);
+        if (conflicts.length > 0) {
+            const mergeState = {
+                fromBranch: branchName,
+                toBranch: state.current,
+                conflicts,
+                incomingSnapshot,
+                createdAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
+            spinner.fail(`${conflicts.length} conflict(s) detected`);
+            console.log('');
+            for (const c of conflicts.slice(0, 5)) {
+                const name = c.parentName ? `${c.parentName}.${c.objectName}` : c.objectName;
+                console.log(`   ${spinner_1.colors.red('conflict:')} ${c.objectType.toLowerCase()} ${name}`);
+            }
+            if (conflicts.length > 5) {
+                console.log(`   ${spinner_1.colors.muted(`... and ${conflicts.length - 5} more`)}`);
+            }
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq resolve --all-theirs')} ${spinner_1.colors.muted('to accept incoming')}`);
+            console.log(`${spinner_1.colors.muted('Or')} ${spinner_1.colors.cyan('relq merge --abort')} ${spinner_1.colors.muted('to cancel')}`);
+            console.log('');
+            return;
+        }
+        const mergedSnapshot = mergeSnapshots(currentSnapshot, incomingSnapshot);
+        (0, repo_manager_1.saveSnapshot)(mergedSnapshot, projectRoot);
+        const author = config?.author || 'Relq CLI';
+        const message = `Merge branch '${branchName}' into ${state.current}`;
+        const commit = (0, repo_manager_1.createCommit)(mergedSnapshot, author, message, projectRoot);
+        spinner.succeed(`Merged '${branchName}' into '${state.current}'`);
+        console.log(`   ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(commit.hash))} ${message}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Merge failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+    }
+}
+function detectMergeConflicts(current, incoming) {
+    const conflicts = [];
+    for (const currentTable of current.tables) {
+        const incomingTable = incoming.tables.find(t => t.name === currentTable.name);
+        if (!incomingTable)
+            continue;
+        for (const currentCol of currentTable.columns) {
+            const incomingCol = incomingTable.columns.find(c => c.name === currentCol.name);
+            if (!incomingCol)
+                continue;
+            if (currentCol.type !== incomingCol.type) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: currentCol.name,
+                    parentName: currentTable.name,
+                    currentValue: currentCol.type,
+                    incomingValue: incomingCol.type,
+                    description: `Type differs: ${currentCol.type} vs ${incomingCol.type}`,
+                });
+            }
+        }
+    }
+    for (const currentEnum of current.enums) {
+        const incomingEnum = incoming.enums.find(e => e.name === currentEnum.name);
+        if (!incomingEnum)
+            continue;
+        const currentVals = JSON.stringify(currentEnum.values.sort());
+        const incomingVals = JSON.stringify(incomingEnum.values.sort());
+        if (currentVals !== incomingVals) {
+            conflicts.push({
+                objectType: 'ENUM',
+                objectName: currentEnum.name,
+                currentValue: currentEnum.values,
+                incomingValue: incomingEnum.values,
+                description: 'Values differ',
+            });
+        }
+    }
+    return conflicts;
+}
+function mergeSnapshots(current, incoming) {
+    const result = JSON.parse(JSON.stringify(current));
+    for (const table of incoming.tables) {
+        if (!result.tables.find(t => t.name === table.name)) {
+            result.tables.push(table);
+        }
+    }
+    for (const e of incoming.enums) {
+        if (!result.enums.find(x => x.name === e.name)) {
+            result.enums.push(e);
+        }
+    }
+    for (const d of incoming.domains) {
+        if (!result.domains.find(x => x.name === d.name)) {
+            result.domains.push(d);
+        }
+    }
+    return result;
+}
+exports.default = mergeCommand;

package/dist/cjs/cli/commands/migrate.cjs

@@ -75,7 +75,7 @@ async function migrateCommand(context) {
     console.log(`   Connection: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
     console.log(`   Migrations: ${migrationsDir}\n`);
     try {
-        const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+        const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
         const pool = new Pool({
             host: connection.host,
             port: connection.port || 5432,