relq 1.0.1 → 1.0.3

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

@@ -4,7 +4,7 @@ import * as readline from 'readline';
 import { loadEnvConfig } from "../utils/env-loader.js";
 import { initRepository, ensureRemoteTable, isInitialized } from "../utils/repo-manager.js";
 import { createDefaultRelqignore } from "../utils/relqignore.js";
-import { colors, createSpinner } from "../utils/spinner.js";
+import { colors, createSpinner, fatal, warning, hint } from "../utils/cli-utils.js";
 function ask(rl, question, defaultValue) {
     const suffix = defaultValue ? ` ${colors.muted(`[${defaultValue}]`)}` : '';
     return new Promise((resolve) => {
@@ -120,11 +120,9 @@ export async function initCommand(context) {
     const cwd = process.cwd();
     const spinner = createSpinner();
     console.log('');
-    console.log(`${colors.bold('Relq')} - Git-like schema versioning for PostgreSQL`);
-    console.log('');
     const { findConfigFileRecursive } = await import("../utils/config-loader.js");
+    const { findProjectRoot } = await import("../utils/project-root.js");
     const existingConfig = findConfigFileRecursive(cwd);
-    const localRelqExists = isInitialized(cwd);
     let projectRoot = cwd;
     let existingConfigValues = null;
     if (existingConfig) {
@@ -136,28 +134,35 @@ export async function initCommand(context) {
         catch {
         }
         if (existingConfig.directory !== cwd) {
-            console.log(`${colors.cyan('ℹ')}  Found ${colors.cyan('relq.config.ts')} in parent directory:`);
-            console.log(`   ${colors.muted(existingConfig.path)}`);
+            hint(`Found relq.config.ts in: ${colors.cyan(existingConfig.directory)}`);
+            console.log(`   Initializing at project root...`);
             console.log('');
-            console.log(`${colors.muted('Run commands from project root:')} ${colors.cyan(existingConfig.directory)}`);
+        }
+    }
+    else {
+        const packageRoot = findProjectRoot(cwd);
+        if (packageRoot && packageRoot !== cwd) {
+            projectRoot = packageRoot;
+            hint(`Found package.json in: ${colors.cyan(packageRoot)}`);
+            console.log(`   Initializing at project root...`);
             console.log('');
-            return;
         }
+    }
+    if (existingConfig && existingConfig.directory === projectRoot) {
         const relqFolderExists = isInitialized(projectRoot);
         if (relqFolderExists) {
-            console.log(`${colors.green('✓')} Relq is already initialized.`);
+            console.log(`${colors.green('Relq is already initialized.')}`);
             console.log('');
-            console.log(`   ${colors.green('●')} ${colors.muted('relq.config.ts')}`);
-            console.log(`   ${colors.green('●')} ${colors.muted('.relq/')} folder`);
+            console.log(`   ${colors.dim('-')} relq.config.ts`);
+            console.log(`   ${colors.dim('-')} .relq/ folder`);
             console.log('');
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq status')} ${colors.muted('to see current state.')}`);
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq pull')} ${colors.muted('to sync with database.')}`);
+            hint(`Use ${colors.cyan('relq status')} to see current state`);
+            hint(`Use ${colors.cyan('relq pull')} to sync with database`);
             return;
         }
         else {
-            console.log(`${colors.yellow('⚠')}  Found ${colors.cyan('relq.config.ts')} but ${colors.cyan('.relq/')} folder is missing.`);
-            console.log('');
-            console.log(`${colors.muted('This could mean the setup was incomplete.')}`);
+            warning('Found relq.config.ts but .relq/ folder is missing');
+            hint('This could mean the setup was incomplete');
             console.log('');
             const rl = readline.createInterface({
                 input: process.stdin,
@@ -181,12 +186,12 @@ export async function initCommand(context) {
                     }
                     if (missingFields.length > 0) {
                         console.log('');
-                        console.log(`${colors.yellow('⚠')}  Your config is missing required fields:`);
+                        warning('Your config is missing required fields:');
                         for (const field of missingFields) {
-                            console.log(`   ${colors.red('●')} ${field}`);
+                            console.log(`   ${colors.dim('-')} ${field}`);
                         }
                         console.log('');
-                        console.log(`${colors.cyan('●')} Let's fill in the missing fields:`);
+                        console.log(`${colors.dim("Let's fill in the missing fields:")}`);
                         console.log('');
                         let authorValue = existingConfigValues?.author;
                         let schemaValue = existingConfigValues?.schema;
@@ -198,9 +203,9 @@ export async function initCommand(context) {
                         }
                         if (missingFields.includes('connection')) {
                             console.log('');
-                            console.log(`${colors.red('●')} Connection not configured.`);
-                            console.log(`   ${colors.muted('Set DATABASE_* environment variables in .env')}`);
-                            console.log(`   ${colors.muted('or update relq.config.ts with connection details.')}`);
+                            console.log('Connection not configured.');
+                            console.log('   Set DATABASE_* environment variables in .env');
+                            console.log('   or update relq.config.ts with connection details.');
                             rl.close();
                             return;
                         }
@@ -226,18 +231,18 @@ export async function initCommand(context) {
                     }
                     rl.close();
                     console.log('');
-                    console.log(`${colors.cyan('●')} Completing setup...`);
+                    console.log('Completing setup...');
                     console.log('');
                     initRepository(projectRoot);
-                    console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relq/')} folder`);
+                    console.log('   Created .relq/ folder');
                     createDefaultRelqignore(projectRoot);
-                    console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relqignore')}`);
+                    console.log('   Created .relqignore');
                     const gitignorePath = path.join(projectRoot, '.gitignore');
                     if (fs.existsSync(gitignorePath)) {
                         const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
                         if (!gitignore.includes('.relq')) {
                             fs.appendFileSync(gitignorePath, '\n# Relq local state\n.relq/\n');
-                            console.log(`   ${colors.green('✓')} Added ${colors.cyan('.relq/')} to .gitignore`);
+                            console.log('   Added .relq/ to .gitignore');
                         }
                     }
                     if (existingConfigValues?.connection) {
@@ -251,9 +256,15 @@ export async function initCommand(context) {
                         }
                     }
                     console.log('');
-                    console.log(`${colors.green('✓')} Setup complete!`);
+                    console.log('Setup complete!');
                     console.log('');
-                    console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('to sync with database.')}`);
+                    const calledFrom = context.flags['called-from'];
+                    if (calledFrom) {
+                        console.log(`Continuing with ${calledFrom}...`);
+                    }
+                    else {
+                        console.log('Run "relq pull" to sync with database.');
+                    }
                     return;
                 }
                 rl.close();
@@ -272,7 +283,7 @@ export async function initCommand(context) {
         output: process.stdout,
     });
     try {
-        console.log(`${colors.cyan('●')} Checking for database connection...`);
+        console.log('Checking for database connection...');
         console.log('');
         const envCheck = checkEnvVars();
         let useEnv = false;
@@ -282,28 +293,28 @@ export async function initCommand(context) {
         let user = 'postgres';
         let password = '';
         if (envCheck.found) {
-            console.log(`${colors.green('✓')} Found database environment variables:`);
+            console.log('Found database environment variables:');
             if (envCheck.vars.RELQ_PG_CONN_URL) {
-                console.log(`   ${colors.green('✓')} RELQ_PG_CONN_URL`);
+                console.log('   RELQ_PG_CONN_URL');
             }
             else {
                 if (envCheck.vars.DATABASE_HOST)
-                    console.log(`   ${colors.green('✓')} DATABASE_HOST: ${envCheck.vars.DATABASE_HOST}`);
+                    console.log(`   DATABASE_HOST: ${envCheck.vars.DATABASE_HOST}`);
                 if (envCheck.vars.DATABASE_PORT)
-                    console.log(`   ${colors.green('✓')} DATABASE_PORT: ${envCheck.vars.DATABASE_PORT}`);
+                    console.log(`   DATABASE_PORT: ${envCheck.vars.DATABASE_PORT}`);
                 if (envCheck.vars.DATABASE_NAME)
-                    console.log(`   ${colors.green('✓')} DATABASE_NAME: ${envCheck.vars.DATABASE_NAME}`);
+                    console.log(`   DATABASE_NAME: ${envCheck.vars.DATABASE_NAME}`);
                 if (envCheck.vars.DATABASE_USER)
-                    console.log(`   ${colors.green('✓')} DATABASE_USER: ${envCheck.vars.DATABASE_USER}`);
+                    console.log(`   DATABASE_USER: ${envCheck.vars.DATABASE_USER}`);
                 if (envCheck.vars.DATABASE_PASSWORD)
-                    console.log(`   ${colors.green('✓')} DATABASE_PASSWORD: ***`);
+                    console.log('   DATABASE_PASSWORD: ***');
             }
             console.log('');
             useEnv = await askYesNo(rl, 'Use these environment variables?', true);
             console.log('');
         }
         if (!useEnv) {
-            console.log(`${colors.cyan('●')} Database Connection`);
+            console.log('Database Connection');
             console.log('');
             host = await ask(rl, '  Host', 'localhost');
             port = await ask(rl, '  Port', '5432');
@@ -313,21 +324,21 @@ export async function initCommand(context) {
             console.log('');
         }
         const detectedPath = detectSchemaPath();
-        console.log(`${colors.cyan('●')} Schema Configuration`);
+        console.log('Schema Configuration');
         console.log('');
         const schemaPath = await ask(rl, '  Schema file path', detectedPath);
         console.log('');
-        console.log(`${colors.cyan('●')} Author (for commit history)`);
+        console.log('Author (for commit history)');
         console.log('');
         const author = await ask(rl, '  Name <email>', 'Developer <dev@example.com>');
         console.log('');
-        console.log(`${colors.cyan('●')} Features to track`);
+        console.log('Features to track');
         console.log('');
         const includeFunctions = await askYesNo(rl, '  Include functions?', false);
         const includeTriggers = await askYesNo(rl, '  Include triggers?', false);
         console.log('');
         rl.close();
-        console.log(`${colors.cyan('●')} Creating files...`);
+        console.log('Creating files...');
         console.log('');
         const configPath = path.join(cwd, 'relq.config.ts');
         if (!fs.existsSync(configPath)) {
@@ -344,26 +355,26 @@ export async function initCommand(context) {
                 includeTriggers,
             });
             fs.writeFileSync(configPath, configContent, 'utf-8');
-            console.log(`   ${colors.green('✓')} Created ${colors.cyan('relq.config.ts')}`);
+            console.log('   Created relq.config.ts');
         }
         else {
-            console.log(`   ${colors.yellow('○')} ${colors.cyan('relq.config.ts')} already exists`);
+            console.log('   relq.config.ts already exists');
         }
         initRepository(cwd);
-        console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relq/')} folder`);
+        console.log('   Created .relq/ folder');
         createDefaultRelqignore(cwd);
-        console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relqignore')}`);
+        console.log('   Created .relqignore');
         const schemaDir = path.dirname(schemaPath);
         if (!fs.existsSync(schemaDir)) {
             fs.mkdirSync(schemaDir, { recursive: true });
-            console.log(`   ${colors.green('✓')} Created ${colors.cyan(schemaDir + '/')}`);
+            console.log(`   Created ${schemaDir}/`);
         }
         const gitignorePath = path.join(cwd, '.gitignore');
         if (fs.existsSync(gitignorePath)) {
             const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
             if (!gitignore.includes('.relq')) {
                 fs.appendFileSync(gitignorePath, '\n# Relq local state\n.relq/\n');
-                console.log(`   ${colors.green('✓')} Added ${colors.cyan('.relq/')} to ${colors.cyan('.gitignore')}`);
+                console.log('   Added .relq/ to .gitignore');
             }
         }
         console.log('');
@@ -382,20 +393,19 @@ export async function initCommand(context) {
         }
         catch (error) {
             spinner.fail('Could not connect to database');
-            console.log(`   ${colors.yellow('⚠')}  ${colors.muted('Run relq pull after fixing connection')}`);
+            hint("run 'relq pull' after fixing connection");
         }
         console.log('');
-        console.log(`${colors.green('✓')} ${colors.bold('Relq initialized successfully!')}`);
+        console.log('Relq initialized successfully!');
         console.log('');
-        console.log(`${colors.bold('Next steps:')}`);
-        console.log(`  1. Review ${colors.cyan('relq.config.ts')}`);
-        console.log(`  2. Run ${colors.cyan('relq pull')} to sync with database`);
-        console.log(`  3. Run ${colors.cyan('relq status')} to see current state`);
+        console.log('Next steps:');
+        console.log("  1. Review 'relq.config.ts'");
+        console.log("  2. Run 'relq pull' to sync with database");
+        console.log("  3. Run 'relq status' to see current state");
         console.log('');
     }
     catch (error) {
         rl.close();
-        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
-        process.exit(1);
+        fatal('Initialization failed', error instanceof Error ? error.message : String(error));
     }
 }

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

@@ -1,6 +1,7 @@
 import * as fs from 'fs';
 import * as readline from 'readline';
 import { parseSqlToDefineTable } from "../../introspect/index.js";
+import { fatal } from "../utils/cli-utils.js";
 function readStdin() {
     return new Promise((resolve) => {
         let data = '';
@@ -43,8 +44,7 @@ export async function introspectCommand(context) {
     let sql;
     if (filePath) {
         if (!fs.existsSync(filePath)) {
-            console.error(`Error: File not found: ${filePath}`);
-            process.exit(1);
+            fatal(`File not found: ${filePath}`, 'Check the file path and try again.');
         }
         sql = fs.readFileSync(filePath, 'utf-8');
         console.log(`📄 Reading from: ${filePath}\n`);
@@ -56,10 +56,7 @@ export async function introspectCommand(context) {
         sql = await readInteractive();
     }
     if (!sql.trim()) {
-        console.error('Error: No SQL input provided.');
-        console.error('Usage: relq introspect --file schema.sql');
-        console.error('   or: cat schema.sql | relq introspect');
-        process.exit(1);
+        fatal('No SQL input provided', 'Usage: relq introspect --file schema.sql\n   or: cat schema.sql | relq introspect');
     }
     console.log('🔍 Parsing SQL...\n');
     try {
@@ -80,8 +77,7 @@ export async function introspectCommand(context) {
         console.log(output.join('\n'));
     }
     catch (error) {
-        console.error('Error parsing SQL:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        fatal('Error parsing SQL', error instanceof Error ? error.message : String(error));
     }
 }
 function generateDefineTableCode(table) {

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

@@ -1,4 +1,4 @@
-import { colors } from "../utils/spinner.js";
+import { colors, fatal, hint } from "../utils/cli-utils.js";
 import { isInitialized, getHead, getCommitHistory, shortHash, } from "../utils/repo-manager.js";
 function formatDate(timestamp) {
     const date = new Date(timestamp);
@@ -12,23 +12,18 @@ function formatDate(timestamp) {
     return `${dayName} ${monthName} ${day} ${time} ${year}`;
 }
 export async function logCommand(context) {
-    const { flags } = context;
-    const projectRoot = process.cwd();
+    const { flags, projectRoot } = context;
     const limit = parseInt(flags['n']) || 10;
     const oneline = flags['oneline'] === 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;
+        fatal('not a relq repository (or any parent directories): .relq', "run 'relq init' to initialize");
     }
     const head = getHead(projectRoot);
     const commits = getCommitHistory(limit, projectRoot);
     if (commits.length === 0) {
-        console.log(`${colors.muted('No commits yet.')}`);
-        console.log('');
-        console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to create first commit.')}`);
+        console.log('No commits yet.');
+        hint("run 'relq commit -m <message>' to create first commit");
         console.log('');
         return;
     }
@@ -56,4 +51,77 @@ export async function logCommand(context) {
         console.log('');
     }
 }
+export async function showCommand(context) {
+    const { args, projectRoot } = context;
+    const target = args[0];
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    if (!target) {
+        console.log(`${colors.red('error:')} Please specify a commit or tag`);
+        console.log('');
+        console.log(`Usage: ${colors.cyan('relq show <commit|tag>')}`);
+        console.log('');
+        return;
+    }
+    const fs = require('fs');
+    const path = require('path');
+    const { resolveRef, loadCommit } = require('../utils/repo-manager');
+    const hash = resolveRef(target, projectRoot);
+    if (!hash) {
+        console.log(`${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(`   ${colors.yellow(shortHash(f.replace('.json', '')))}`);
+            }
+        }
+        return;
+    }
+    const commitPath = path.join(projectRoot, '.relq', 'commits', `${hash}.json`);
+    if (!fs.existsSync(commitPath)) {
+        console.log(`${colors.red('error:')} Commit not found: ${hash}`);
+        return;
+    }
+    const commitData = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+    console.log(`${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(`${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(`${colors.bold('Changes:')}`);
+        for (const change of commitData.changes.slice(0, 20)) {
+            const symbol = change.action === 'CREATE'
+                ? colors.green('+')
+                : change.action === 'DROP'
+                    ? colors.red('-')
+                    : colors.yellow('~');
+            console.log(`    ${symbol} ${change.objectType.toLowerCase()}: ${change.name}`);
+        }
+        if (commitData.changes.length > 20) {
+            console.log(`    ${colors.muted(`... and ${commitData.changes.length - 20} more`)}`);
+        }
+        console.log('');
+    }
+    if (commitData.sql && commitData.sql.trim()) {
+        console.log(`${colors.bold('SQL:')}`);
+        console.log('');
+        console.log(`${colors.cyan(commitData.sql)}`);
+        console.log('');
+    }
+}
 export { logCommand as historyCommand };

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

@@ -0,0 +1,171 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors, createSpinner, fatal } from "../utils/cli-utils.js";
+import { isInitialized, getHead, loadCommit, loadSnapshot, saveSnapshot, createCommit, shortHash, } from "../utils/repo-manager.js";
+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').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));
+}
+export async function mergeCommand(context) {
+    const { config, args, flags, projectRoot } = context;
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        fatal('not a relq repository (or any parent directories): .relq', `Run ${colors.cyan('relq init')} to initialize.`);
+    }
+    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('Merge aborted');
+            console.log('');
+            return;
+        }
+        else {
+            fatal('There is no merge to abort (MERGE_STATE missing)');
+        }
+    }
+    if (fs.existsSync(mergeStatePath)) {
+        const mergeState = JSON.parse(fs.readFileSync(mergeStatePath, 'utf-8'));
+        fatal(`Merge in progress from '${mergeState.fromBranch}'`, `Use ${colors.cyan('relq resolve')} to resolve conflicts\nOr ${colors.cyan('relq merge --abort')} to cancel`);
+    }
+    if (!branchName) {
+        fatal('Please specify a branch to merge', `Usage: ${colors.cyan('relq merge <branch>')}`);
+    }
+    const state = loadBranchState(projectRoot);
+    if (!state.branches[branchName]) {
+        fatal(`Branch not found: ${branchName}`, `Use ${colors.cyan('relq branch')} to list available branches.`);
+    }
+    if (branchName === state.current) {
+        fatal('Cannot merge branch into itself');
+    }
+    const spinner = createSpinner();
+    spinner.start(`Merging '${branchName}' into '${state.current}'...`);
+    try {
+        const currentHash = getHead(projectRoot);
+        const incomingHash = state.branches[branchName];
+        if (!currentHash || !incomingHash) {
+            spinner.stop();
+            fatal('No commits to merge', `Run ${colors.cyan('relq pull')} first.`);
+        }
+        if (currentHash === incomingHash) {
+            spinner.succeed('Already up to date');
+            console.log('');
+            return;
+        }
+        const currentCommit = loadCommit(currentHash, projectRoot);
+        const incomingCommit = loadCommit(incomingHash, projectRoot);
+        if (!currentCommit || !incomingCommit) {
+            spinner.stop();
+            fatal('Cannot load commit data - repository may be corrupt');
+        }
+        const currentSnapshot = loadSnapshot(projectRoot) || currentCommit.schema;
+        const incomingSnapshot = incomingCommit.schema;
+        if (!currentSnapshot || !incomingSnapshot) {
+            spinner.stop();
+            fatal('No snapshot data - repository may be corrupt');
+        }
+        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(`   ${colors.red('conflict:')} ${c.objectType.toLowerCase()} ${name}`);
+            }
+            if (conflicts.length > 5) {
+                console.log(`   ${colors.muted(`... and ${conflicts.length - 5} more`)}`);
+            }
+            fatal(`Automatic merge failed; fix conflicts and then commit`, `Use ${colors.cyan('relq resolve --all-theirs')} to accept incoming\nOr ${colors.cyan('relq merge --abort')} to cancel`);
+        }
+        const mergedSnapshot = mergeSnapshots(currentSnapshot, incomingSnapshot);
+        saveSnapshot(mergedSnapshot, projectRoot);
+        const author = config?.author || 'Relq CLI';
+        const message = `Merge branch '${branchName}' into ${state.current}`;
+        const commit = createCommit(mergedSnapshot, author, message, projectRoot);
+        spinner.succeed(`Merged '${branchName}' into '${state.current}'`);
+        console.log(`   ${colors.yellow(shortHash(commit.hash))} ${message}`);
+        console.log('');
+    }
+    catch (err) {
+        spinner.fail('Merge failed');
+        fatal(err instanceof Error ? err.message : String(err));
+    }
+}
+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;
+}
+export default mergeCommand;