relq 1.0.0

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

@@ -0,0 +1,297 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { introspectDatabase } from "../utils/schema-introspect.js";
+import { createSpinner, colors } from "../utils/spinner.js";
+import { isInitialized, getStagedChanges, getUnstagedChanges, loadSnapshot, } from "../utils/repo-manager.js";
+import { generateCombinedSQL, sortChangesByDependency, getChangeDisplayName, } from "../utils/change-tracker.js";
+import { generateFullSchemaSQL } from "../utils/sql-generator.js";
+export async function exportCommand(context) {
+    const spinner = createSpinner();
+    const { args, flags } = context;
+    const projectRoot = process.cwd();
+    const changesOnly = Boolean(flags['changes']);
+    const stagedOnly = Boolean(flags['staged']);
+    const fromDb = Boolean(flags['db']);
+    if (changesOnly || stagedOnly) {
+        return exportChanges(projectRoot, flags, args, stagedOnly);
+    }
+    const outputPath = flags.output || args[0] || './schema-export.sql';
+    const absoluteOutputPath = path.resolve(outputPath);
+    const options = {
+        output: outputPath,
+        includeData: Boolean(flags['include-data']),
+        includeFunctions: Boolean(flags['include-functions']),
+        includeTriggers: Boolean(flags['include-triggers']),
+        fromDb,
+    };
+    if (fromDb) {
+        return exportFromDatabase(context, absoluteOutputPath, options);
+    }
+    return exportFromSnapshot(projectRoot, absoluteOutputPath, options);
+}
+async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
+    const spinner = createSpinner();
+    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, or use')} ${colors.cyan('relq import')} ${colors.muted('to import a schema.')}`);
+        return;
+    }
+    spinner.start('Loading snapshot');
+    const snapshot = loadSnapshot(projectRoot);
+    if (!snapshot) {
+        spinner.fail('No snapshot found');
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq import <file.sql>')} ${colors.muted('to import a schema first.')}`);
+        return;
+    }
+    spinner.succeed('Loaded snapshot');
+    const schema = normalizedToDbSchema(snapshot);
+    console.log('');
+    console.log(colors.cyan('Schema Summary:'));
+    console.log(`  ${colors.green('•')} Tables: ${schema.tables.length}`);
+    console.log(`  ${colors.green('•')} Enums: ${schema.enums.length}`);
+    console.log(`  ${colors.green('•')} Domains: ${schema.domains.length}`);
+    console.log(`  ${colors.green('•')} Composite Types: ${schema.compositeTypes.length}`);
+    console.log(`  ${colors.green('•')} Sequences: ${schema.sequences?.length || 0}`);
+    console.log(`  ${colors.green('•')} Extensions: ${schema.extensions.length}`);
+    if (snapshot.functions?.length) {
+        console.log(`  ${colors.green('•')} Functions: ${snapshot.functions.length}`);
+    }
+    if (snapshot.triggers?.length) {
+        console.log(`  ${colors.green('•')} Triggers: ${snapshot.triggers.length}`);
+    }
+    spinner.start('Generating SQL statements');
+    const sqlContent = generateFullSQL(schema, options);
+    spinner.succeed('Generated SQL statements');
+    const outputDir = path.dirname(absoluteOutputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
+    spinner.succeed(`Written ${options.output} (${(sqlContent.length / 1024).toFixed(1)} KB)`);
+    console.log('');
+    console.log(colors.green('✓ Export completed!'));
+    console.log(`  Source: ${colors.muted('snapshot (local)')}`);
+    console.log(`  Output: ${colors.muted(options.output || '')}`);
+}
+async function exportFromDatabase(context, absoluteOutputPath, options) {
+    const spinner = createSpinner();
+    if (!context.config || !context.config.connection) {
+        console.error(colors.red('Error: No database connection configured'));
+        return;
+    }
+    try {
+        spinner.start('Introspecting database schema');
+        const schema = await introspectDatabase(context.config.connection, undefined, {
+            includeFunctions: options.includeFunctions,
+            includeTriggers: options.includeTriggers,
+        });
+        spinner.succeed(`Introspected ${schema.tables.length} tables, ${schema.enums.length} enums`);
+        console.log('');
+        console.log(colors.cyan('Schema Summary:'));
+        console.log(`  ${colors.green('•')} Tables: ${schema.tables.length}`);
+        console.log(`  ${colors.green('•')} Enums: ${schema.enums.length}`);
+        console.log(`  ${colors.green('•')} Domains: ${schema.domains.length}`);
+        console.log(`  ${colors.green('•')} Composite Types: ${schema.compositeTypes.length}`);
+        console.log(`  ${colors.green('•')} Extensions: ${schema.extensions.length}`);
+        if (options.includeFunctions) {
+            console.log(`  ${colors.green('•')} Functions: ${schema.functions.length}`);
+        }
+        if (options.includeTriggers) {
+            console.log(`  ${colors.green('•')} Triggers: ${schema.triggers.length}`);
+        }
+        spinner.start('Generating SQL statements');
+        const sqlContent = generateFullSQL(schema, options);
+        spinner.succeed('Generated SQL statements');
+        const outputDir = path.dirname(absoluteOutputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
+        spinner.succeed(`Written ${options.output} (${(sqlContent.length / 1024).toFixed(1)} KB)`);
+        console.log('');
+        console.log(colors.green('✓ Export completed!'));
+        console.log(`  Source: ${colors.muted('database (live)')}`);
+        console.log(`  Output: ${colors.muted(options.output || '')}`);
+    }
+    catch (error) {
+        spinner.fail('Export failed');
+        throw error;
+    }
+}
+function normalizedToDbSchema(normalized) {
+    return {
+        tables: normalized.tables.map(t => ({
+            name: t.name,
+            schema: t.schema,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                dataType: c.type,
+                isNullable: c.nullable,
+                defaultValue: c.default,
+                isPrimaryKey: c.primaryKey,
+                isUnique: c.unique,
+                maxLength: null,
+                precision: null,
+                scale: null,
+                references: c.references ? {
+                    table: c.references.table,
+                    column: c.references.column,
+                    onDelete: c.references.onDelete,
+                    onUpdate: c.references.onUpdate,
+                } : null,
+                check: c.check ?? undefined,
+                comment: c.comment ?? undefined,
+                isGenerated: c.isGenerated || false,
+                generationExpression: c.generationExpression ?? null,
+                identityGeneration: c.identity?.type ?? null,
+            })),
+            indexes: t.indexes.map(i => ({
+                name: i.name,
+                columns: i.columns,
+                isUnique: i.unique,
+                isPrimary: i.isPrimary || false,
+                type: i.type || 'btree',
+                definition: i.definition,
+                whereClause: i.whereClause ?? null,
+                expression: i.columnDefs?.find(cd => cd.expression)?.expression ?? null,
+            })),
+            constraints: t.constraints.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: c.columns || [],
+                definition: c.definition || '',
+                referencedTable: c.referencedTable,
+                referencedColumns: c.referencedColumns,
+                checkExpression: c.checkExpression,
+            })),
+            rowCount: 0,
+            isPartitioned: t.isPartitioned || t.partitionType !== undefined,
+            partitionType: t.partitionType,
+            partitionKey: t.partitionKey,
+        })),
+        enums: normalized.enums.map(e => ({
+            name: e.name,
+            values: e.values,
+        })),
+        domains: normalized.domains.map(d => ({
+            name: d.name,
+            baseType: d.baseType,
+            isNotNull: d.notNull,
+            defaultValue: d.default,
+            checkExpression: d.check,
+        })),
+        compositeTypes: normalized.compositeTypes.map(c => ({
+            name: c.name,
+            attributes: c.attributes,
+        })),
+        sequences: normalized.sequences.map(s => ({
+            name: s.name,
+            dataType: s.dataType,
+            start: s.startValue,
+            increment: s.increment,
+            minValue: s.minValue,
+            maxValue: s.maxValue,
+            cache: s.cache,
+            cycle: s.cycle,
+            ownedBy: s.ownedBy || undefined,
+        })),
+        extensions: normalized.extensions.map(e => e.name),
+        functions: (normalized.functions || []).map(f => ({
+            name: f.name,
+            schema: f.schema || 'public',
+            returnType: f.returnType,
+            argTypes: f.argTypes || [],
+            language: f.language,
+            definition: f.body || '',
+            isAggregate: false,
+            volatility: f.volatility || 'VOLATILE',
+        })),
+        triggers: (normalized.triggers || []).map(t => ({
+            name: t.name,
+            tableName: t.table,
+            event: t.events.join(' OR '),
+            timing: t.timing,
+            functionName: t.functionName,
+            definition: '',
+            isEnabled: t.isEnabled !== false,
+        })),
+        partitions: [],
+        policies: [],
+        foreignServers: [],
+        foreignTables: [],
+    };
+}
+async function exportChanges(projectRoot, flags, args, stagedOnly) {
+    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;
+    }
+    let changes;
+    let modeLabel;
+    if (stagedOnly) {
+        changes = getStagedChanges(projectRoot);
+        modeLabel = 'staged';
+    }
+    else {
+        const staged = getStagedChanges(projectRoot);
+        const unstaged = getUnstagedChanges(projectRoot);
+        changes = [...staged, ...unstaged];
+        modeLabel = 'uncommitted';
+    }
+    if (changes.length === 0) {
+        console.log(`${colors.yellow('⚠')} No ${modeLabel} changes to export`);
+        console.log('');
+        if (stagedOnly) {
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq add .')} ${colors.muted('to stage changes.')}`);
+        }
+        else {
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('or')} ${colors.cyan('relq import')} ${colors.muted('to detect changes.')}`);
+        }
+        return;
+    }
+    const outputPath = flags.output || args[0] || `./${modeLabel}-changes.sql`;
+    const absoluteOutputPath = path.resolve(outputPath);
+    console.log(`${colors.cyan(`Exporting ${modeLabel} changes:`)} ${changes.length}`);
+    console.log('');
+    for (const change of changes) {
+        const display = getChangeDisplayName(change);
+        const color = change.type === 'CREATE' ? colors.green :
+            change.type === 'DROP' ? colors.red :
+                colors.yellow;
+        console.log(`   ${color(display)}`);
+    }
+    console.log('');
+    const sortedChanges = sortChangesByDependency(changes);
+    const sqlContent = generateCombinedSQL(sortedChanges);
+    const outputDir = path.dirname(absoluteOutputPath);
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
+    console.log(`${colors.green('✓')} Exported ${changes.length} ${modeLabel} change(s) to ${outputPath}`);
+    console.log(`${colors.muted(`${(sqlContent.length / 1024).toFixed(1)} KB`)}`);
+    console.log('');
+}
+function generateFullSQL(schema, options) {
+    const header = `-- PostgreSQL Database Schema Export\n-- Generated: ${new Date().toISOString()}\n-- Relq CLI`;
+    return generateFullSchemaSQL(schema, {
+        includeExtensions: true,
+        includeEnums: true,
+        includeDomains: true,
+        includeCompositeTypes: true,
+        includeSequences: true,
+        includeTables: true,
+        includePartitions: true,
+        includeIndexes: true,
+        includeConstraints: true,
+        includeFunctions: options.includeFunctions,
+        includeTriggers: options.includeTriggers,
+        headerComment: header,
+    });
+}
+export default exportCommand;

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

@@ -0,0 +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, getHead, loadCommit, saveCommit, setFetchHead, shortHash, fetchRemoteCommits, ensureRemoteTable, } from "../utils/repo-manager.js";
+export async function fetchCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    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;
+    }
+    const spinner = createSpinner();
+    spinner.start(`Fetching from ${getConnectionDescription(connection)}...`);
+    try {
+        await ensureRemoteTable(connection);
+        const remoteCommits = await fetchRemoteCommits(connection, 100);
+        if (remoteCommits.length === 0) {
+            spinner.succeed('No remote commits found');
+            console.log('');
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq push')} ${colors.muted('to push your commits.')}`);
+            return;
+        }
+        let newCommits = 0;
+        for (const commit of remoteCommits) {
+            const existing = loadCommit(commit.hash, projectRoot);
+            if (!existing) {
+                saveCommit(commit, projectRoot);
+                newCommits++;
+            }
+        }
+        const latestRemote = remoteCommits[0];
+        setFetchHead(latestRemote.hash, projectRoot);
+        spinner.succeed(`Fetched ${remoteCommits.length} commits (${newCommits} new)`);
+        const localHead = getHead(projectRoot);
+        if (localHead && latestRemote.hash !== localHead) {
+            console.log('');
+            console.log(`${colors.muted('From')} ${getConnectionDescription(connection)}`);
+            console.log(`   ${shortHash(localHead)}..${shortHash(latestRemote.hash)}  ${colors.muted('main -> origin/main')}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Fetch failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+    console.log('');
+}

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

@@ -0,0 +1,206 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { requireValidConfig } from "../utils/config-loader.js";
+import { introspectDatabase } from "../utils/schema-introspect.js";
+import { loadSnapshot, snapshotToDatabaseSchema, saveSnapshot } from "../utils/snapshot-manager.js";
+import { diffSchemas, filterDiff, hasDestructiveChanges, getDestructiveTables } from "../utils/schema-diff.js";
+import { normalizeSchema } from "../utils/schema-hash.js";
+import { generateMigrationFile, getNextMigrationNumber, generateTimestampedName } from "../utils/migration-generator.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',
+};
+function askConfirm(question, defaultYes = false) {
+    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');
+        });
+    });
+}
+function askInput(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+export async function generateCommand(context) {
+    const { config, args, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
+    const ignorePatterns = config.sync?.ignore || ['_relq_*'];
+    const format = config.migrations?.format || 'sequential';
+    const message = flags['m'] || flags['message'];
+    const autoStage = flags['a'] === true || flags['am'] !== undefined;
+    const isEmpty = flags['empty'] === true;
+    const interactive = flags['interactive'] === true;
+    const noDown = flags['no-down'] === true;
+    const dryRun = flags['dry-run'] === true;
+    let migrationName = args[0] || '';
+    if (flags['am']) {
+        const amMessage = flags['am'];
+        if (typeof amMessage === 'string') {
+            migrationName = amMessage.replace(/\s+/g, '_').toLowerCase();
+        }
+    }
+    if (!migrationName && message) {
+        migrationName = message.replace(/\s+/g, '_').toLowerCase();
+    }
+    if (!migrationName && !isEmpty) {
+        migrationName = await askInput(`${colors.cyan}Migration name:${colors.reset} `);
+        if (!migrationName) {
+            console.error('Error: Migration name is required.');
+            process.exit(1);
+        }
+    }
+    if (isEmpty) {
+        migrationName = migrationName || 'empty';
+        await createEmptyMigration(migrationsDir, migrationName, format, dryRun);
+        return;
+    }
+    console.log(`${colors.bold}Generating migration...${colors.reset}`);
+    console.log(`   Connection: ${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}" first to create initial snapshot.`);
+            return;
+        }
+        const localSchema = snapshotToDatabaseSchema(snapshot);
+        const diff = diffSchemas(normalizeSchema(localSchema), normalizeSchema(dbSchema));
+        const filteredDiff = filterDiff(diff, ignorePatterns);
+        if (!filteredDiff.hasChanges) {
+            console.log(`${colors.green}No changes to generate.${colors.reset}`);
+            return;
+        }
+        const s = filteredDiff.summary;
+        console.log(`${colors.bold}Changes to include:${colors.reset}`);
+        if (s.tablesAdded > 0)
+            console.log(`  ${colors.green}+ ${s.tablesAdded} table(s)${colors.reset}`);
+        if (s.tablesRemoved > 0)
+            console.log(`  ${colors.red}- ${s.tablesRemoved} table(s)${colors.reset}`);
+        if (s.tablesModified > 0)
+            console.log(`  ${colors.yellow}~ ${s.tablesModified} table(s) modified${colors.reset}`);
+        if (s.columnsAdded > 0)
+            console.log(`  ${colors.green}+ ${s.columnsAdded} column(s)${colors.reset}`);
+        if (s.columnsRemoved > 0)
+            console.log(`  ${colors.red}- ${s.columnsRemoved} column(s)${colors.reset}`);
+        if (s.columnsModified > 0)
+            console.log(`  ${colors.yellow}~ ${s.columnsModified} column(s)${colors.reset}`);
+        console.log('');
+        if (hasDestructiveChanges(filteredDiff)) {
+            const tables = getDestructiveTables(filteredDiff);
+            console.log(`${colors.red}${colors.bold}⚠️  Destructive changes:${colors.reset}`);
+            for (const t of tables) {
+                console.log(`   ${colors.red}• ${t}${colors.reset}`);
+            }
+            console.log('');
+            if (!autoStage) {
+                const proceed = await askConfirm('Include destructive changes?', false);
+                if (!proceed) {
+                    console.log('Cancelled.');
+                    return;
+                }
+            }
+        }
+        const migrationFile = generateMigrationFile(filteredDiff, migrationName, {
+            includeDown: !noDown,
+            includeComments: true,
+            message: message,
+        });
+        let fileName;
+        if (format === 'timestamp') {
+            fileName = generateTimestampedName(migrationName) + '.sql';
+        }
+        else {
+            const num = getNextMigrationNumber(migrationsDir);
+            fileName = `${num}_${migrationName.replace(/\s+/g, '_').toLowerCase()}.sql`;
+        }
+        const filePath = path.join(migrationsDir, fileName);
+        if (dryRun) {
+            console.log(`${colors.cyan}[dry-run] Would create: ${filePath}${colors.reset}`);
+            console.log('');
+            console.log('--- Generated SQL ---');
+            console.log(migrationFile.content);
+            console.log('--- End ---');
+        }
+        else {
+            if (!fs.existsSync(migrationsDir)) {
+                fs.mkdirSync(migrationsDir, { recursive: true });
+            }
+            fs.writeFileSync(filePath, migrationFile.content, 'utf-8');
+            console.log(`${colors.green}✓ Created:${colors.reset} ${filePath}`);
+            saveSnapshot(dbSchema, snapshotPath, connection.database);
+            console.log(`${colors.dim}Updated snapshot.${colors.reset}`);
+        }
+        console.log('');
+        console.log(`${colors.dim}Run "relq push" to apply this migration.${colors.reset}`);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+async function createEmptyMigration(migrationsDir, name, format, dryRun) {
+    let fileName;
+    if (format === 'timestamp') {
+        fileName = generateTimestampedName(name) + '.sql';
+    }
+    else {
+        const num = getNextMigrationNumber(migrationsDir);
+        fileName = `${num}_${name.replace(/\s+/g, '_').toLowerCase()}.sql`;
+    }
+    const filePath = path.join(migrationsDir, fileName);
+    const content = `-- Migration: ${name}
+-- Generated: ${new Date().toISOString()}
+
+-- UP
+-- Add your schema changes here
+
+
+-- DOWN
+-- Add rollback statements here
+
+`;
+    if (dryRun) {
+        console.log(`${colors.cyan}[dry-run] Would create: ${filePath}${colors.reset}`);
+    }
+    else {
+        if (!fs.existsSync(migrationsDir)) {
+            fs.mkdirSync(migrationsDir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, content, 'utf-8');
+        console.log(`${colors.green}✓ Created empty migration:${colors.reset} ${filePath}`);
+    }
+}

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

@@ -0,0 +1,129 @@
+import * as fs from 'fs';
+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',
+};
+export async function historyCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const tableName = config.migrations?.tableName || '_relq_migrations';
+    const limit = parseInt(flags['n']) || 20;
+    console.log(`${colors.bold}Migration History${colors.reset}`);
+    console.log(`Database: ${getConnectionDescription(connection)}`);
+    console.log('');
+    try {
+        const migrationFiles = getMigrationFiles(migrationsDir);
+        const appliedMigrations = await getAppliedMigrations(connection, tableName);
+        const history = [];
+        for (const file of migrationFiles) {
+            const applied = appliedMigrations.find(m => m.name === file);
+            history.push({
+                name: file,
+                appliedAt: applied?.appliedAt || null,
+                pending: !applied,
+            });
+        }
+        history.sort((a, b) => b.name.localeCompare(a.name));
+        const toShow = history.slice(0, limit);
+        const pendingCount = history.filter(h => h.pending).length;
+        const appliedCount = history.filter(h => !h.pending).length;
+        console.log(`${colors.dim}Showing ${toShow.length} of ${history.length} migrations${colors.reset}`);
+        console.log(`${colors.green}${appliedCount} applied${colors.reset}, ${colors.yellow}${pendingCount} pending${colors.reset}`);
+        console.log('');
+        for (const record of toShow) {
+            if (record.pending) {
+                console.log(`${colors.yellow}○ ${record.name}${colors.reset} ${colors.dim}(pending)${colors.reset}`);
+            }
+            else {
+                const date = record.appliedAt ? formatDate(record.appliedAt) : '';
+                console.log(`${colors.green}● ${record.name}${colors.reset} ${colors.dim}${date}${colors.reset}`);
+            }
+        }
+        if (history.length > limit) {
+            console.log('');
+            console.log(`${colors.dim}Use "relq history -n ${history.length}" to see all.${colors.reset}`);
+        }
+    }
+    catch (error) {
+        if (error?.code === '42P01') {
+            console.log(`${colors.yellow}No migration table found.${colors.reset}`);
+            console.log(`Run "${colors.cyan}relq push${colors.reset}" to initialize.`);
+            console.log('');
+            const files = getMigrationFiles(migrationsDir);
+            if (files.length > 0) {
+                console.log(`${colors.bold}Pending migrations:${colors.reset}`);
+                for (const file of files.slice(0, limit)) {
+                    console.log(`  ${colors.yellow}○ ${file}${colors.reset}`);
+                }
+            }
+            else {
+                console.log(`${colors.dim}No migration files found.${colors.reset}`);
+            }
+            return;
+        }
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function getMigrationFiles(migrationsDir) {
+    if (!fs.existsSync(migrationsDir)) {
+        return [];
+    }
+    return fs.readdirSync(migrationsDir)
+        .filter(f => f.endsWith('.sql'))
+        .sort();
+}
+async function getAppliedMigrations(connection, tableName) {
+    const { Pool } = await import("../../addon/pg.js");
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+    });
+    try {
+        const result = await pool.query(`
+            SELECT name, applied_at 
+            FROM "${tableName}" 
+            ORDER BY id DESC;
+        `);
+        return result.rows.map(r => ({
+            name: r.name,
+            appliedAt: new Date(r.applied_at),
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+function formatDate(date) {
+    const now = new Date();
+    const diff = now.getTime() - date.getTime();
+    const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+    if (days === 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days} days ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)} weeks ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)} months ago`;
+    return date.toLocaleDateString();
+}