relq 1.0.2 → 1.0.4

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

@@ -14,8 +14,7 @@ function saveTags(tags, projectRoot) {
     fs.writeFileSync(tagPath, JSON.stringify(tags, null, 2));
 }
 export async function tagCommand(context) {
-    const { args, flags } = context;
-    const projectRoot = process.cwd();
+    const { args, flags, projectRoot } = context;
     console.log('');
     if (!isInitialized(projectRoot)) {
         console.log(`${colors.red('fatal:')} not a relq repository`);
@@ -39,7 +38,7 @@ export async function tagCommand(context) {
         }
         delete tags[tagName];
         saveTags(tags, projectRoot);
-        console.log(`${colors.green('✓')} Deleted tag '${tagName}'`);
+        console.log(`Deleted tag '${tagName}'`);
         console.log('');
         return;
     }
@@ -87,7 +86,7 @@ export async function tagCommand(context) {
             createdAt: new Date().toISOString(),
         };
         saveTags(tags, projectRoot);
-        console.log(`${colors.green('✓')} Tagged ${colors.yellow(shortHash(hash))} as '${colors.cyan(tagName)}'`);
+        console.log(`Tagged ${colors.yellow(shortHash(hash))} as '${tagName}'`);
         console.log(`    ${commit.message}`);
         console.log('');
         return;

package/dist/esm/cli/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { initCommand } from "./commands/init.js";
 import { pullCommand } from "./commands/pull.js";
 import { pushCommand } from "./commands/push.js";
@@ -22,6 +21,34 @@ 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";
+import * as fs from 'fs';
+import * as path from 'path';
+function loadEnvFile() {
+    let currentDir = process.cwd();
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const envPath = path.join(currentDir, '.env');
+        if (fs.existsSync(envPath)) {
+            const envContent = fs.readFileSync(envPath, 'utf-8');
+            for (const line of envContent.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const match = trimmed.match(/^([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    const value = match[2].trim().replace(/^["']|["']$/g, '');
+                    if (!process.env[key]) {
+                        process.env[key] = value;
+                    }
+                }
+            }
+            return;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+}
+loadEnvFile();
 const VERSION = '1.1.0';
 function parseArgs(argv) {
     const args = [];
@@ -149,20 +176,56 @@ async function main() {
         process.exit(1);
     }
     let config = null;
+    let resolvedProjectRoot = process.cwd();
     if (requiresConfig(command)) {
         const configPath = flags.config;
         try {
             const { loadConfigWithEnv, findConfigFileRecursive } = await import("./utils/config-loader.js");
-            const foundConfig = configPath ? configPath : findConfigFileRecursive()?.path;
+            const { findProjectRoot } = await import("./utils/project-root.js");
+            const configResult = configPath ? { path: configPath, directory: path.dirname(path.resolve(configPath)) } : findConfigFileRecursive();
+            if (!configResult) {
+                const projectRoot = findProjectRoot();
+                if (!projectRoot) {
+                    const colors = {
+                        red: (s) => `\x1b[31m${s}\x1b[0m`,
+                        yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+                        cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+                    };
+                    console.error('');
+                    console.error(colors.red('fatal:') + ' not a relq project (or any of the parent directories)');
+                    console.error('');
+                    console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} in your project directory to initialize relq.`);
+                    console.error('');
+                    process.exit(128);
+                }
+            }
+            resolvedProjectRoot = configResult?.directory || findProjectRoot() || process.cwd();
+            const foundConfig = configResult?.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.');
+                const colors = {
+                    red: (s) => `\x1b[31m${s}\x1b[0m`,
+                    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+                    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+                };
+                console.error('');
+                console.error(colors.red('error:') + ' relq.config.ts not found');
+                console.error('');
+                console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} to create one or use ${colors.cyan('--config')} to specify a path.`);
+                console.error('');
                 process.exit(1);
             }
             config = await loadConfigWithEnv(configPath);
             if (requiresDbConnection(command, flags) && !config.connection?.host && !config.connection?.url) {
-                console.error('Error: No database connection configured.');
-                console.error('Run "relq init" or set DATABASE_* environment variables.');
+                const colors = {
+                    red: (s) => `\x1b[31m${s}\x1b[0m`,
+                    yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+                    cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+                };
+                console.error('');
+                console.error(colors.red('error:') + ' No database connection configured');
+                console.error('');
+                console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} or set DATABASE_* environment variables.`);
+                console.error('');
                 process.exit(1);
             }
         }
@@ -171,7 +234,7 @@ async function main() {
             process.exit(1);
         }
     }
-    const context = { config, args, flags };
+    const context = { config, args, flags, projectRoot: resolvedProjectRoot };
     try {
         switch (command) {
             case 'init':
@@ -261,7 +324,7 @@ async function main() {
                     theirs: Boolean(flags.theirs),
                     ours: Boolean(flags.ours),
                     abort: Boolean(flags.abort),
-                });
+                }, resolvedProjectRoot);
                 break;
             case 'export':
                 await exportCommand(context);
@@ -281,4 +344,4 @@ async function main() {
         process.exit(1);
     }
 }
-main().catch(console.error);
+export { main };

package/dist/esm/cli/utils/change-tracker.js

@@ -31,6 +31,12 @@ export function generateChangeSQL(change) {
             return generateConstraintSQL(change);
         case 'PARTITION':
             return generatePartitionSQL(change);
+        case 'PARTITION_CHILD':
+            return generatePartitionChildSQL(change);
+        case 'TABLE_COMMENT':
+            return generateTableCommentSQL(change);
+        case 'COLUMN_COMMENT':
+            return generateColumnCommentSQL(change);
         case 'VIEW':
             return generateViewSQL(change);
         case 'MATERIALIZED_VIEW':
@@ -44,6 +50,8 @@ export function generateChangeSQL(change) {
             return generateForeignServerSQL(change);
         case 'FOREIGN_TABLE':
             return generateForeignTableSQL(change);
+        case 'COLLATION':
+            return generateCollationSQL(change);
         default:
             return `-- Unsupported object type: ${change.objectType}`;
     }
@@ -144,8 +152,11 @@ function generateTableSQL(change) {
         }
         const allDefs = [...colDefs, ...constraintDefs].join(',\n');
         let sql = `CREATE TABLE "${data.name}" (\n${allDefs}\n)`;
-        if (data.isPartitioned && data.partitionType && data.partitionKey?.length) {
-            sql += ` PARTITION BY ${data.partitionType} (${data.partitionKey.join(', ')})`;
+        if (data.isPartitioned && data.partitionType && data.partitionKey) {
+            const keyArr = Array.isArray(data.partitionKey) ? data.partitionKey : [data.partitionKey];
+            if (keyArr.length) {
+                sql += ` PARTITION BY ${data.partitionType} (${keyArr.join(', ')})`;
+            }
         }
         return sql + ';';
     }
@@ -226,6 +237,9 @@ function generateConstraintSQL(change) {
     return '';
 }
 function generatePartitionSQL(change) {
+    return '';
+}
+function generatePartitionChildSQL(change) {
     const data = change.after;
     if (change.type === 'CREATE' && data) {
         return `CREATE TABLE "${data.name}" PARTITION OF "${data.parentTable}" ${data.bound};`;
@@ -235,6 +249,33 @@ function generatePartitionSQL(change) {
     }
     return '';
 }
+function generateTableCommentSQL(change) {
+    const data = change.after;
+    if ((change.type === 'CREATE' || change.type === 'ALTER') && data) {
+        const escaped = data.comment.replace(/'/g, "''");
+        return `COMMENT ON TABLE "${data.tableName}" IS '${escaped}';`;
+    }
+    else if (change.type === 'DROP') {
+        const beforeData = change.before;
+        const tableName = beforeData?.tableName || change.objectName;
+        return `COMMENT ON TABLE "${tableName}" IS NULL;`;
+    }
+    return '';
+}
+function generateColumnCommentSQL(change) {
+    const data = change.after;
+    if ((change.type === 'CREATE' || change.type === 'ALTER') && data) {
+        const escaped = data.comment.replace(/'/g, "''");
+        return `COMMENT ON COLUMN "${data.tableName}"."${data.columnName}" IS '${escaped}';`;
+    }
+    else if (change.type === 'DROP') {
+        const beforeData = change.before;
+        const tableName = beforeData?.tableName || change.parentName || '';
+        const columnName = beforeData?.columnName || change.objectName;
+        return `COMMENT ON COLUMN "${tableName}"."${columnName}" IS NULL;`;
+    }
+    return '';
+}
 function generateViewSQL(change) {
     const data = change.after;
     if (change.type === 'CREATE' && data) {
@@ -320,6 +361,28 @@ function generateForeignTableSQL(change) {
     }
     return '';
 }
+function generateCollationSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const options = [];
+        if (data.locale)
+            options.push(`LOCALE = '${data.locale}'`);
+        if (data.lcCollate)
+            options.push(`LC_COLLATE = '${data.lcCollate}'`);
+        if (data.lcCtype)
+            options.push(`LC_CTYPE = '${data.lcCtype}'`);
+        if (data.provider)
+            options.push(`PROVIDER = ${data.provider}`);
+        if (data.deterministic !== undefined) {
+            options.push(`DETERMINISTIC = ${data.deterministic ? 'TRUE' : 'FALSE'}`);
+        }
+        return `CREATE COLLATION IF NOT EXISTS "${data.name}" (${options.join(', ')});`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP COLLATION IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
 export function createChange(type, objectType, objectName, before, after, parentName) {
     const id = generateChangeId(type, objectType, objectName, parentName);
     const change = {
@@ -341,6 +404,42 @@ export function getChangeDisplayName(change) {
         change.type === 'DROP' ? '-' :
             change.type === 'ALTER' ? '~' :
                 '>';
+    if (change.objectType === 'INDEX') {
+        const data = change.after;
+        const tableName = data?.tableName || change.parentName;
+        if (tableName) {
+            return `${prefix} ${change.objectType} ${change.objectName} on ${tableName}`;
+        }
+    }
+    if (change.objectType === 'PARTITION') {
+        const data = change.after;
+        if (data?.tableName && data?.type && data?.key) {
+            let keyStr = Array.isArray(data.key) ? data.key.join(', ') : data.key;
+            keyStr = keyStr.replace(/[{}]/g, '');
+            return `${prefix} PARTITIONED ${data.tableName} by ${data.type.toUpperCase()}(${keyStr})`;
+        }
+    }
+    if (change.objectType === 'PARTITION_CHILD') {
+        const data = change.after;
+        if (data?.name && data?.parentTable) {
+            const bound = data.bound || '';
+            return `${prefix} PARTITION ${data.name} of ${data.parentTable} ${bound}`;
+        }
+    }
+    if (change.objectType === 'CHECK') {
+        const actionWord = change.type === 'CREATE' ? 'ADD' : change.type === 'DROP' ? 'DROP' : 'ALTER';
+        if (change.parentName) {
+            return `${prefix} ${actionWord} CHECK ${change.objectName} on ${change.parentName}`;
+        }
+        return `${prefix} ${actionWord} CHECK ${change.objectName}`;
+    }
+    if (change.objectType === 'PRIMARY_KEY' || change.objectType === 'FOREIGN_KEY' || change.objectType === 'EXCLUSION') {
+        const actionWord = change.type === 'CREATE' ? 'ADD' : change.type === 'DROP' ? 'DROP' : 'ALTER';
+        if (change.parentName) {
+            return `${prefix} ${actionWord} ${change.objectType.replace('_', ' ')} ${change.objectName} on ${change.parentName}`;
+        }
+        return `${prefix} ${actionWord} ${change.objectType.replace('_', ' ')} ${change.objectName}`;
+    }
     if (change.parentName) {
         return `${prefix} ${change.objectType} ${change.parentName}.${change.objectName}`;
     }
@@ -350,14 +449,18 @@ export function sortChangesByDependency(changes) {
     const order = {
         'EXTENSION': 1,
         'SCHEMA': 2,
+        'SCHEMA_FILE': 0,
         'ENUM': 3,
         'DOMAIN': 4,
         'COMPOSITE_TYPE': 5,
         'SEQUENCE': 6,
         'FOREIGN_SERVER': 7,
         'TABLE': 10,
+        'TABLE_COMMENT': 10,
         'PARTITION': 11,
-        'COLUMN': 12,
+        'PARTITION_CHILD': 12,
+        'COLUMN': 13,
+        'COLUMN_COMMENT': 12,
         'INDEX': 13,
         'CONSTRAINT': 14,
         'PRIMARY_KEY': 14,
@@ -370,6 +473,7 @@ export function sortChangesByDependency(changes) {
         'PROCEDURE': 31,
         'TRIGGER': 40,
         'ENUM_VALUE': 3,
+        'COLLATION': 4,
         'FOREIGN_TABLE': 8,
     };
     return [...changes].sort((a, b) => {

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

@@ -0,0 +1,169 @@
+import * as readline from 'readline';
+const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+export const colors = {
+    reset: '\x1b[0m',
+    red: (s) => isColorSupported ? `\x1b[31m${s}\x1b[0m` : s,
+    green: (s) => isColorSupported ? `\x1b[32m${s}\x1b[0m` : s,
+    yellow: (s) => isColorSupported ? `\x1b[33m${s}\x1b[0m` : s,
+    blue: (s) => isColorSupported ? `\x1b[34m${s}\x1b[0m` : s,
+    magenta: (s) => isColorSupported ? `\x1b[35m${s}\x1b[0m` : s,
+    cyan: (s) => isColorSupported ? `\x1b[36m${s}\x1b[0m` : s,
+    white: (s) => isColorSupported ? `\x1b[37m${s}\x1b[0m` : s,
+    gray: (s) => isColorSupported ? `\x1b[90m${s}\x1b[0m` : s,
+    bold: (s) => isColorSupported ? `\x1b[1m${s}\x1b[0m` : s,
+    dim: (s) => isColorSupported ? `\x1b[2m${s}\x1b[0m` : s,
+    muted: (s) => isColorSupported ? `\x1b[90m${s}\x1b[0m` : s,
+    success: (s) => isColorSupported ? `\x1b[32m${s}\x1b[0m` : s,
+    error: (s) => isColorSupported ? `\x1b[31m${s}\x1b[0m` : s,
+    warning: (s) => isColorSupported ? `\x1b[33m${s}\x1b[0m` : s,
+    info: (s) => isColorSupported ? `\x1b[34m${s}\x1b[0m` : s,
+};
+export function createSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    let interval = null;
+    let currentMessage = '';
+    let isSpinning = false;
+    const isTTY = process.stdout.isTTY;
+    const clearLine = () => {
+        if (isTTY)
+            process.stdout.write('\r\x1b[K');
+    };
+    const render = () => {
+        if (!isSpinning)
+            return;
+        clearLine();
+        process.stdout.write(`${colors.cyan(frames[frameIndex])} ${currentMessage}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+    };
+    return {
+        start(message) {
+            if (isSpinning)
+                this.stop();
+            currentMessage = message;
+            isSpinning = true;
+            frameIndex = 0;
+            if (isTTY) {
+                interval = setInterval(render, 80);
+                render();
+            }
+            else {
+                console.log(`${message}...`);
+            }
+        },
+        update(message) {
+            currentMessage = message;
+        },
+        succeed(message) {
+            this.stop();
+            console.log(message || currentMessage);
+        },
+        fail(message) {
+            this.stop();
+        },
+        info(message) {
+            this.stop();
+            console.log(message || currentMessage);
+        },
+        warn(message) {
+            this.stop();
+            warning(message || currentMessage);
+        },
+        stop() {
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+            }
+            if (isSpinning && isTTY) {
+                clearLine();
+            }
+            isSpinning = false;
+        }
+    };
+}
+export function fatal(message, hintMessage) {
+    console.error(`${colors.red('fatal:')} ${message}`);
+    if (hintMessage) {
+        hint(hintMessage);
+    }
+    process.exit(1);
+}
+export function error(message, hintMessage) {
+    console.error(`${colors.red('error:')} ${message}`);
+    if (hintMessage) {
+        hint(hintMessage);
+    }
+}
+export function warning(message) {
+    console.error(`${colors.yellow('warning:')} ${message}`);
+}
+export function hint(message) {
+    console.error(`${colors.yellow('hint:')} ${message}`);
+}
+export function success(message) {
+    console.log(colors.green(message));
+}
+export function confirm(question, defaultYes = true) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
+    return new Promise((resolve) => {
+        rl.question(`${question} ${suffix} `, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+export function select(question, options) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log(question);
+    options.forEach((opt, i) => {
+        console.log(`  ${i + 1}) ${opt}`);
+    });
+    return new Promise((resolve) => {
+        rl.question(`Select [1-${options.length}]: `, (answer) => {
+            rl.close();
+            const num = parseInt(answer.trim(), 10);
+            if (num >= 1 && num <= options.length) {
+                resolve(num - 1);
+            }
+            else {
+                resolve(0);
+            }
+        });
+    });
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
+}
+export function progressBar(current, total, width = 30) {
+    const percentage = Math.min(100, Math.round((current / total) * 100));
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    return `${'#'.repeat(filled)}${'.'.repeat(empty)} ${percentage}%`;
+}
+export function requireInit(isInitialized, projectRoot) {
+    if (!isInitialized) {
+        fatal('not a relq repository (or any of the parent directories): .relq', "run 'relq init' to initialize a repository");
+    }
+}

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

@@ -64,7 +64,7 @@ export function validateConfig(config) {
     if (!config.connection?.host && !config.connection?.url) {
         errors.push('No database connection configured. Set connection in relq.config.ts or use DATABASE_* env vars.');
     }
-    const hasSchemaPath = typeof config.schema === 'string';
+    const hasSchemaPath = typeof config.schema === 'string' && config.schema.length > 0;
     const hasSchemaDir = typeof config.schema === 'object' && config.schema?.directory;
     const hasTypeGenOutput = config.typeGeneration?.output;
     const hasGenerateOutDir = config.generate?.outDir;
@@ -73,14 +73,40 @@ export function validateConfig(config) {
     }
     return errors;
 }
-export function requireValidConfig(config) {
+export async function requireValidConfig(config, options) {
     const errors = validateConfig(config);
-    if (errors.length > 0) {
-        console.error('Configuration errors:');
-        for (const error of errors) {
-            console.error(`  • ${error}`);
+    if (errors.length === 0)
+        return;
+    const colors = {
+        red: (s) => `\x1b[31m${s}\x1b[0m`,
+        yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+        cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+        bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    };
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    if (options?.autoComplete !== false && isInteractive) {
+        try {
+            const { initCommand } = await import("../commands/init.js");
+            const { findProjectRoot } = await import("./project-root.js");
+            const projectRoot = findProjectRoot() || process.cwd();
+            const flags = {};
+            if (options?.calledFrom) {
+                flags['called-from'] = options.calledFrom;
+            }
+            await initCommand({ args: [], flags, config, projectRoot });
+            return;
         }
-        console.error('\nRun "relq init" to create a configuration file.');
-        process.exit(1);
+        catch (e) {
+            process.exit(1);
+        }
+    }
+    console.error('');
+    console.error(colors.red('error:') + ' Configuration errors:');
+    for (const error of errors) {
+        console.error(`   ${colors.yellow('•')} ${error}`);
     }
+    console.error('');
+    console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} to create a configuration file or check your config settings.`);
+    console.error('');
+    process.exit(1);
 }