relq 1.0.1 → 1.0.2

package/dist/cjs/cli/commands/add.cjs

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.addCommand = addCommand;
 exports.getRelatedChanges = getRelatedChanges;
 const spinner_1 = require("../utils/spinner.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
+const config_1 = require("../../config/config.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 const change_tracker_1 = require("../utils/change-tracker.cjs");
 async function addCommand(context) {
@@ -15,8 +17,31 @@ async function addCommand(context) {
         console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('first.')}`);
         return;
     }
-    const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    const allUnstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
     const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+    const config = await (0, config_1.loadConfig)();
+    const unstaged = allUnstaged.filter(change => {
+        const objectType = change.objectType;
+        const result = (0, relqignore_1.isIgnored)(objectType, change.objectName, change.parentName || null, ignorePatterns);
+        if (result.ignored) {
+            return false;
+        }
+        if (['FUNCTION', 'PROCEDURE'].includes(change.objectType) && !config.includeFunctions) {
+            return false;
+        }
+        if (change.objectType === 'TRIGGER' && !config.includeTriggers) {
+            return false;
+        }
+        if (['VIEW', 'MATERIALIZED_VIEW'].includes(change.objectType) && !config.includeViews) {
+            return false;
+        }
+        if (change.objectType === 'FOREIGN_TABLE' && !config.includeFDW) {
+            return false;
+        }
+        return true;
+    });
+    const filteredCount = allUnstaged.length - unstaged.length;
     if (unstaged.length === 0) {
         if (staged.length > 0) {
             console.log(`${spinner_1.colors.green('✓')} All changes are already staged`);
@@ -24,6 +49,10 @@ async function addCommand(context) {
             console.log('');
             console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to commit.')}`);
         }
+        else if (filteredCount > 0) {
+            console.log(`${spinner_1.colors.green('✓')} No stageable changes`);
+            console.log(`${spinner_1.colors.muted(`${filteredCount} change(s) filtered by .relqignore or config`)}`);
+        }
         else {
             console.log(`${spinner_1.colors.green('✓')} No changes to stage`);
             console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq pull')} ${spinner_1.colors.muted('or')} ${spinner_1.colors.cyan('relq import')} ${spinner_1.colors.muted('to detect changes.')}`);

package/dist/cjs/cli/commands/branch.cjs

@@ -0,0 +1,141 @@
+"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.branchCommand = branchCommand;
+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 = (0, repo_manager_1.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 branchCommand(context) {
+    const { 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 state = loadBranchState(projectRoot);
+    const deleteFlag = flags['d'] === true || flags['delete'] === true;
+    const renameFlag = flags['m'] === true || flags['move'] === true;
+    if (deleteFlag) {
+        const branchName = args[0];
+        if (!branchName) {
+            console.log(`${spinner_1.colors.red('error:')} Please specify branch name`);
+            return;
+        }
+        if (branchName === state.current) {
+            console.log(`${spinner_1.colors.red('error:')} Cannot delete current branch`);
+            return;
+        }
+        if (!state.branches[branchName]) {
+            console.log(`${spinner_1.colors.red('error:')} Branch not found: ${branchName}`);
+            return;
+        }
+        delete state.branches[branchName];
+        saveBranchState(state, projectRoot);
+        console.log(`${spinner_1.colors.green('✓')} Deleted branch '${branchName}'`);
+        console.log('');
+        return;
+    }
+    if (renameFlag) {
+        const oldName = args[0];
+        const newName = args[1];
+        if (!oldName || !newName) {
+            console.log(`${spinner_1.colors.red('error:')} Usage: relq branch -m <old> <new>`);
+            return;
+        }
+        if (!state.branches[oldName]) {
+            console.log(`${spinner_1.colors.red('error:')} Branch not found: ${oldName}`);
+            return;
+        }
+        if (state.branches[newName]) {
+            console.log(`${spinner_1.colors.red('error:')} Branch already exists: ${newName}`);
+            return;
+        }
+        state.branches[newName] = state.branches[oldName];
+        delete state.branches[oldName];
+        if (state.current === oldName)
+            state.current = newName;
+        saveBranchState(state, projectRoot);
+        console.log(`${spinner_1.colors.green('✓')} Renamed '${oldName}' to '${newName}'`);
+        console.log('');
+        return;
+    }
+    if (args[0]) {
+        const branchName = args[0];
+        if (state.branches[branchName]) {
+            console.log(`${spinner_1.colors.red('error:')} Branch already exists: ${branchName}`);
+            return;
+        }
+        const head = (0, repo_manager_1.getHead)(projectRoot);
+        if (!head) {
+            console.log(`${spinner_1.colors.red('error:')} No commits yet`);
+            return;
+        }
+        state.branches[branchName] = head;
+        saveBranchState(state, projectRoot);
+        console.log(`${spinner_1.colors.green('✓')} Created branch '${branchName}'`);
+        console.log('');
+        return;
+    }
+    const branches = Object.keys(state.branches).sort();
+    if (branches.length === 0) {
+        console.log(`${spinner_1.colors.muted('No branches.')}`);
+        return;
+    }
+    for (const name of branches) {
+        const isCurrent = name === state.current;
+        const prefix = isCurrent ? spinner_1.colors.green('* ') : '  ';
+        const branchName = isCurrent ? spinner_1.colors.green(name) : name;
+        console.log(`${prefix}${branchName}`);
+    }
+    console.log('');
+}
+exports.default = branchCommand;

package/dist/cjs/cli/commands/checkout.cjs

@@ -0,0 +1,134 @@
+"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.checkoutCommand = checkoutCommand;
+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 = (0, repo_manager_1.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 checkoutCommand(context) {
+    const { 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 createBranch = flags['b'] === true;
+    const branchName = args[0];
+    if (!branchName) {
+        console.log(`${spinner_1.colors.red('error:')} Please specify a branch`);
+        console.log('');
+        console.log(`Usage: ${spinner_1.colors.cyan('relq checkout <branch>')}`);
+        console.log(`       ${spinner_1.colors.cyan('relq checkout -b <new-branch>')}`);
+        console.log('');
+        return;
+    }
+    const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    if (staged.length > 0 || unstaged.length > 0) {
+        console.log(`${spinner_1.colors.red('error:')} You have uncommitted changes`);
+        console.log('');
+        console.log('Commit or stash them before switching branches:');
+        console.log(`  ${spinner_1.colors.cyan('relq commit -m "message"')}`);
+        console.log(`  ${spinner_1.colors.cyan('relq stash')}`);
+        console.log('');
+        return;
+    }
+    const state = loadBranchState(projectRoot);
+    if (createBranch) {
+        if (state.branches[branchName]) {
+            console.log(`${spinner_1.colors.red('error:')} Branch already exists: ${branchName}`);
+            return;
+        }
+        const head = (0, repo_manager_1.getHead)(projectRoot);
+        if (!head) {
+            console.log(`${spinner_1.colors.red('error:')} No commits yet`);
+            return;
+        }
+        state.branches[branchName] = head;
+        state.current = branchName;
+        saveBranchState(state, projectRoot);
+        console.log(`${spinner_1.colors.green('✓')} Switched to new branch '${branchName}'`);
+        console.log('');
+        return;
+    }
+    if (!state.branches[branchName]) {
+        console.log(`${spinner_1.colors.red('error:')} Branch not found: ${branchName}`);
+        console.log('');
+        console.log('Available branches:');
+        for (const name of Object.keys(state.branches)) {
+            console.log(`   ${name}`);
+        }
+        console.log('');
+        return;
+    }
+    if (state.current === branchName) {
+        console.log(`Already on '${branchName}'`);
+        console.log('');
+        return;
+    }
+    const currentHead = (0, repo_manager_1.getHead)(projectRoot);
+    if (currentHead) {
+        state.branches[state.current] = currentHead;
+    }
+    const targetHash = state.branches[branchName];
+    const targetCommit = (0, repo_manager_1.loadCommit)(targetHash, projectRoot);
+    if (!targetCommit) {
+        console.log(`${spinner_1.colors.red('error:')} Cannot find commit for branch`);
+        return;
+    }
+    if (targetCommit.schema) {
+        (0, repo_manager_1.saveSnapshot)(targetCommit.schema, projectRoot);
+    }
+    (0, repo_manager_1.setHead)(targetHash, projectRoot);
+    state.current = branchName;
+    saveBranchState(state, projectRoot);
+    console.log(`${spinner_1.colors.green('✓')} Switched to branch '${branchName}'`);
+    console.log('');
+}
+exports.default = checkoutCommand;

package/dist/cjs/cli/commands/cherry-pick.cjs

@@ -0,0 +1,283 @@
+"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.cherryPickCommand = cherryPickCommand;
+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");
+async function cherryPickCommand(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 abort = flags['abort'] === true;
+    const cherryPickStatePath = path.join(projectRoot, '.relq', 'CHERRY_PICK_STATE');
+    if (abort) {
+        if (fs.existsSync(cherryPickStatePath)) {
+            fs.unlinkSync(cherryPickStatePath);
+            console.log(`${spinner_1.colors.green('✓')} Cherry-pick aborted`);
+        }
+        else {
+            console.log(`${spinner_1.colors.muted('No cherry-pick in progress.')}`);
+        }
+        console.log('');
+        return;
+    }
+    if (fs.existsSync(cherryPickStatePath)) {
+        const state = JSON.parse(fs.readFileSync(cherryPickStatePath, 'utf-8'));
+        console.log(`${spinner_1.colors.red('error:')} Cherry-pick in progress from ${(0, repo_manager_1.shortHash)(state.fromCommit)}`);
+        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 cherry-pick --abort')} ${spinner_1.colors.muted('to cancel')}`);
+        console.log('');
+        return;
+    }
+    const ref = args[0];
+    if (!ref) {
+        console.log(`${spinner_1.colors.red('error:')} Please specify a commit`);
+        console.log('');
+        console.log(`Usage: ${spinner_1.colors.cyan('relq cherry-pick <commit>')}`);
+        console.log('');
+        return;
+    }
+    const spinner = (0, spinner_1.createSpinner)();
+    spinner.start(`Cherry-picking ${(0, repo_manager_1.shortHash)(ref)}...`);
+    try {
+        const hash = (0, repo_manager_1.resolveRef)(ref, projectRoot);
+        if (!hash) {
+            spinner.fail(`Commit not found: ${ref}`);
+            return;
+        }
+        const targetCommit = (0, repo_manager_1.loadCommit)(hash, projectRoot);
+        const parentCommit = (0, repo_manager_1.loadParentCommit)(hash, projectRoot);
+        if (!targetCommit) {
+            spinner.fail('Cannot load commit');
+            return;
+        }
+        if (!parentCommit) {
+            spinner.fail('Cannot cherry-pick first commit (no parent)');
+            return;
+        }
+        const diff = calculateCommitDiff(parentCommit.schema, targetCommit.schema);
+        const currentSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        if (!currentSnapshot) {
+            spinner.fail('No snapshot found');
+            return;
+        }
+        const conflicts = detectCherryPickConflicts(currentSnapshot, diff);
+        if (conflicts.length > 0) {
+            const state = {
+                fromCommit: hash,
+                originalMessage: targetCommit.message,
+                conflicts,
+                diff,
+                createdAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(cherryPickStatePath, JSON.stringify(state, 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}`);
+                console.log(`      ${spinner_1.colors.muted(c.description)}`);
+            }
+            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 --theirs')} ${spinner_1.colors.muted('to resolve')}`);
+            console.log(`${spinner_1.colors.muted('Or')} ${spinner_1.colors.cyan('relq cherry-pick --abort')} ${spinner_1.colors.muted('to cancel')}`);
+            console.log('');
+            return;
+        }
+        const newSnapshot = applyCommitDiff(currentSnapshot, diff);
+        (0, repo_manager_1.saveSnapshot)(newSnapshot, projectRoot);
+        const author = config?.author || 'Relq CLI';
+        const message = `Cherry-picked ${(0, repo_manager_1.shortHash)(hash)}: ${targetCommit.message}`;
+        const commit = (0, repo_manager_1.createCommit)(newSnapshot, author, message, projectRoot);
+        spinner.succeed(`Cherry-picked ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(hash))}`);
+        console.log(`   ${spinner_1.colors.cyan(commit.message)}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Cherry-pick failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+    }
+}
+function calculateCommitDiff(parent, target) {
+    const diff = {
+        tablesAdded: [],
+        tablesRemoved: [],
+        tablesModified: [],
+        enumsAdded: [],
+        enumsRemoved: [],
+        columnsAdded: [],
+        columnsRemoved: [],
+    };
+    const parentTables = new Map(parent.tables.map(t => [t.name, t]));
+    const targetTables = new Map(target.tables.map(t => [t.name, t]));
+    for (const [name, table] of targetTables) {
+        if (!parentTables.has(name)) {
+            diff.tablesAdded.push(table);
+        }
+    }
+    for (const [name] of parentTables) {
+        if (!targetTables.has(name)) {
+            diff.tablesRemoved.push(name);
+        }
+    }
+    for (const [name, targetTable] of targetTables) {
+        const parentTable = parentTables.get(name);
+        if (!parentTable)
+            continue;
+        const parentCols = new Map(parentTable.columns.map(c => [c.name, c]));
+        const targetCols = new Map(targetTable.columns.map(c => [c.name, c]));
+        const changes = { columnsAdded: [], columnsRemoved: [] };
+        for (const [colName, col] of targetCols) {
+            if (!parentCols.has(colName)) {
+                changes.columnsAdded.push(col);
+            }
+        }
+        for (const [colName] of parentCols) {
+            if (!targetCols.has(colName)) {
+                changes.columnsRemoved.push(colName);
+            }
+        }
+        if (changes.columnsAdded.length > 0 || changes.columnsRemoved.length > 0) {
+            diff.tablesModified.push({ name, changes });
+        }
+    }
+    const parentEnums = new Set(parent.enums.map(e => e.name));
+    const targetEnums = new Map(target.enums.map(e => [e.name, e]));
+    for (const [name, e] of targetEnums) {
+        if (!parentEnums.has(name)) {
+            diff.enumsAdded.push(e);
+        }
+    }
+    for (const name of parentEnums) {
+        if (!targetEnums.has(name)) {
+            diff.enumsRemoved.push(name);
+        }
+    }
+    return diff;
+}
+function detectCherryPickConflicts(current, diff) {
+    const conflicts = [];
+    for (const table of diff.tablesAdded) {
+        if (current.tables.find(t => t.name === table.name)) {
+            conflicts.push({
+                objectType: 'TABLE',
+                objectName: table.name,
+                currentValue: 'exists',
+                incomingValue: 'add',
+                description: 'Table already exists in current snapshot',
+            });
+        }
+    }
+    for (const tableName of diff.tablesRemoved) {
+        if (!current.tables.find(t => t.name === tableName)) {
+            conflicts.push({
+                objectType: 'TABLE',
+                objectName: tableName,
+                currentValue: 'missing',
+                incomingValue: 'remove',
+                description: 'Table does not exist in current snapshot',
+            });
+        }
+    }
+    for (const mod of diff.tablesModified) {
+        const currentTable = current.tables.find(t => t.name === mod.name);
+        if (!currentTable) {
+            conflicts.push({
+                objectType: 'TABLE',
+                objectName: mod.name,
+                currentValue: 'missing',
+                incomingValue: 'modify',
+                description: 'Table does not exist in current snapshot',
+            });
+            continue;
+        }
+        for (const col of mod.changes.columnsAdded) {
+            if (currentTable.columns.find(c => c.name === col.name)) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: col.name,
+                    parentName: mod.name,
+                    currentValue: 'exists',
+                    incomingValue: 'add',
+                    description: 'Column already exists',
+                });
+            }
+        }
+    }
+    for (const e of diff.enumsAdded) {
+        if (current.enums.find(en => en.name === e.name)) {
+            conflicts.push({
+                objectType: 'ENUM',
+                objectName: e.name,
+                currentValue: 'exists',
+                incomingValue: 'add',
+                description: 'Enum already exists',
+            });
+        }
+    }
+    return conflicts;
+}
+function applyCommitDiff(snapshot, diff) {
+    const result = JSON.parse(JSON.stringify(snapshot));
+    for (const table of diff.tablesAdded) {
+        result.tables.push(table);
+    }
+    result.tables = result.tables.filter(t => !diff.tablesRemoved.includes(t.name));
+    for (const mod of diff.tablesModified) {
+        const table = result.tables.find(t => t.name === mod.name);
+        if (!table)
+            continue;
+        for (const col of mod.changes.columnsAdded) {
+            table.columns.push(col);
+        }
+        table.columns = table.columns.filter(c => !mod.changes.columnsRemoved.includes(c.name));
+    }
+    for (const e of diff.enumsAdded) {
+        result.enums.push(e);
+    }
+    result.enums = result.enums.filter(e => !diff.enumsRemoved.includes(e.name));
+    return result;
+}
+exports.default = cherryPickCommand;