relq 1.0.1 → 1.0.3

package/dist/cjs/cli/commands/resolve.cjs

@@ -0,0 +1,191 @@
+"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.resolveCommand = resolveCommand;
+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 resolveCommand(context) {
+    const { flags, args, projectRoot } = context;
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        (0, spinner_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${spinner_1.colors.cyan('relq init')} to initialize.`);
+    }
+    const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+    if (!fs.existsSync(mergeStatePath)) {
+        console.log('No conflicts to resolve');
+        console.log('');
+        return;
+    }
+    const mergeState = JSON.parse(fs.readFileSync(mergeStatePath, 'utf-8'));
+    if (mergeState.conflicts.length === 0) {
+        fs.unlinkSync(mergeStatePath);
+        console.log('All conflicts resolved');
+        console.log('');
+        return;
+    }
+    const allTheirs = flags['all-theirs'] === true;
+    const allOurs = flags['all-ours'] === true;
+    const theirs = flags['theirs'] === true;
+    const ours = flags['ours'] === true;
+    const objectName = args[0];
+    if (allTheirs) {
+        console.log(`Resolving ${mergeState.conflicts.length} conflict(s) with --all-theirs`);
+        console.log('');
+        (0, repo_manager_1.saveSnapshot)(mergeState.remoteSnapshot, projectRoot);
+        fs.unlinkSync(mergeStatePath);
+        console.log('Applied remote versions for all conflicts');
+        console.log('');
+        console.log(`hint: run 'relq commit -m "Merge remote changes"' to complete`);
+        console.log('');
+        return;
+    }
+    if (allOurs) {
+        console.log(`Resolving ${mergeState.conflicts.length} conflict(s) with --all-ours`);
+        console.log('');
+        fs.unlinkSync(mergeStatePath);
+        console.log('Kept local versions for all conflicts');
+        console.log('');
+        console.log(`hint: run 'relq commit -m "Keep local changes"' to complete`);
+        console.log('');
+        return;
+    }
+    if ((theirs || ours) && objectName) {
+        const conflict = mergeState.conflicts.find(c => c.objectName === objectName ||
+            `${c.parentName}.${c.objectName}` === objectName);
+        if (!conflict) {
+            console.log(`${spinner_1.colors.red('error:')} No conflict found for '${objectName}'`);
+            console.log('');
+            console.log('Conflicts:');
+            for (const c of mergeState.conflicts) {
+                const name = c.parentName ? `${c.parentName}.${c.objectName}` : c.objectName;
+                console.log(`   ${c.objectType}: ${name}`);
+            }
+            console.log('');
+            return;
+        }
+        const localSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        if (!localSnapshot) {
+            console.log(`${spinner_1.colors.red('error:')} No local snapshot found`);
+            return;
+        }
+        if (theirs) {
+            applyResolution(localSnapshot, conflict, mergeState.remoteSnapshot, 'theirs');
+            (0, repo_manager_1.saveSnapshot)(localSnapshot, projectRoot);
+        }
+        mergeState.conflicts = mergeState.conflicts.filter(c => c !== conflict);
+        if (mergeState.conflicts.length === 0) {
+            fs.unlinkSync(mergeStatePath);
+            console.log('All conflicts resolved');
+        }
+        else {
+            fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
+            console.log(`Resolved: ${conflict.objectType} ${objectName}`);
+            console.log(`${mergeState.conflicts.length} conflict(s) remaining`);
+        }
+        console.log('');
+        return;
+    }
+    (0, spinner_1.warning)(`You have ${mergeState.conflicts.length} unresolved conflict(s):`);
+    console.log('');
+    for (const conflict of mergeState.conflicts) {
+        const name = conflict.parentName
+            ? `${conflict.parentName}.${conflict.objectName}`
+            : conflict.objectName;
+        console.log(`   ${spinner_1.colors.red('conflict:')} ${conflict.objectType.toLowerCase()} ${spinner_1.colors.bold(name)}`);
+        console.log(`     ${spinner_1.colors.muted(conflict.description)}`);
+    }
+    console.log('');
+    console.log('To resolve:');
+    console.log(`  ${spinner_1.colors.cyan('relq resolve --theirs <name>')}  Take remote version`);
+    console.log(`  ${spinner_1.colors.cyan('relq resolve --ours <name>')}    Keep local version`);
+    console.log(`  ${spinner_1.colors.cyan('relq resolve --all-theirs')}     Take all remote`);
+    console.log(`  ${spinner_1.colors.cyan('relq resolve --all-ours')}       Keep all local`);
+    console.log('');
+}
+function applyResolution(local, conflict, remote, resolution) {
+    if (resolution !== 'theirs')
+        return;
+    switch (conflict.objectType) {
+        case 'TABLE': {
+            const remoteTable = remote.tables.find(t => t.name === conflict.objectName);
+            const localIdx = local.tables.findIndex(t => t.name === conflict.objectName);
+            if (remoteTable) {
+                if (localIdx >= 0) {
+                    local.tables[localIdx] = remoteTable;
+                }
+                else {
+                    local.tables.push(remoteTable);
+                }
+            }
+            break;
+        }
+        case 'COLUMN': {
+            const [tableName, colName] = conflict.objectName.includes('.')
+                ? conflict.objectName.split('.')
+                : [conflict.parentName, conflict.objectName];
+            const remoteTable = remote.tables.find(t => t.name === tableName);
+            const localTable = local.tables.find(t => t.name === tableName);
+            if (remoteTable && localTable) {
+                const remoteCol = remoteTable.columns.find(c => c.name === colName);
+                const localIdx = localTable.columns.findIndex(c => c.name === colName);
+                if (remoteCol) {
+                    if (localIdx >= 0) {
+                        localTable.columns[localIdx] = remoteCol;
+                    }
+                    else {
+                        localTable.columns.push(remoteCol);
+                    }
+                }
+            }
+            break;
+        }
+        case 'ENUM': {
+            const remoteEnum = remote.enums.find(e => e.name === conflict.objectName);
+            const localIdx = local.enums.findIndex(e => e.name === conflict.objectName);
+            if (remoteEnum) {
+                if (localIdx >= 0) {
+                    local.enums[localIdx] = remoteEnum;
+                }
+                else {
+                    local.enums.push(remoteEnum);
+                }
+            }
+            break;
+        }
+    }
+}
+exports.default = resolveCommand;

package/dist/cjs/cli/commands/rollback.cjs

@@ -36,18 +36,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rollbackCommand = rollbackCommand;
 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 env_loader_1 = require("../utils/env-loader.cjs");
-const colors = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    cyan: '\x1b[36m',
-};
+const cli_utils_1 = require("../utils/cli-utils.cjs");
 function parseMigration(content) {
     const upMatch = content.match(/--\s*UP\s*\n([\s\S]*?)(?=--\s*DOWN|$)/i);
     const downMatch = content.match(/--\s*DOWN\s*\n([\s\S]*?)$/i);
@@ -56,36 +47,24 @@ function parseMigration(content) {
         down: downMatch?.[1]?.trim() || '',
     };
 }
-function askConfirm(question) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    return new Promise((resolve) => {
-        rl.question(`${question} [y/N]: `, (answer) => {
-            rl.close();
-            resolve(answer.trim().toLowerCase() === 'y');
-        });
-    });
-}
 async function rollbackCommand(context) {
     const { config, args, flags } = 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 a configuration file`);
+        return;
     }
-    (0, config_loader_1.requireValidConfig)(config);
+    await (0, config_loader_1.requireValidConfig)(config, { calledFrom: 'rollback' });
     const connection = config.connection;
     const migrationsDir = config.migrations?.directory || './migrations';
     const tableName = config.migrations?.tableName || '_relq_migrations';
     const count = parseInt(args[0]) || 1;
     const dryRun = flags['dry-run'] === true;
     const force = flags['force'] === true;
-    console.log(`${colors.bold}Rolling back ${count} migration(s)...${colors.reset}`);
+    console.log(`Rolling back ${count} migration(s)...`);
     console.log(`   Connection: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
     console.log('');
     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,
@@ -101,17 +80,17 @@ async function rollbackCommand(context) {
                 LIMIT $1;
             `, [count]);
             if (result.rows.length === 0) {
-                console.log(`${colors.yellow}No migrations to rollback.${colors.reset}`);
+                console.log('No migrations to rollback.');
                 return;
             }
             const toRollback = result.rows.map(r => r.name);
-            console.log(`${colors.bold}Migrations to rollback:${colors.reset}`);
+            console.log('Migrations to rollback:');
             for (const name of toRollback) {
-                console.log(`  ${colors.red}• ${name}${colors.reset}`);
+                console.log(`  - ${name}`);
             }
             console.log('');
             if (!force && !dryRun) {
-                const proceed = await askConfirm(`${colors.red}This will undo ${toRollback.length} migration(s). Continue?${colors.reset}`);
+                const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.red('This will undo ' + toRollback.length + ' migration(s). Continue?')}`, false);
                 if (!proceed) {
                     console.log('Cancelled.');
                     return;
@@ -120,18 +99,18 @@ async function rollbackCommand(context) {
             for (const name of toRollback) {
                 const filePath = path.join(migrationsDir, name);
                 if (!fs.existsSync(filePath)) {
-                    console.log(`${colors.yellow}⚠️  Migration file not found: ${name}${colors.reset}`);
+                    (0, cli_utils_1.warning)(`Migration file not found: ${name}`);
                     continue;
                 }
                 const content = fs.readFileSync(filePath, 'utf-8');
                 const { down } = parseMigration(content);
                 if (!down) {
-                    console.log(`${colors.yellow}⚠️  No DOWN section in: ${name}${colors.reset}`);
+                    (0, cli_utils_1.warning)(`No DOWN section in: ${name}`);
                     continue;
                 }
                 if (dryRun) {
-                    console.log(`${colors.cyan}[dry-run] Would rollback: ${name}${colors.reset}`);
-                    console.log(`${colors.dim}${down}${colors.reset}`);
+                    console.log(`[dry-run] Would rollback: ${name}`);
+                    console.log(down);
                     console.log('');
                 }
                 else {
@@ -142,7 +121,7 @@ async function rollbackCommand(context) {
                         await client.query(down);
                         await client.query(`DELETE FROM "${tableName}" WHERE name = $1`, [name]);
                         await client.query('COMMIT');
-                        console.log(`   ${colors.green}✓ Rolled back${colors.reset}`);
+                        console.log('   Rolled back');
                     }
                     catch (error) {
                         await client.query('ROLLBACK');
@@ -155,7 +134,7 @@ async function rollbackCommand(context) {
             }
             if (!dryRun) {
                 console.log('');
-                console.log(`${colors.green}✓ Rolled back ${toRollback.length} migration(s).${colors.reset}`);
+                console.log(`Rolled back ${toRollback.length} migration(s).`);
             }
         }
         finally {
@@ -163,7 +142,6 @@ async function rollbackCommand(context) {
         }
     }
     catch (error) {
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        (0, cli_utils_1.fatal)('Rollback failed', error instanceof Error ? error.message : String(error));
     }
 }

package/dist/cjs/cli/commands/stash.cjs

@@ -0,0 +1,152 @@
+"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.stashCommand = stashCommand;
+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 stashCommand(context) {
+    const { args, flags, projectRoot } = context;
+    const subcommand = args[0] || 'push';
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        (0, spinner_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${spinner_1.colors.cyan('relq init')} to initialize.`);
+    }
+    const stashDir = path.join(projectRoot, '.relq', 'stash');
+    switch (subcommand) {
+        case 'push':
+        case 'save':
+            await stashPush(projectRoot, stashDir, flags['m'] || 'WIP');
+            break;
+        case 'pop':
+            await stashPop(projectRoot, stashDir);
+            break;
+        case 'list':
+            await stashList(stashDir);
+            break;
+        case 'drop':
+            await stashDrop(stashDir);
+            break;
+        default:
+            await stashPush(projectRoot, stashDir, subcommand);
+    }
+}
+async function stashPush(projectRoot, stashDir, message) {
+    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.muted('No changes to stash.')}`);
+        console.log('');
+        return;
+    }
+    if (!fs.existsSync(stashDir)) {
+        fs.mkdirSync(stashDir, { recursive: true });
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json'));
+    const stashIdx = stashFiles.length;
+    const stash = {
+        message,
+        timestamp: new Date().toISOString(),
+        staged,
+        unstaged,
+    };
+    fs.writeFileSync(path.join(stashDir, `stash-${stashIdx}.json`), JSON.stringify(stash, null, 2));
+    const stagedPath = path.join(projectRoot, '.relq', 'staged.json');
+    const unstagedPath = path.join(projectRoot, '.relq', 'unstaged.json');
+    if (fs.existsSync(stagedPath))
+        fs.writeFileSync(stagedPath, '[]');
+    if (fs.existsSync(unstagedPath))
+        fs.writeFileSync(unstagedPath, '[]');
+    console.log('Saved working directory');
+    console.log(`   stash@{${stashIdx}}: ${message}`);
+    console.log('');
+}
+async function stashPop(projectRoot, stashDir) {
+    if (!fs.existsSync(stashDir)) {
+        console.log(`${spinner_1.colors.muted('No stashes found.')}`);
+        return;
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json')).sort().reverse();
+    if (stashFiles.length === 0) {
+        console.log(`${spinner_1.colors.muted('No stashes found.')}`);
+        return;
+    }
+    const stashPath = path.join(stashDir, stashFiles[0]);
+    const stash = JSON.parse(fs.readFileSync(stashPath, 'utf-8'));
+    const stagedPath = path.join(projectRoot, '.relq', 'staged.json');
+    const unstagedPath = path.join(projectRoot, '.relq', 'unstaged.json');
+    if (stash.staged.length > 0) {
+        fs.writeFileSync(stagedPath, JSON.stringify(stash.staged, null, 2));
+    }
+    if (stash.unstaged.length > 0) {
+        fs.writeFileSync(unstagedPath, JSON.stringify(stash.unstaged, null, 2));
+    }
+    fs.unlinkSync(stashPath);
+    console.log('Applied stash and dropped');
+    console.log(`   ${stash.message}`);
+    console.log('');
+}
+async function stashList(stashDir) {
+    if (!fs.existsSync(stashDir)) {
+        console.log(`${spinner_1.colors.muted('No stashes.')}`);
+        return;
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json')).sort();
+    if (stashFiles.length === 0) {
+        console.log(`${spinner_1.colors.muted('No stashes.')}`);
+        return;
+    }
+    for (let i = 0; i < stashFiles.length; i++) {
+        const stash = JSON.parse(fs.readFileSync(path.join(stashDir, stashFiles[i]), 'utf-8'));
+        console.log(`stash@{${i}}: ${stash.message} (${stash.staged.length + stash.unstaged.length} changes)`);
+    }
+    console.log('');
+}
+async function stashDrop(stashDir) {
+    if (!fs.existsSync(stashDir)) {
+        console.log(`${spinner_1.colors.muted('No stashes.')}`);
+        return;
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json')).sort().reverse();
+    if (stashFiles.length === 0) {
+        console.log(`${spinner_1.colors.muted('No stashes.')}`);
+        return;
+    }
+    fs.unlinkSync(path.join(stashDir, stashFiles[0]));
+    console.log('Dropped stash');
+    console.log('');
+}
+exports.default = stashCommand;

package/dist/cjs/cli/commands/status.cjs

@@ -1,20 +1,51 @@
 "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.statusCommand = statusCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const env_loader_1 = require("../utils/env-loader.cjs");
 const spinner_1 = require("../utils/spinner.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 async function statusCommand(context) {
-    const { config, flags } = context;
-    const projectRoot = process.cwd();
+    const { config, flags, projectRoot } = context;
     const connection = config?.connection;
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
-        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
-        console.log('');
-        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('to initialize.')}`);
-        console.log('');
-        return;
+        (0, spinner_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${spinner_1.colors.cyan('relq init')} to initialize.`);
     }
     const head = (0, repo_manager_1.getHead)(projectRoot);
     const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
@@ -37,7 +68,7 @@ async function statusCommand(context) {
         console.log(`${spinner_1.colors.green('Changes to be committed:')}`);
         console.log(`  ${spinner_1.colors.muted('(use "relq restore --staged <name>..." to unstage)')}`);
         console.log('');
-        displayChanges(staged, '	');
+        displayChanges(staged, '        ');
         console.log('');
     }
     if (unstaged.length > 0) {
@@ -45,9 +76,21 @@ async function statusCommand(context) {
         console.log(`  ${spinner_1.colors.muted('(use "relq add <name>..." to stage)')}`);
         console.log(`  ${spinner_1.colors.muted('(use "relq restore <name>..." to discard)')}`);
         console.log('');
-        displayChanges(unstaged, '	');
+        displayChanges(unstaged, '      ');
         console.log('');
     }
+    const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+    const relqignorePath = path.join(projectRoot, '.relqignore');
+    if (ignorePatterns.length > 0 && fs.existsSync(relqignorePath)) {
+        const userPatterns = ignorePatterns.filter(p => !p.raw.startsWith('_relq_') &&
+            !p.raw.startsWith('pg_') &&
+            !p.raw.startsWith('_temp_') &&
+            !p.raw.startsWith('tmp_'));
+        if (userPatterns.length > 0) {
+            console.log(`${spinner_1.colors.muted(`${userPatterns.length} pattern(s) active from .relqignore`)}`);
+            console.log('');
+        }
+    }
     if (staged.length === 0 && unstaged.length === 0) {
         console.log(`${spinner_1.colors.green('nothing to commit, working tree clean')}`);
         console.log('');