relq 1.0.0 → 1.0.2

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

@@ -0,0 +1,118 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+export async function stashCommand(context) {
+    const { args, flags } = context;
+    const projectRoot = process.cwd();
+    const subcommand = args[0] || 'push';
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${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 = 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(`${colors.green('✓')} 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(`${colors.green('✓')} 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(`${colors.green('✓')} Dropped stash`);
+    console.log('');
+}
+export default stashCommand;

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

@@ -1,5 +1,8 @@
+import * as fs from 'fs';
+import * as path from 'path';
 import { getConnectionDescription } from "../utils/env-loader.js";
 import { colors } 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;
@@ -45,6 +48,18 @@ export async function statusCommand(context) {
         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/tag.js

@@ -0,0 +1,111 @@
+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 } = context;
+    const projectRoot = process.cwd();
+    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(`${colors.green('✓')} 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(`${colors.green('✓')} Tagged ${colors.yellow(shortHash(hash))} as '${colors.cyan(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;

package/dist/esm/cli/index.js

@@ -7,13 +7,21 @@ import { introspectCommand } from "./commands/introspect.js";
 import { syncCommand } from "./commands/sync.js";
 import { statusCommand } from "./commands/status.js";
 import { diffCommand } from "./commands/diff.js";
-import { logCommand } from "./commands/log.js";
+import { logCommand, showCommand } from "./commands/log.js";
 import { rollbackCommand } from "./commands/rollback.js";
 import { commitCommand } from "./commands/commit.js";
 import { fetchCommand } from "./commands/fetch.js";
 import { addCommand } from "./commands/add.js";
 import { importCommand } from "./commands/import.js";
 import { exportCommand } from "./commands/export.js";
+import { resolveCommand } from "./commands/resolve.js";
+import { resetCommand } from "./commands/reset.js";
+import { stashCommand } from "./commands/stash.js";
+import { branchCommand } from "./commands/branch.js";
+import { mergeCommand } from "./commands/merge.js";
+import { tagCommand } from "./commands/tag.js";
+import { cherryPickCommand } from "./commands/cherry-pick.js";
+import { remoteCommand } from "./commands/remote.js";
 const VERSION = '1.1.0';
 function parseArgs(argv) {
     const args = [];
@@ -144,8 +152,8 @@ async function main() {
     if (requiresConfig(command)) {
         const configPath = flags.config;
         try {
-            const { loadConfigWithEnv, findConfigFile } = await import("./utils/config-loader.js");
-            const foundConfig = configPath || findConfigFile();
+            const { loadConfigWithEnv, findConfigFileRecursive } = await import("./utils/config-loader.js");
+            const foundConfig = configPath ? configPath : findConfigFileRecursive()?.path;
             if (!foundConfig) {
                 console.error('Error: relq.config.ts not found.');
                 console.error('Run "relq init" to create one or use --config to specify a path.');
@@ -194,6 +202,9 @@ async function main() {
             case 'log':
                 await logCommand(context);
                 break;
+            case 'show':
+                await showCommand(context);
+                break;
             case 'fetch':
                 await fetchCommand(context);
                 break;
@@ -201,6 +212,39 @@ async function main() {
             case 'revert':
                 await rollbackCommand(context);
                 break;
+            case 'resolve':
+                await resolveCommand(context);
+                break;
+            case 'reset':
+                await resetCommand(context);
+                break;
+            case 'stash':
+                await stashCommand(context);
+                break;
+            case 'branch':
+                await branchCommand(context);
+                break;
+            case 'checkout':
+            case 'switch':
+                console.log('');
+                console.log('⚠️  Branch switching is currently disabled.');
+                console.log('');
+                console.log('This feature will be available when Relq Postgres Native is officially launched.');
+                console.log('For now, work on a single branch and use merge to combine schemas.');
+                console.log('');
+                break;
+            case 'merge':
+                await mergeCommand(context);
+                break;
+            case 'tag':
+                await tagCommand(context);
+                break;
+            case 'cherry-pick':
+                await cherryPickCommand(context);
+                break;
+            case 'remote':
+                await remoteCommand(context);
+                break;
             case 'introspect':
                 await introspectCommand(context);
                 break;

package/dist/esm/cli/utils/commit-manager.js

@@ -69,7 +69,7 @@ CREATE INDEX IF NOT EXISTS idx_relq_commits_created
     ON _relq_commits(created_at DESC);
 `;
 export async function ensureCommitsTable(connection) {
-    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,
@@ -87,7 +87,7 @@ export async function ensureCommitsTable(connection) {
     }
 }
 export async function getRemoteCommits(connection, limit = 100) {
-    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,
@@ -124,7 +124,7 @@ export async function getLatestRemoteCommit(connection) {
     return commits.length > 0 ? commits[0] : null;
 }
 export async function addRemoteCommit(connection, commit, limit = 1000) {
-    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,

package/dist/esm/cli/utils/env-loader.js

@@ -1,5 +1,5 @@
 export function loadEnvConfig() {
-    const connectionString = process.env.DATABASE_CONNECTION_STRING;
+    const connectionString = process.env.RELQ_PG_CONN_URL || process.env.DATABASE_CONNECTION_STRING;
     if (connectionString) {
         return parseConnectionString(connectionString);
     }
@@ -37,7 +37,8 @@ function parseConnectionString(url) {
     }
 }
 export function hasEnvConfig() {
-    return !!(process.env.DATABASE_CONNECTION_STRING ||
+    return !!(process.env.RELQ_PG_CONN_URL ||
+        process.env.DATABASE_CONNECTION_STRING ||
         process.env.DATABASE_HOST);
 }
 export function getConnectionDescription(config) {

package/dist/esm/cli/utils/fast-introspect.js

@@ -1,6 +1,6 @@
 export async function fastIntrospectDatabase(connection, onProgress, options) {
     const { includeFunctions = false, includeTriggers = false } = options || {};
-    const { Pool } = await import("../../addon/pg.js");
+    const { Pool } = await import("../../addon/pg/index.js");
     onProgress?.('connecting', connection.database);
     const pool = new Pool({
         host: connection.host,

package/dist/esm/cli/utils/project-root.js

@@ -0,0 +1,19 @@
+import * as fs from 'fs';
+import * as path from 'path';
+export function findProjectRoot(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const packageJsonPath = path.join(currentDir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            return currentDir;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return process.cwd();
+}
+export function getRelqDir(startDir = process.cwd()) {
+    const projectRoot = findProjectRoot(startDir) || process.cwd();
+    return path.join(projectRoot, '.relq');
+}
+export default { findProjectRoot, getRelqDir };