relq 1.0.1 → 1.0.2

package/dist/cjs/cli/commands/reset.cjs

@@ -0,0 +1,169 @@
+"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.resetCommand = resetCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+async function resetCommand(context) {
+    const { flags, args } = 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 hard = flags['hard'] === true;
+    const soft = flags['soft'] === true;
+    const target = args[0];
+    if (!target) {
+        console.log(`${spinner_1.colors.red('error:')} Please specify a target`);
+        console.log('');
+        console.log('Usage:');
+        console.log(`  ${spinner_1.colors.cyan('relq reset --hard HEAD~1')}   Reset to previous commit`);
+        console.log(`  ${spinner_1.colors.cyan('relq reset --hard <hash>')}   Reset to specific commit`);
+        console.log('');
+        return;
+    }
+    if (!hard && !soft) {
+        console.log(`${spinner_1.colors.red('error:')} Please specify --hard or --soft`);
+        console.log('');
+        console.log(`  ${spinner_1.colors.cyan('--hard')}  Discard all changes (DANGEROUS)`);
+        console.log(`  ${spinner_1.colors.cyan('--soft')}  Keep changes unstaged`);
+        console.log('');
+        return;
+    }
+    const currentHead = (0, repo_manager_1.getHead)(projectRoot);
+    if (!currentHead) {
+        console.log(`${spinner_1.colors.red('error:')} No commits yet`);
+        return;
+    }
+    const allCommits = (0, repo_manager_1.getAllCommits)(projectRoot);
+    let targetHash = null;
+    if (target.startsWith('HEAD~')) {
+        const n = parseInt(target.slice(5)) || 1;
+        const headIndex = allCommits.findIndex(c => c.hash === currentHead);
+        if (headIndex >= 0 && headIndex + n < allCommits.length) {
+            targetHash = allCommits[headIndex + n].hash;
+        }
+    }
+    else if (target === 'HEAD') {
+        targetHash = currentHead;
+    }
+    else {
+        const match = allCommits.find(c => c.hash.startsWith(target));
+        if (match) {
+            targetHash = match.hash;
+        }
+    }
+    if (!targetHash) {
+        console.log(`${spinner_1.colors.red('error:')} Cannot find commit: ${target}`);
+        console.log('');
+        console.log('Available commits:');
+        for (const c of allCommits.slice(0, 5)) {
+            console.log(`   ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(c.hash))} ${c.message}`);
+        }
+        return;
+    }
+    const targetCommit = (0, repo_manager_1.loadCommit)(targetHash, projectRoot);
+    if (!targetCommit) {
+        console.log(`${spinner_1.colors.red('error:')} Cannot load commit: ${targetHash}`);
+        return;
+    }
+    if (hard) {
+        console.log(`${spinner_1.colors.red('⚠  WARNING: This will discard all local changes!')}`);
+        console.log('');
+        console.log(`Reset to: ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(targetHash))} ${targetCommit.message}`);
+        console.log('');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const confirmed = await new Promise((resolve) => {
+            rl.question(`Continue? [y/N] `, (answer) => {
+                rl.close();
+                resolve(answer.trim().toLowerCase() === 'y');
+            });
+        });
+        if (!confirmed) {
+            console.log(`${spinner_1.colors.muted('Cancelled.')}`);
+            console.log('');
+            return;
+        }
+    }
+    const spinner = (0, spinner_1.createSpinner)();
+    try {
+        spinner.start(`Resetting to ${(0, repo_manager_1.shortHash)(targetHash)}...`);
+        const commitPath = path.join(projectRoot, '.relq', 'commits', `${targetHash}.json`);
+        if (!fs.existsSync(commitPath)) {
+            spinner.fail('Cannot find commit data');
+            return;
+        }
+        const commitData = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+        const targetSnapshot = commitData.snapshot;
+        if (!targetSnapshot) {
+            spinner.fail('Commit has no snapshot data');
+            return;
+        }
+        if (hard) {
+            (0, repo_manager_1.saveSnapshot)(targetSnapshot, projectRoot);
+            (0, repo_manager_1.setHead)(targetHash, projectRoot);
+            const stagedPath = path.join(projectRoot, '.relq', 'staged.json');
+            const unstagedPath = path.join(projectRoot, '.relq', 'unstaged.json');
+            if (fs.existsSync(stagedPath))
+                fs.unlinkSync(stagedPath);
+            if (fs.existsSync(unstagedPath))
+                fs.unlinkSync(unstagedPath);
+            const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+            if (fs.existsSync(mergeStatePath))
+                fs.unlinkSync(mergeStatePath);
+        }
+        spinner.succeed(`Reset to ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(targetHash))}`);
+        console.log('');
+        console.log(`HEAD is now at ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(targetHash))} ${targetCommit.message}`);
+        console.log('');
+        if (soft) {
+            console.log(`${spinner_1.colors.muted('Changes are unstaged. Use')} ${spinner_1.colors.cyan('relq status')} ${spinner_1.colors.muted('to see.')}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Reset failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+}
+exports.default = resetCommand;

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

@@ -0,0 +1,193 @@
+"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 } = 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 mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+    if (!fs.existsSync(mergeStatePath)) {
+        console.log(`${spinner_1.colors.green('✓')} 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(`${spinner_1.colors.green('✓')} 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(`${spinner_1.colors.green('✓')} Applied remote versions for all conflicts`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "Merge remote changes"')} ${spinner_1.colors.muted('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(`${spinner_1.colors.green('✓')} Kept local versions for all conflicts`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "Keep local changes"')} ${spinner_1.colors.muted('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(`${spinner_1.colors.green('✓')} All conflicts resolved`);
+        }
+        else {
+            fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
+            console.log(`${spinner_1.colors.green('✓')} Resolved: ${conflict.objectType} ${objectName}`);
+            console.log(`${spinner_1.colors.yellow(String(mergeState.conflicts.length))} conflict(s) remaining`);
+        }
+        console.log('');
+        return;
+    }
+    console.log(`${spinner_1.colors.yellow('⚠')} 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

@@ -85,7 +85,7 @@ async function rollbackCommand(context) {
     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,

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

@@ -0,0 +1,154 @@
+"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 } = context;
+    const projectRoot = process.cwd();
+    const subcommand = args[0] || 'push';
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    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(`${spinner_1.colors.green('✓')} 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(`${spinner_1.colors.green('✓')} 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(`${spinner_1.colors.green('✓')} Dropped stash`);
+    console.log('');
+}
+exports.default = stashCommand;

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

@@ -1,8 +1,44 @@
 "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;
@@ -48,6 +84,18 @@ async function statusCommand(context) {
         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('');