relq 1.0.1 → 1.0.3

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

@@ -1,17 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as readline from 'readline';
 import { requireValidConfig } from "../utils/config-loader.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-const colors = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    cyan: '\x1b[36m',
-};
+import { colors, confirm, fatal, warning } from "../utils/cli-utils.js";
 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);
@@ -20,36 +11,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');
-        });
-    });
-}
 export async function rollbackCommand(context) {
     const { config, args, flags } = context;
     if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+        fatal('No configuration found', `run ${colors.cyan('relq init')} to create a configuration file`);
+        return;
     }
-    requireValidConfig(config);
+    await 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: ${getConnectionDescription(connection)}`);
     console.log('');
     try {
-        const { Pool } = await import("../../addon/pg.js");
+        const { Pool } = await import("../../addon/pg/index.js");
         const pool = new Pool({
             host: connection.host,
             port: connection.port || 5432,
@@ -65,17 +44,17 @@ export 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 confirm(`${colors.red('This will undo ' + toRollback.length + ' migration(s). Continue?')}`, false);
                 if (!proceed) {
                     console.log('Cancelled.');
                     return;
@@ -84,18 +63,18 @@ export 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}`);
+                    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}`);
+                    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 {
@@ -106,7 +85,7 @@ export 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');
@@ -119,7 +98,7 @@ export 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 {
@@ -127,7 +106,6 @@ export async function rollbackCommand(context) {
         }
     }
     catch (error) {
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        fatal('Rollback failed', error instanceof Error ? error.message : String(error));
     }
 }

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

@@ -0,0 +1,116 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors, fatal } from "../utils/spinner.js";
+import { isInitialized, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+export async function stashCommand(context) {
+    const { args, flags, projectRoot } = context;
+    const subcommand = args[0] || 'push';
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        fatal('not a relq repository (or any parent directories): .relq', `Run ${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 = getStagedChanges(projectRoot);
+    const unstaged = getUnstagedChanges(projectRoot);
+    if (staged.length === 0 && unstaged.length === 0) {
+        console.log(`${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(`${colors.muted('No stashes found.')}`);
+        return;
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json')).sort().reverse();
+    if (stashFiles.length === 0) {
+        console.log(`${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(`${colors.muted('No stashes.')}`);
+        return;
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json')).sort();
+    if (stashFiles.length === 0) {
+        console.log(`${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(`${colors.muted('No stashes.')}`);
+        return;
+    }
+    const stashFiles = fs.readdirSync(stashDir).filter(f => f.endsWith('.json')).sort().reverse();
+    if (stashFiles.length === 0) {
+        console.log(`${colors.muted('No stashes.')}`);
+        return;
+    }
+    fs.unlinkSync(path.join(stashDir, stashFiles[0]));
+    console.log('Dropped stash');
+    console.log('');
+}
+export default stashCommand;

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

@@ -1,17 +1,15 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { colors } from "../utils/spinner.js";
+import { colors, fatal } from "../utils/spinner.js";
+import { loadRelqignore, } from "../utils/relqignore.js";
 import { isInitialized, getHead, loadCommit, shortHash, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
 export async function statusCommand(context) {
-    const { config, flags } = context;
-    const projectRoot = process.cwd();
+    const { config, flags, projectRoot } = context;
     const connection = config?.connection;
     console.log('');
     if (!isInitialized(projectRoot)) {
-        console.log(`${colors.red('fatal:')} not a relq repository`);
-        console.log('');
-        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('to initialize.')}`);
-        console.log('');
-        return;
+        fatal('not a relq repository (or any parent directories): .relq', `Run ${colors.cyan('relq init')} to initialize.`);
     }
     const head = getHead(projectRoot);
     const staged = getStagedChanges(projectRoot);
@@ -34,7 +32,7 @@ export async function statusCommand(context) {
         console.log(`${colors.green('Changes to be committed:')}`);
         console.log(`  ${colors.muted('(use "relq restore --staged <name>..." to unstage)')}`);
         console.log('');
-        displayChanges(staged, '	');
+        displayChanges(staged, '        ');
         console.log('');
     }
     if (unstaged.length > 0) {
@@ -42,9 +40,21 @@ export async function statusCommand(context) {
         console.log(`  ${colors.muted('(use "relq add <name>..." to stage)')}`);
         console.log(`  ${colors.muted('(use "relq restore <name>..." to discard)')}`);
         console.log('');
-        displayChanges(unstaged, '	');
+        displayChanges(unstaged, '      ');
         console.log('');
     }
+    const ignorePatterns = 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(`${colors.muted(`${userPatterns.length} pattern(s) active from .relqignore`)}`);
+            console.log('');
+        }
+    }
     if (staged.length === 0 && unstaged.length === 0) {
         console.log(`${colors.green('nothing to commit, working tree clean')}`);
         console.log('');

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

@@ -1,76 +1,56 @@
 import { requireValidConfig } from "../utils/config-loader.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { colors, createSpinner } from "../utils/spinner.js";
-import { isInitialized, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, getRepoStatus, } from "../utils/repo-manager.js";
+import { colors, createSpinner, fatal, success } from "../utils/cli-utils.js";
+import { isInitialized, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, } from "../utils/repo-manager.js";
 import { pullCommand } from "./pull.js";
 export async function syncCommand(context) {
     const { config, flags } = context;
     if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+        fatal('No configuration found', `Run ${colors.cyan('relq init')} to create one.`);
     }
-    requireValidConfig(config);
+    await requireValidConfig(config, { calledFrom: 'sync' });
     const connection = config.connection;
-    const projectRoot = process.cwd();
+    const { projectRoot } = context;
     console.log('');
     if (!isInitialized(projectRoot)) {
-        console.log(`${colors.red('fatal:')} not a relq repository`);
-        console.log('');
-        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('to initialize.')}`);
-        return;
+        fatal('not a relq repository (or any parent directories): .relq', `Run ${colors.cyan('relq init')} to initialize.`);
     }
     const spinner = createSpinner();
     try {
-        spinner.start('Checking sync status...');
-        const status = await getRepoStatus(connection, projectRoot);
-        spinner.stop();
-        console.log(`On database: ${colors.cyan(getConnectionDescription(connection))}`);
+        console.log(`Syncing with ${colors.cyan(getConnectionDescription(connection))}...`);
         console.log('');
-        if (status.behindBy > 0) {
-            console.log(`${colors.yellow('↓')} ${status.behindBy} commit(s) to pull`);
-        }
-        if (status.aheadBy > 0) {
-            console.log(`${colors.green('↑')} ${status.aheadBy} commit(s) to push`);
-        }
-        if (status.behindBy === 0 && status.aheadBy === 0) {
-            console.log(`${colors.green('✓')} Already in sync`);
+        await pullCommand(context);
+        await ensureRemoteTable(connection);
+        const remoteCommits = await fetchRemoteCommits(connection, 100);
+        const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+        const localCommitsAfter = getAllCommits(projectRoot);
+        const toPush = localCommitsAfter.filter(c => !remoteHashes.has(c.hash));
+        if (toPush.length === 0) {
+            success('Sync complete - up to date');
             console.log('');
             return;
         }
+        console.log(`Pushing ${toPush.length} local commit(s)...`);
         console.log('');
-        if (status.behindBy > 0) {
-            console.log(`${colors.cyan('●')} Pulling changes...`);
-            console.log('');
-            const pullContext = {
-                ...context,
-                flags: { ...flags, force: true },
-            };
-            await pullCommand(pullContext);
+        spinner.start(`Pushing ${toPush.length} commit(s)...`);
+        for (const commit of toPush.reverse()) {
+            await pushCommit(connection, commit);
         }
-        if (status.aheadBy > 0) {
-            console.log(`${colors.cyan('●')} Pushing commits...`);
-            console.log('');
-            await ensureRemoteTable(connection);
-            const localCommits = getAllCommits(projectRoot);
-            const remoteCommits = await fetchRemoteCommits(connection, 100);
-            const remoteHashes = new Set(remoteCommits.map(c => c.hash));
-            const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
-            spinner.start(`Pushing ${toPush.length} commit(s)...`);
-            for (const commit of toPush.reverse()) {
-                await pushCommit(connection, commit);
-            }
-            spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+        spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+        console.log('');
+        console.log('Pushed commits:');
+        for (const commit of toPush.slice(0, 5)) {
+            console.log(`  ${colors.yellow(shortHash(commit.hash))} ${commit.message}`);
+        }
+        if (toPush.length > 5) {
+            console.log(`  ${colors.muted(`... and ${toPush.length - 5} more`)}`);
         }
         console.log('');
-        const pulledText = status.behindBy > 0 ? `${colors.yellow(`↓ ${status.behindBy}`)} pulled` : '';
-        const pushedText = status.aheadBy > 0 ? `${colors.green(`↑ ${status.aheadBy}`)} pushed` : '';
-        const separator = pulledText && pushedText ? ' | ' : '';
-        console.log(`${colors.green('✓')} Sync complete: ${pulledText}${separator}${pushedText}`);
+        success(`Sync complete - pushed ${toPush.length} commit(s)`);
     }
-    catch (error) {
+    catch (err) {
         spinner.fail('Sync failed');
-        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
-        process.exit(1);
+        fatal(err instanceof Error ? err.message : String(err));
     }
     console.log('');
 }

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

@@ -0,0 +1,110 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getHead, loadCommit, shortHash } from "../utils/repo-manager.js";
+function loadTags(projectRoot) {
+    const tagPath = path.join(projectRoot, '.relq', 'tags.json');
+    if (fs.existsSync(tagPath)) {
+        return JSON.parse(fs.readFileSync(tagPath, 'utf-8'));
+    }
+    return {};
+}
+function saveTags(tags, projectRoot) {
+    const tagPath = path.join(projectRoot, '.relq', 'tags.json');
+    fs.writeFileSync(tagPath, JSON.stringify(tags, null, 2));
+}
+export async function tagCommand(context) {
+    const { args, flags, projectRoot } = context;
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    const tags = loadTags(projectRoot);
+    const deleteFlag = flags['d'] === true || flags['delete'] === true;
+    const force = flags['f'] === true || flags['force'] === true;
+    if (deleteFlag) {
+        const tagName = args[0];
+        if (!tagName) {
+            console.log(`${colors.red('error:')} Please specify tag name`);
+            console.log('');
+            console.log(`Usage: ${colors.cyan('relq tag -d <name>')}`);
+            console.log('');
+            return;
+        }
+        if (!tags[tagName]) {
+            console.log(`${colors.red('error:')} Tag not found: ${tagName}`);
+            return;
+        }
+        delete tags[tagName];
+        saveTags(tags, projectRoot);
+        console.log(`Deleted tag '${tagName}'`);
+        console.log('');
+        return;
+    }
+    if (args[0]) {
+        const tagName = args[0];
+        const targetHash = args[1];
+        if (!/^[a-zA-Z0-9._-]+$/.test(tagName)) {
+            console.log(`${colors.red('error:')} Invalid tag name`);
+            console.log('Tag names can only contain: letters, numbers, dots, dashes, underscores');
+            console.log('');
+            return;
+        }
+        if (tags[tagName] && !force) {
+            console.log(`${colors.red('error:')} Tag already exists: ${tagName}`);
+            console.log('');
+            console.log(`Use ${colors.cyan(`relq tag -f ${tagName}`)} to overwrite`);
+            console.log('');
+            return;
+        }
+        let hash;
+        if (targetHash) {
+            const commit = loadCommit(targetHash, projectRoot);
+            if (!commit) {
+                console.log(`${colors.red('error:')} Commit not found: ${targetHash}`);
+                return;
+            }
+            hash = commit.hash;
+        }
+        else {
+            const head = getHead(projectRoot);
+            if (!head) {
+                console.log(`${colors.red('error:')} No commits yet`);
+                return;
+            }
+            hash = head;
+        }
+        const commit = loadCommit(hash, projectRoot);
+        if (!commit) {
+            console.log(`${colors.red('error:')} Cannot load commit`);
+            return;
+        }
+        tags[tagName] = {
+            hash,
+            message: commit.message,
+            createdAt: new Date().toISOString(),
+        };
+        saveTags(tags, projectRoot);
+        console.log(`Tagged ${colors.yellow(shortHash(hash))} as '${tagName}'`);
+        console.log(`    ${commit.message}`);
+        console.log('');
+        return;
+    }
+    const tagNames = Object.keys(tags).sort();
+    if (tagNames.length === 0) {
+        console.log(`${colors.muted('No tags.')}`);
+        console.log('');
+        console.log(`Create one with: ${colors.cyan('relq tag <name>')}`);
+        console.log('');
+        return;
+    }
+    for (const name of tagNames) {
+        const tag = tags[name];
+        const hash = colors.yellow(shortHash(tag.hash));
+        const tagName = colors.cyan(name);
+        console.log(`${tagName.padEnd(20)} ${hash}  ${tag.message}`);
+    }
+    console.log('');
+}
+export default tagCommand;