relq 1.0.1 → 1.0.3

package/dist/cjs/cli/commands/pull.cjs

@@ -36,17 +36,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pullCommand = pullCommand;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const readline = __importStar(require("readline"));
 const config_loader_1 = require("../utils/config-loader.cjs");
 const fast_introspect_1 = require("../utils/fast-introspect.cjs");
 const type_generator_1 = require("../utils/type-generator.cjs");
 const env_loader_1 = require("../utils/env-loader.cjs");
-const spinner_1 = require("../utils/spinner.cjs");
+const cli_utils_1 = require("../utils/cli-utils.cjs");
 const relqignore_1 = require("../utils/relqignore.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
+const schema_comparator_1 = require("../utils/schema-comparator.cjs");
 function toCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 }
+function normalizePartitionKey(partitionKey) {
+    if (!partitionKey)
+        return undefined;
+    if (Array.isArray(partitionKey)) {
+        return partitionKey;
+    }
+    if (typeof partitionKey === 'string') {
+        return partitionKey
+            .replace(/^\{|\}$/g, '')
+            .split(',')
+            .map(k => k.trim())
+            .filter(Boolean);
+    }
+    return undefined;
+}
 function parseSchemaFileForSnapshot(schemaPath) {
     if (!fs.existsSync(schemaPath)) {
         return null;
@@ -152,86 +167,70 @@ function parseSchemaFileForSnapshot(schemaPath) {
         extensions: [],
     };
 }
-function askConfirm(question, defaultYes = true) {
-    const suffix = defaultYes ? spinner_1.colors.muted('[Y/n]') : spinner_1.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');
-        });
-    });
-}
 async function pullCommand(context) {
-    const { config, flags } = context;
+    const { config, flags, projectRoot } = context;
     if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+        (0, cli_utils_1.fatal)('No configuration found', `Run ${cli_utils_1.colors.cyan('relq init')} to create one.`);
     }
-    (0, config_loader_1.requireValidConfig)(config);
+    await (0, config_loader_1.requireValidConfig)(config, { calledFrom: 'pull' });
     const connection = config.connection;
-    const projectRoot = process.cwd();
     const force = flags['force'] === true;
+    const merge = flags['merge'] === true;
+    const noCommit = flags['no-commit'] === 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 schemaPathRaw = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
+    const schemaPath = path.resolve(projectRoot, schemaPathRaw);
     const includeFunctions = config.generate?.includeFunctions ?? false;
     const includeTriggers = config.generate?.includeTriggers ?? false;
-    const spinner = (0, spinner_1.createSpinner)();
+    const spinner = (0, cli_utils_1.createSpinner)();
     const startTime = Date.now();
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
         (0, repo_manager_1.initRepository)(projectRoot);
-        console.log(`${spinner_1.colors.cyan('ℹ')}  Initialized .relq folder`);
+        console.log('Initialized .relq folder');
     }
-    if (!force) {
-        const stagedChanges = (0, repo_manager_1.getStagedChanges)(projectRoot);
-        const unstagedChanges = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
-        if (stagedChanges.length > 0 || unstagedChanges.length > 0) {
+    const stagedChanges = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    const unstagedChanges = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    const hasLocalChanges = stagedChanges.length > 0 || unstagedChanges.length > 0;
+    let stashedSchemaContent = null;
+    const schemaFileExists = fs.existsSync(schemaPath);
+    if (hasLocalChanges) {
+        if (force) {
+            (0, repo_manager_1.clearWorkingState)(projectRoot);
+        }
+        else if (merge) {
+            if (schemaFileExists) {
+                stashedSchemaContent = fs.readFileSync(schemaPath, 'utf-8');
+            }
+            (0, repo_manager_1.clearWorkingState)(projectRoot);
+            console.log(`Stashed local file content for restore after pull`);
+        }
+        else {
             const hasUnstaged = unstagedChanges.length > 0;
             const hasStaged = stagedChanges.length > 0;
-            if (hasUnstaged && hasStaged) {
-                console.error(spinner_1.colors.red('Error: You have uncommitted and unstaged changes.'));
-            }
-            else if (hasStaged) {
-                console.error(spinner_1.colors.red('Error: You have uncommitted changes.'));
-            }
-            else {
-                console.error(spinner_1.colors.red('Error: You have unstaged changes.'));
-            }
             console.log('');
             if (hasStaged) {
-                console.log(`  ${spinner_1.colors.green('Staged (uncommitted):')} ${stagedChanges.length} change(s)`);
+                console.log(`  ${cli_utils_1.colors.green('Staged (uncommitted):')} ${stagedChanges.length} change(s)`);
             }
             if (hasUnstaged) {
-                console.log(`  ${spinner_1.colors.red('Unstaged:')} ${unstagedChanges.length} change(s)`);
+                console.log(`  ${cli_utils_1.colors.red('Unstaged:')} ${unstagedChanges.length} change(s)`);
             }
-            console.log('');
-            if (hasUnstaged && !hasStaged) {
-                console.log('Please stage and commit, or reset your changes:');
-                console.log(`  ${spinner_1.colors.cyan('relq add .')}              - stage all changes`);
-                console.log(`  ${spinner_1.colors.cyan('relq commit -m "message"')}  - then commit`);
+            let errorMsg = 'You have uncommitted changes';
+            if (hasUnstaged && hasStaged) {
+                errorMsg = 'You have uncommitted and unstaged changes';
             }
-            else {
-                console.log('Please commit or reset your changes:');
-                console.log(`  ${spinner_1.colors.cyan('relq commit -m "message"')}  - commit staged changes`);
+            else if (hasUnstaged) {
+                errorMsg = 'You have unstaged changes';
             }
-            console.log(`  ${spinner_1.colors.cyan('relq reset')}               - discard all changes`);
-            console.log(`  ${spinner_1.colors.cyan('relq pull --force')}        - force pull (overwrites local changes)`);
-            return;
+            const hint = `Commit first: ${cli_utils_1.colors.cyan('relq add . && relq commit -m "message"')}\nOr merge:    ${cli_utils_1.colors.cyan('relq pull --merge')} (preserve local edits)\nOr force:    ${cli_utils_1.colors.cyan('relq pull --force')} (discard & pull)`;
+            (0, cli_utils_1.fatal)(errorMsg, hint);
         }
     }
     try {
         spinner.start('Connecting to database...');
         await (0, repo_manager_1.ensureRemoteTable)(connection);
-        spinner.succeed(`Connected to ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+        spinner.succeed(`Connected to ${cli_utils_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
         spinner.start('Fetching remote commits...');
         const remoteCommits = await (0, repo_manager_1.fetchRemoteCommits)(connection, 100);
         const remoteHead = remoteCommits.length > 0 ? remoteCommits[0].hash : null;
@@ -245,8 +244,24 @@ async function pullCommand(context) {
             includeTriggers,
         });
         spinner.succeed(`Found ${dbSchema.tables.length} tables`);
-        const ignorePatterns = (0, relqignore_1.getIgnorePatterns)(projectRoot);
-        const filteredTables = (0, relqignore_1.filterIgnored)(dbSchema.tables, ignorePatterns);
+        const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+        const filteredTables = dbSchema.tables
+            .filter(t => !(0, relqignore_1.isTableIgnored)(t.name, ignorePatterns).ignored)
+            .map(t => ({
+            ...t,
+            columns: t.columns.filter(c => !(0, relqignore_1.isColumnIgnored)(t.name, c.name, ignorePatterns).ignored),
+            indexes: t.indexes.filter(i => !(0, relqignore_1.isIndexIgnored)(t.name, i.name, ignorePatterns).ignored),
+            constraints: t.constraints.filter(c => !(0, relqignore_1.isConstraintIgnored)(t.name, c.name, ignorePatterns).ignored),
+        }));
+        const filteredEnums = dbSchema.enums.filter(e => !(0, relqignore_1.isEnumIgnored)(e.name, ignorePatterns).ignored);
+        const filteredDomains = dbSchema.domains.filter(d => !(0, relqignore_1.isDomainIgnored)(d.name, ignorePatterns).ignored);
+        const filteredCompositeTypes = dbSchema.compositeTypes.filter(c => !(0, relqignore_1.isCompositeTypeIgnored)(c.name, ignorePatterns).ignored);
+        const filteredFunctions = includeFunctions
+            ? dbSchema.functions.filter(f => !(0, relqignore_1.isFunctionIgnored)(f.name, ignorePatterns).ignored)
+            : [];
+        const filteredTriggers = includeTriggers
+            ? dbSchema.triggers
+            : [];
         const localHead = (0, repo_manager_1.getHead)(projectRoot);
         const localSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
         const schemaExists = fs.existsSync(schemaPath);
@@ -274,13 +289,16 @@ async function pullCommand(context) {
                     type: c.type,
                     definition: c.definition,
                 })),
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: normalizePartitionKey(t.partitionKey),
             })),
-            enums: dbSchema.enums.map(e => ({
+            enums: filteredEnums.map(e => ({
                 name: e.name,
                 schema: 'public',
                 values: e.values,
             })),
-            domains: dbSchema.domains.map(d => ({
+            domains: filteredDomains.map(d => ({
                 name: d.name,
                 schema: 'public',
                 baseType: d.baseType,
@@ -288,20 +306,20 @@ async function pullCommand(context) {
                 default: d.defaultValue || null,
                 check: d.checkExpression || null,
             })),
-            compositeTypes: dbSchema.compositeTypes.map(c => ({
+            compositeTypes: filteredCompositeTypes.map(c => ({
                 name: c.name,
                 schema: 'public',
                 attributes: c.attributes,
             })),
             sequences: [],
             collations: [],
-            functions: dbSchema.functions.map(f => ({
+            functions: filteredFunctions.map(f => ({
                 name: f.name,
                 returnType: f.returnType,
                 argTypes: f.argTypes,
                 language: f.language,
             })),
-            triggers: dbSchema.triggers.map(t => ({
+            triggers: filteredTriggers.map(t => ({
                 name: t.name,
                 table: t.tableName,
                 events: [t.event],
@@ -312,59 +330,93 @@ async function pullCommand(context) {
             extensions: dbSchema.extensions.map(ext => ({ name: ext })),
         };
         console.log('');
+        const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+        if (fs.existsSync(mergeStatePath) && !force) {
+            (0, cli_utils_1.fatal)('You have unresolved merge conflicts', `Use ${cli_utils_1.colors.cyan('relq resolve')} to see and resolve conflicts\nOr use ${cli_utils_1.colors.cyan('relq pull --force')} to overwrite local`);
+        }
         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));
+            const conflicts = detectObjectConflicts(localSnapshot, currentSchema);
+            if (conflicts.length > 0 && !force) {
+                const mergeState = {
+                    conflicts,
+                    remoteSnapshot: currentSchema,
+                    createdAt: new Date().toISOString(),
+                };
+                fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
+                console.log('');
+                console.log(`Both local and remote have modified the same objects:`);
+                console.log('');
+                for (const c of conflicts.slice(0, 10)) {
+                    const name = c.parentName ? `${c.parentName}.${c.objectName}` : c.objectName;
+                    console.log(`   ${cli_utils_1.colors.red('conflict:')} ${c.objectType.toLowerCase()} ${cli_utils_1.colors.bold(name)}`);
+                    console.log(`     ${cli_utils_1.colors.muted(c.description)}`);
+                }
+                if (conflicts.length > 10) {
+                    console.log(`   ${cli_utils_1.colors.muted(`... and ${conflicts.length - 10} more`)}`);
+                }
+                (0, cli_utils_1.fatal)('Automatic merge failed; fix conflicts and then commit', `${cli_utils_1.colors.cyan('relq resolve --theirs <name>')}  Take remote version\n${cli_utils_1.colors.cyan('relq resolve --all-theirs')}     Take all remote\n${cli_utils_1.colors.cyan('relq pull --force')}             Force overwrite local`);
+            }
             if (added.length === 0 && removed.length === 0) {
-                console.log(`${spinner_1.colors.green('✓')} Already up to date with remote`);
+                console.log('Already up to date with remote');
                 console.log('');
                 return;
             }
-            console.log(`${spinner_1.colors.yellow('Remote has changes:')}`);
+            console.log(`${cli_utils_1.colors.yellow('Remote has changes:')}`);
             if (added.length > 0) {
-                console.log(`   ${spinner_1.colors.green(`+${added.length}`)} tables added`);
+                console.log(`   ${cli_utils_1.colors.green(`+${added.length}`)} tables added`);
             }
             if (removed.length > 0) {
-                console.log(`   ${spinner_1.colors.red(`-${removed.length}`)} tables removed`);
+                console.log(`   ${cli_utils_1.colors.red(`-${removed.length}`)} tables removed`);
             }
             console.log('');
             if (!dryRun) {
-                const proceed = await askConfirm(`${spinner_1.colors.bold('Pull these changes?')}`, true);
+                const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.bold('Pull these changes?')}`, true);
                 if (!proceed) {
-                    console.log('');
-                    console.log(`${spinner_1.colors.muted('Cancelled.')}`);
-                    return;
+                    (0, cli_utils_1.fatal)('Operation cancelled by user');
                 }
                 console.log('');
             }
         }
         else if (schemaExists && !force) {
-            console.log(`${spinner_1.colors.yellow('⚠')}  ${spinner_1.colors.bold('Local schema exists but not tracked')}`);
+            (0, cli_utils_1.warning)('Local schema exists but not tracked');
             console.log('');
-            console.log(`   ${spinner_1.colors.cyan(schemaPath)}`);
+            console.log(`   ${cli_utils_1.colors.cyan(schemaPath)}`);
             console.log('');
             if (!dryRun) {
-                const proceed = await askConfirm(`${spinner_1.colors.bold('Overwrite local schema?')}`, false);
+                const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.bold('Overwrite local schema?')}`, false);
                 if (!proceed) {
-                    console.log('');
-                    console.log(`${spinner_1.colors.muted('Cancelled. Run')} ${spinner_1.colors.cyan('relq status')} ${spinner_1.colors.muted('to see current state.')}`);
-                    return;
+                    (0, cli_utils_1.fatal)('Operation cancelled by user', `Run ${cli_utils_1.colors.cyan('relq status')} to see current state.`);
                 }
                 console.log('');
             }
         }
         else if (!schemaExists) {
-            console.log(`${spinner_1.colors.cyan('ℹ')}  ${spinner_1.colors.bold('First pull - creating schema')}`);
+            console.log('First pull - creating schema');
             console.log('');
-            console.log(`📊 ${spinner_1.colors.bold('Schema Summary')}`);
-            console.log(`   ${spinner_1.colors.green(String(filteredTables.length))} tables`);
-            console.log(`   ${spinner_1.colors.green(String(dbSchema.extensions.length))} extensions`);
+            const indexCount = filteredTables.reduce((sum, t) => sum + (t.indexes?.filter(i => !i.isPrimary).length || 0), 0);
+            const partitionCount = filteredTables.filter(t => t.isPartitioned).length;
+            const tableCommentCount = filteredTables.filter(t => t.comment).length;
+            const columnCommentCount = filteredTables.reduce((sum, t) => sum + t.columns.filter(c => c.comment).length, 0);
+            console.log('Schema Summary:');
+            console.log(`   ${cli_utils_1.colors.green(String(filteredTables.length))} tables`);
+            if (indexCount > 0)
+                console.log(`   ${cli_utils_1.colors.green(String(indexCount))} indexes`);
+            if (partitionCount > 0)
+                console.log(`   ${cli_utils_1.colors.green(String(partitionCount))} partitioned tables`);
+            if (tableCommentCount > 0)
+                console.log(`   ${cli_utils_1.colors.green(String(tableCommentCount))} table comments`);
+            if (columnCommentCount > 0)
+                console.log(`   ${cli_utils_1.colors.green(String(columnCommentCount))} column comments`);
+            if (dbSchema.extensions.length > 0)
+                console.log(`   ${cli_utils_1.colors.green(String(dbSchema.extensions.length))} extensions`);
             console.log('');
         }
         if (dryRun) {
-            console.log(`${spinner_1.colors.yellow('⚠')} Dry run - no files written`);
+            console.log('Dry run - no files written');
             console.log('');
             return;
         }
@@ -385,26 +437,200 @@ async function pullCommand(context) {
         spinner.start('Writing schema file...');
         fs.writeFileSync(schemaPath, typescript, 'utf-8');
         const fileSize = Buffer.byteLength(typescript, 'utf8');
-        spinner.succeed(`Written ${spinner_1.colors.cyan(schemaPath)} ${spinner_1.colors.muted(`(${(0, spinner_1.formatBytes)(fileSize)})`)}`);
-        const snapshotFromFile = parseSchemaFileForSnapshot(schemaPath);
-        if (snapshotFromFile) {
-            (0, repo_manager_1.saveSnapshot)(snapshotFromFile, projectRoot);
+        spinner.succeed(`Written ${cli_utils_1.colors.cyan(schemaPath)} ${cli_utils_1.colors.muted(`(${(0, cli_utils_1.formatBytes)(fileSize)})`)}`);
+        const fileHash = (0, repo_manager_1.hashFileContent)(typescript);
+        (0, repo_manager_1.saveFileHash)(fileHash, projectRoot);
+        const oldSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        const beforeSchema = oldSnapshot ? {
+            extensions: oldSnapshot.extensions?.map(e => e.name) || [],
+            enums: oldSnapshot.enums || [],
+            domains: oldSnapshot.domains?.map(d => ({
+                name: d.name,
+                baseType: d.baseType,
+                isNotNull: d.notNull,
+                defaultValue: d.default,
+                checkExpression: d.check,
+            })) || [],
+            compositeTypes: oldSnapshot.compositeTypes || [],
+            sequences: oldSnapshot.sequences || [],
+            tables: oldSnapshot.tables.map(t => ({
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    dataType: c.type,
+                    isNullable: c.nullable,
+                    defaultValue: c.default,
+                    isPrimaryKey: c.primaryKey,
+                    isUnique: c.unique,
+                    comment: c.comment,
+                })),
+                indexes: t.indexes.map(i => ({
+                    name: i.name,
+                    columns: i.columns,
+                    isUnique: i.unique,
+                    type: i.type,
+                })),
+                constraints: t.constraints || [],
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: t.partitionKey,
+                comment: t.comment,
+            })),
+            functions: oldSnapshot.functions || [],
+            triggers: oldSnapshot.triggers || [],
+        } : {
+            extensions: [],
+            enums: [],
+            domains: [],
+            compositeTypes: [],
+            sequences: [],
+            tables: [],
+            functions: [],
+            triggers: [],
+        };
+        const afterSchema = {
+            extensions: dbSchema.extensions || [],
+            enums: filteredEnums || [],
+            domains: filteredDomains?.map(d => ({
+                name: d.name,
+                baseType: d.baseType,
+                isNotNull: d.isNotNull,
+                defaultValue: d.defaultValue,
+                checkExpression: d.checkExpression,
+            })) || [],
+            compositeTypes: filteredCompositeTypes || [],
+            sequences: [],
+            tables: filteredTables.map(t => ({
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    dataType: c.dataType,
+                    isNullable: c.isNullable,
+                    defaultValue: c.defaultValue,
+                    isPrimaryKey: c.isPrimaryKey,
+                    isUnique: c.isUnique,
+                    comment: c.comment,
+                })),
+                indexes: t.indexes.map(i => ({
+                    name: i.name,
+                    columns: i.columns,
+                    isUnique: i.isUnique,
+                    type: i.type,
+                })),
+                constraints: t.constraints || [],
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: t.partitionKey,
+                childPartitions: t.childPartitions,
+                comment: t.comment,
+            })),
+            functions: filteredFunctions || [],
+            triggers: filteredTriggers || [],
+        };
+        const schemaChanges = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
+        (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
+        const duration = Date.now() - startTime;
+        if (noCommit) {
+            if (schemaChanges.length > 0) {
+                (0, repo_manager_1.addUnstagedChanges)(schemaChanges, projectRoot);
+                spinner.succeed(`Detected ${schemaChanges.length} schema change(s)`);
+            }
+            console.log('');
+            console.log(`Pull completed in ${(0, cli_utils_1.formatDuration)(duration)}`);
+            if (schemaChanges.length > 0) {
+                console.log('');
+                console.log(`${cli_utils_1.colors.green(String(schemaChanges.length))} change(s) ready to stage`);
+                console.log(`hint: run ${cli_utils_1.colors.cyan("'relq add .'")} to stage all changes`);
+            }
+            else {
+                console.log('Already up to date');
+            }
         }
         else {
-            (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
+            const connectionDesc = (0, env_loader_1.getConnectionDescription)(connection);
+            const commitMessage = `pull: sync from ${connectionDesc}`;
+            const commit = (0, repo_manager_1.createCommit)(currentSchema, author, commitMessage, projectRoot);
+            (0, repo_manager_1.clearWorkingState)(projectRoot);
+            console.log('');
+            console.log(`Pull completed in ${(0, cli_utils_1.formatDuration)(duration)}`);
+            console.log('');
+            console.log(`${cli_utils_1.colors.yellow('→')} ${(0, repo_manager_1.shortHash)(commit.hash)} ${commitMessage}`);
+            console.log(`  ${cli_utils_1.colors.green(String(commit.stats.tables))} tables, ${cli_utils_1.colors.green(String(commit.stats.columns))} columns`);
+            if (stashedSchemaContent) {
+                fs.writeFileSync(schemaPath, stashedSchemaContent, 'utf-8');
+                console.log('');
+                console.log(`${cli_utils_1.colors.yellow('Restored')} local schema file content`);
+                console.log(`hint: run ${cli_utils_1.colors.cyan("'relq add .'")} to detect changes against the new snapshot`);
+            }
         }
-        spinner.start('Creating commit...');
-        const message = localHead ? 'Pulled schema from database' : 'Initial schema pull';
-        const commit = (0, repo_manager_1.createCommit)(currentSchema, author, message, projectRoot);
-        spinner.succeed(`Created commit ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(commit.hash))}`);
-        const duration = Date.now() - startTime;
-        console.log('');
-        console.log(`${spinner_1.colors.green('✓')} Pull completed in ${spinner_1.colors.cyan(`${duration}ms`)}`);
         console.log('');
     }
-    catch (error) {
+    catch (err) {
         spinner.fail('Pull failed');
-        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
-        process.exit(1);
+        (0, cli_utils_1.fatal)(err instanceof Error ? err.message : String(err));
+    }
+}
+function detectObjectConflicts(local, remote) {
+    const conflicts = [];
+    for (const localTable of local.tables) {
+        const remoteTable = remote.tables.find(t => t.name === localTable.name);
+        if (!remoteTable)
+            continue;
+        for (const localCol of localTable.columns) {
+            const remoteCol = remoteTable.columns.find(c => c.name === localCol.name);
+            if (!remoteCol)
+                continue;
+            if (localCol.type !== remoteCol.type) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: localCol.name,
+                    parentName: localTable.name,
+                    localValue: localCol.type,
+                    remoteValue: remoteCol.type,
+                    description: `Type changed: ${localCol.type} → ${remoteCol.type}`,
+                });
+            }
+            else if (localCol.nullable !== remoteCol.nullable) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: localCol.name,
+                    parentName: localTable.name,
+                    localValue: localCol.nullable,
+                    remoteValue: remoteCol.nullable,
+                    description: `Nullable changed: ${localCol.nullable} → ${remoteCol.nullable}`,
+                });
+            }
+            else if (String(localCol.default || '') !== String(remoteCol.default || '')) {
+                if (localCol.default && remoteCol.default && localCol.default !== remoteCol.default) {
+                    conflicts.push({
+                        objectType: 'COLUMN',
+                        objectName: localCol.name,
+                        parentName: localTable.name,
+                        localValue: localCol.default,
+                        remoteValue: remoteCol.default,
+                        description: `Default changed`,
+                    });
+                }
+            }
+        }
+    }
+    for (const localEnum of local.enums) {
+        const remoteEnum = remote.enums.find(e => e.name === localEnum.name);
+        if (!remoteEnum)
+            continue;
+        const localVals = JSON.stringify(localEnum.values.sort());
+        const remoteVals = JSON.stringify(remoteEnum.values.sort());
+        if (localVals !== remoteVals) {
+            conflicts.push({
+                objectType: 'ENUM',
+                objectName: localEnum.name,
+                localValue: localEnum.values,
+                remoteValue: remoteEnum.values,
+                description: `Values differ`,
+            });
+        }
     }
+    return conflicts;
 }