relq 1.0.1 → 1.0.3

package/dist/esm/cli/commands/cherry-pick.js

@@ -0,0 +1,246 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, loadCommit, loadParentCommit, loadSnapshot, saveSnapshot, createCommit, shortHash, resolveRef, } from "../utils/repo-manager.js";
+export async function cherryPickCommand(context) {
+    const { config, args, flags, projectRoot } = context;
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${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('Cherry-pick aborted');
+        }
+        else {
+            console.log('No cherry-pick in progress.');
+        }
+        console.log('');
+        return;
+    }
+    if (fs.existsSync(cherryPickStatePath)) {
+        const state = JSON.parse(fs.readFileSync(cherryPickStatePath, 'utf-8'));
+        console.log(`${colors.red('error:')} Cherry-pick in progress from ${shortHash(state.fromCommit)}`);
+        console.log('');
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve')} ${colors.muted('to resolve conflicts')}`);
+        console.log(`${colors.muted('Or')} ${colors.cyan('relq cherry-pick --abort')} ${colors.muted('to cancel')}`);
+        console.log('');
+        return;
+    }
+    const ref = args[0];
+    if (!ref) {
+        console.log(`${colors.red('error:')} Please specify a commit`);
+        console.log('');
+        console.log(`Usage: ${colors.cyan('relq cherry-pick <commit>')}`);
+        console.log('');
+        return;
+    }
+    const spinner = createSpinner();
+    spinner.start(`Cherry-picking ${shortHash(ref)}...`);
+    try {
+        const hash = resolveRef(ref, projectRoot);
+        if (!hash) {
+            spinner.fail(`Commit not found: ${ref}`);
+            return;
+        }
+        const targetCommit = loadCommit(hash, projectRoot);
+        const parentCommit = 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 = 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(`   ${colors.red('conflict:')} ${c.objectType.toLowerCase()} ${name}`);
+                console.log(`      ${colors.muted(c.description)}`);
+            }
+            if (conflicts.length > 5) {
+                console.log(`   ${colors.muted(`... and ${conflicts.length - 5} more`)}`);
+            }
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve --theirs')} ${colors.muted('to resolve')}`);
+            console.log(`${colors.muted('Or')} ${colors.cyan('relq cherry-pick --abort')} ${colors.muted('to cancel')}`);
+            console.log('');
+            return;
+        }
+        const newSnapshot = applyCommitDiff(currentSnapshot, diff);
+        saveSnapshot(newSnapshot, projectRoot);
+        const author = config?.author || 'Relq CLI';
+        const message = `Cherry-picked ${shortHash(hash)}: ${targetCommit.message}`;
+        const commit = createCommit(newSnapshot, author, message, projectRoot);
+        spinner.succeed(`Cherry-picked ${colors.yellow(shortHash(hash))}`);
+        console.log(`   ${colors.cyan(commit.message)}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Cherry-pick failed');
+        console.error(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;
+}
+export default cherryPickCommand;

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

@@ -1,31 +1,27 @@
 import * as crypto from 'crypto';
-import { colors } from "../utils/spinner.js";
-import { isInitialized, getHead, getStagedChanges, getUnstagedChanges, shortHash, } from "../utils/repo-manager.js";
+import { fatal, hint } from "../utils/cli-utils.js";
+import { isInitialized, getHead, getStagedChanges, getUnstagedChanges, shortHash, hashFileContent, saveFileHash, } from "../utils/repo-manager.js";
+import { loadConfig } from "../../config/config.js";
 import { sortChangesByDependency, generateCombinedSQL, } from "../utils/change-tracker.js";
 import * as fs from 'fs';
 import * as path from 'path';
 export async function commitCommand(context) {
-    const { config, flags, args } = context;
-    const projectRoot = process.cwd();
+    const { config, flags, args, projectRoot } = context;
     const author = config?.author || 'Developer <dev@example.com>';
     console.log('');
     if (!isInitialized(projectRoot)) {
-        console.log(`${colors.red('error:')} relq not initialized`);
-        console.log('');
-        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('first.')}`);
-        return;
+        fatal('not a relq repository (or any parent directories): .relq', "run 'relq init' to initialize");
     }
     const staged = getStagedChanges(projectRoot);
     if (staged.length === 0) {
-        console.log(`${colors.yellow('Nothing to commit')}`);
-        console.log('');
+        console.log('nothing to commit, working tree clean');
         const unstaged = getUnstagedChanges(projectRoot);
         if (unstaged.length > 0) {
-            console.log(`${colors.muted(`${unstaged.length} unstaged change(s).`)}`);
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq add .')} ${colors.muted('to stage all changes.')}`);
+            console.log(`${unstaged.length} unstaged change(s).`);
+            hint("run 'relq add .' to stage all changes");
         }
         else {
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq add <table>')} ${colors.muted('to stage changes.')}`);
+            hint("run 'relq add <table>' to stage changes");
         }
         return;
     }
@@ -35,10 +31,7 @@ export async function commitCommand(context) {
             message = args.join(' ');
         }
         else {
-            console.log(`${colors.red('error:')} commit message required`);
-            console.log('');
-            console.log(`${colors.muted('Usage:')} relq commit -m "message"`);
-            return;
+            fatal('commit message required', "usage: relq commit -m '<message>'");
         }
     }
     const sortedChanges = sortChangesByDependency(staged);
@@ -77,7 +70,7 @@ export async function commitCommand(context) {
     fs.writeFileSync(path.join(commitsDir, `${hash}.json`), JSON.stringify(commit, null, 2), 'utf-8');
     fs.writeFileSync(path.join(projectRoot, '.relq', 'HEAD'), hash, 'utf-8');
     const workingPath = path.join(projectRoot, '.relq', 'working.json');
-    const unstaged = getUnstagedChanges(projectRoot);
+    const unstaged = getUnstagedChanges(projectRoot).filter(c => c.objectType !== 'SCHEMA_FILE');
     if (unstaged.length > 0) {
         fs.writeFileSync(workingPath, JSON.stringify({
             timestamp: new Date().toISOString(),
@@ -90,20 +83,19 @@ export async function commitCommand(context) {
             fs.unlinkSync(workingPath);
         }
     }
-    console.log(`${colors.yellow(`[${shortHash(hash)}]`)} ${message}`);
-    console.log('');
-    if (creates > 0) {
-        console.log(` ${colors.green(`${creates} created`)}`);
-    }
-    if (alters > 0) {
-        console.log(` ${colors.yellow(`${alters} altered`)}`);
-    }
-    if (drops > 0) {
-        console.log(` ${colors.red(`${drops} dropped`)}`);
+    const commitConfig = await loadConfig();
+    const schemaPathRaw = typeof commitConfig.schema === 'string' ? commitConfig.schema : './db/schema.ts';
+    const schemaFilePath = path.resolve(projectRoot, schemaPathRaw);
+    if (fs.existsSync(schemaFilePath)) {
+        const currentContent = fs.readFileSync(schemaFilePath, 'utf-8');
+        const currentHash = hashFileContent(currentContent);
+        saveFileHash(currentHash, projectRoot);
     }
+    console.log(`[${shortHash(hash)}] ${message}`);
+    console.log(` ${creates} create(s), ${alters} alter(s), ${drops} drop(s)`);
     console.log('');
-    console.log(`${colors.muted('Run')} ${colors.cyan('relq push')} ${colors.muted('to apply changes to database.')}`);
-    console.log(`${colors.muted('Run')} ${colors.cyan('relq export')} ${colors.muted('to export as SQL file.')}`);
+    hint("run 'relq push' to apply changes to database");
+    hint("run 'relq export' to export as SQL file");
     console.log('');
 }
 export default commitCommand;

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

@@ -1,81 +1,156 @@
 import { requireValidConfig } from "../utils/config-loader.js";
-import { introspectDatabase } from "../utils/schema-introspect.js";
-import { loadSnapshot, snapshotToDatabaseSchema } from "../utils/snapshot-manager.js";
-import { formatDiff } from "../utils/schema-diff.js";
-import { normalizeSchema } from "../utils/schema-hash.js";
-import { diffSchemas } from "../utils/schema-diff.js";
-import { generateMigration } from "../utils/migration-generator.js";
+import { fastIntrospectDatabase } from "../utils/fast-introspect.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',
-    blue: '\x1b[34m',
-    cyan: '\x1b[36m',
-    magenta: '\x1b[35m',
-};
-function filterDiff(diff, ignorePatterns) {
-    const patterns = ignorePatterns.map(p => {
-        const regexStr = p.replace(/\*/g, '.*').replace(/\?/g, '.');
-        return new RegExp(`^${regexStr}$`, 'i');
-    });
-    const matchesPattern = (name) => patterns.some(p => p.test(name));
-    const tables = diff.tables.filter(t => !matchesPattern(t.name));
-    const hasChanges = tables.length > 0 || diff.extensions.length > 0;
-    return {
-        ...diff,
-        tables,
-        hasChanges,
-    };
-}
+import { colors, createSpinner, fatal } from "../utils/cli-utils.js";
+import { isInitialized, loadSnapshot, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+import { getChangeDisplayName, generateChangeSQL, sortChangesByDependency } from "../utils/change-tracker.js";
 export async function diffCommand(context) {
-    const { config, flags } = context;
-    if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+    const { config, args, flags, projectRoot } = context;
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        fatal('not a relq repository (or any parent directories): .relq', `Run ${colors.cyan('relq init')} to initialize.`);
     }
-    requireValidConfig(config);
-    const connection = config.connection;
-    const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
-    const ignorePatterns = config.sync?.ignore || ['_relq_*'];
     const showSQL = flags['sql'] === true;
-    console.log(`${colors.bold}Comparing:${colors.reset} local snapshot ↔ ${getConnectionDescription(connection)}`);
-    console.log('');
-    try {
-        const dbSchema = await introspectDatabase(connection);
-        const snapshot = loadSnapshot(snapshotPath);
-        if (!snapshot) {
-            console.log(`${colors.yellow}No snapshot found.${colors.reset}`);
-            console.log(`Run "${colors.cyan}relq pull${colors.reset}" to create initial snapshot.`);
-            return;
+    const staged = flags['staged'] === true;
+    const target = args[0];
+    if (staged) {
+        await showStagedDiff(projectRoot, showSQL);
+        return;
+    }
+    if (target === 'remote/live' || target === 'remote' || target === 'live' || target === 'origin') {
+        if (!config) {
+            fatal('No configuration found', `Run ${colors.cyan('relq init')} to create one.`);
         }
-        const localSchema = snapshotToDatabaseSchema(snapshot);
-        const normalizedLocal = normalizeSchema(localSchema);
-        const normalizedDb = normalizeSchema(dbSchema);
-        const diff = diffSchemas(normalizedLocal, normalizedDb);
-        const filteredDiff = filterDiff(diff, ignorePatterns);
-        if (!filteredDiff.hasChanges) {
-            console.log(`${colors.green}No differences.${colors.reset}`);
-            return;
+        await requireValidConfig(config, { calledFrom: 'diff' });
+        await showOriginDiff(config, projectRoot, showSQL);
+        return;
+    }
+    await showUnstagedDiff(projectRoot, showSQL);
+}
+function getSymbol(change) {
+    if (change.type === 'CREATE')
+        return colors.green('+');
+    if (change.type === 'DROP')
+        return colors.red('-');
+    return colors.yellow('~');
+}
+async function showUnstagedDiff(projectRoot, showSQL) {
+    const unstaged = getUnstagedChanges(projectRoot);
+    if (unstaged.length === 0) {
+        console.log(`${colors.green('No unstaged changes.')}`);
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq diff remote/live')} ${colors.muted('to compare with remote.')}`);
+        console.log('');
+        return;
+    }
+    console.log(`${colors.bold('Unstaged changes:')}`);
+    console.log('');
+    const sorted = sortChangesByDependency(unstaged);
+    for (const change of sorted) {
+        console.log(`   ${getSymbol(change)} ${change.objectType.toLowerCase()}: ${getChangeDisplayName(change)}`);
+    }
+    if (showSQL) {
+        console.log('');
+        console.log(`${colors.bold('SQL:')}`);
+        for (const change of sorted) {
+            const sql = generateChangeSQL(change);
+            if (sql)
+                console.log(`${colors.cyan(sql)}`);
         }
-        console.log(formatDiff(filteredDiff));
-        if (showSQL) {
-            console.log('');
-            console.log(`${colors.bold}Generated SQL:${colors.reset}`);
-            console.log('');
-            const { up } = generateMigration(filteredDiff, { includeDown: false });
-            for (const sql of up) {
-                console.log(`${colors.cyan}${sql}${colors.reset}`);
-            }
+    }
+    console.log('');
+    console.log(`${colors.muted('Use')} ${colors.cyan('relq add .')} ${colors.muted('to stage all.')}`);
+    console.log('');
+}
+async function showStagedDiff(projectRoot, showSQL) {
+    const staged = getStagedChanges(projectRoot);
+    if (staged.length === 0) {
+        console.log(`${colors.green('No staged changes.')}`);
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq add .')} ${colors.muted('to stage changes.')}`);
+        console.log('');
+        return;
+    }
+    console.log(`${colors.bold('Staged changes:')}`);
+    console.log('');
+    const sorted = sortChangesByDependency(staged);
+    for (const change of sorted) {
+        console.log(`   ${getSymbol(change)} ${change.objectType.toLowerCase()}: ${getChangeDisplayName(change)}`);
+    }
+    if (showSQL) {
+        console.log('');
+        console.log(`${colors.bold('SQL:')}`);
+        for (const change of sorted) {
+            const sql = generateChangeSQL(change);
+            if (sql)
+                console.log(`${colors.cyan(sql)}`);
         }
+    }
+    console.log('');
+    console.log(`${colors.muted('Use')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to commit.')}`);
+    console.log('');
+}
+async function showOriginDiff(config, projectRoot, showSQL) {
+    const connection = config.connection;
+    const spinner = createSpinner();
+    const snapshot = loadSnapshot(projectRoot);
+    if (!snapshot) {
+        console.log(`${colors.yellow('No local snapshot.')}`);
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('first.')}`);
+        console.log('');
+        return;
+    }
+    spinner.start(`Connecting to ${getConnectionDescription(connection)}...`);
+    const remoteDb = await fastIntrospectDatabase(connection, undefined, {
+        includeFunctions: config.includeFunctions ?? false,
+        includeTriggers: config.includeTriggers ?? false,
+    });
+    spinner.succeed(`Connected`);
+    const diffs = compareSchemas(snapshot, remoteDb);
+    if (diffs.length === 0) {
+        console.log('');
+        console.log('Local and remote are in sync.');
         console.log('');
-        console.log(`${colors.dim}Use "relq diff --sql" to see generated SQL statements.${colors.reset}`);
+        return;
+    }
+    console.log('');
+    console.log(`${colors.bold('Differences:')}`);
+    console.log('');
+    for (const d of diffs.slice(0, 20)) {
+        const sym = d.type === 'added' ? colors.green('+') : d.type === 'removed' ? colors.red('-') : colors.yellow('~');
+        console.log(`   ${sym} ${d.description}`);
     }
-    catch (error) {
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+    if (diffs.length > 20) {
+        console.log(`   ${colors.muted(`... and ${diffs.length - 20} more`)}`);
+    }
+    console.log('');
+    console.log(`${colors.muted('Use')} ${colors.cyan('relq pull')} ${colors.muted('to sync local with remote.')}`);
+    console.log('');
+}
+function compareSchemas(local, remote) {
+    const diffs = [];
+    const localTableNames = local.tables.map(t => t.name);
+    const remoteTableNames = (remote.tables || []).map((t) => t.name);
+    for (const name of remoteTableNames) {
+        if (!localTableNames.includes(name)) {
+            diffs.push({ type: 'added', description: `table: ${name}` });
+        }
+    }
+    for (const name of localTableNames) {
+        if (!remoteTableNames.includes(name)) {
+            diffs.push({ type: 'removed', description: `table: ${name}` });
+        }
+    }
+    const localEnumNames = local.enums.map(e => e.name);
+    const remoteEnumNames = (remote.enums || []).map((e) => e.name);
+    for (const name of remoteEnumNames) {
+        if (!localEnumNames.includes(name)) {
+            diffs.push({ type: 'added', description: `enum: ${name}` });
+        }
+    }
+    for (const name of localEnumNames) {
+        if (!remoteEnumNames.includes(name)) {
+            diffs.push({ type: 'removed', description: `enum: ${name}` });
+        }
     }
+    return diffs;
 }
+export default diffCommand;