relq 1.0.0

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

@@ -0,0 +1,347 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { isInitialized, getStagedChanges, getUnstagedChanges, getHead, loadCommit, } from "./repo-manager.js";
+const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+export const colors = {
+    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,
+};
+export function error(message) {
+    console.error(`${colors.red('error:')} ${message}`);
+}
+export function fatal(message) {
+    console.error(`${colors.red('fatal:')} ${message}`);
+    process.exit(128);
+}
+export function warning(message) {
+    console.error(`${colors.yellow('warning:')} ${message}`);
+}
+export function hint(message) {
+    console.log(`${colors.yellow('hint:')} ${message}`);
+}
+export function success(message) {
+    console.log(`${colors.green('✓')} ${message}`);
+}
+export function info(message) {
+    console.log(message);
+}
+export function getWorkingTreeStatus(projectRoot = process.cwd()) {
+    const initialized = isInitialized(projectRoot);
+    const head = initialized ? getHead(projectRoot) : null;
+    const headCommit = head ? loadCommit(head, projectRoot) : null;
+    const staged = initialized ? getStagedChanges(projectRoot) : [];
+    const unstaged = initialized ? getUnstagedChanges(projectRoot) : [];
+    return {
+        isInitialized: initialized,
+        hasHead: !!head,
+        headHash: head,
+        headMessage: headCommit?.message || null,
+        stagedChanges: staged,
+        unstagedChanges: unstaged,
+        isClean: staged.length === 0 && unstaged.length === 0,
+        hasUncommittedChanges: staged.length > 0,
+        hasUnstagedChanges: unstaged.length > 0,
+    };
+}
+export function requireRepository(projectRoot = process.cwd()) {
+    if (!isInitialized(projectRoot)) {
+        fatal('not a relq repository (or any of the parent directories): .relq');
+    }
+}
+export function requireCleanWorkingTree(projectRoot = process.cwd(), operation = 'operation') {
+    const status = getWorkingTreeStatus(projectRoot);
+    if (status.isClean) {
+        return { clean: true };
+    }
+    const lines = [];
+    if (status.hasUnstagedChanges && status.hasUncommittedChanges) {
+        lines.push(`Your local changes would be overwritten by ${operation}.`);
+        lines.push(`Please commit your changes or stash them before you ${operation}.`);
+    }
+    else if (status.hasUncommittedChanges) {
+        lines.push(`You have uncommitted changes.`);
+        lines.push(`Please commit your changes before you ${operation}.`);
+    }
+    else {
+        lines.push(`You have unstaged changes.`);
+        lines.push(`Please stage and commit your changes before you ${operation}.`);
+    }
+    return { clean: false, message: lines.join('\n') };
+}
+export function printDirtyWorkingTreeError(status, operation) {
+    console.log('');
+    if (status.hasUnstagedChanges && status.hasUncommittedChanges) {
+        error(`Your local changes would be overwritten by ${operation}.`);
+        hint(`Commit your changes or stash them before you ${operation}.`);
+    }
+    else if (status.hasUncommittedChanges) {
+        error(`You have uncommitted changes.`);
+        hint(`Please commit your changes before you ${operation}.`);
+    }
+    else {
+        error(`You have unstaged changes.`);
+        hint(`Please stage and commit your changes before you ${operation}.`);
+    }
+    console.log('');
+    if (status.hasUncommittedChanges) {
+        console.log(`Changes to be committed:`);
+        console.log(`  ${colors.gray('(use "relq restore --staged <file>..." to unstage)')}`);
+        console.log('');
+        for (const change of status.stagedChanges.slice(0, 10)) {
+            const prefix = change.type === 'CREATE' ? 'new' : change.type === 'DROP' ? 'deleted' : 'modified';
+            const color = change.type === 'CREATE' ? colors.green : change.type === 'DROP' ? colors.red : colors.yellow;
+            console.log(`\t${color(`${prefix}:`.padEnd(12))}${change.objectName}`);
+        }
+        if (status.stagedChanges.length > 10) {
+            console.log(`\t${colors.gray(`... and ${status.stagedChanges.length - 10} more`)}`);
+        }
+        console.log('');
+    }
+    if (status.hasUnstagedChanges) {
+        console.log(`Changes not staged for commit:`);
+        console.log(`  ${colors.gray('(use "relq add <file>..." to update what will be committed)')}`);
+        console.log(`  ${colors.gray('(use "relq restore <file>..." to discard changes in working directory)')}`);
+        console.log('');
+        for (const change of status.unstagedChanges.slice(0, 10)) {
+            const prefix = change.type === 'CREATE' ? 'new' : change.type === 'DROP' ? 'deleted' : 'modified';
+            const color = change.type === 'CREATE' ? colors.green : change.type === 'DROP' ? colors.red : colors.yellow;
+            console.log(`\t${color(`${prefix}:`.padEnd(12))}${change.objectName}`);
+        }
+        if (status.unstagedChanges.length > 10) {
+            console.log(`\t${colors.gray(`... and ${status.unstagedChanges.length - 10} more`)}`);
+        }
+        console.log('');
+    }
+    console.log('Aborting.');
+}
+export function detectConflicts(localChanges, incomingChanges) {
+    const conflicts = [];
+    const localByKey = new Map();
+    for (const change of localChanges) {
+        const key = `${change.objectType}:${change.parentName || ''}:${change.objectName}`;
+        localByKey.set(key, change);
+    }
+    const incomingByKey = new Map();
+    for (const change of incomingChanges) {
+        const key = `${change.objectType}:${change.parentName || ''}:${change.objectName}`;
+        incomingByKey.set(key, change);
+    }
+    for (const [key, localChange] of localByKey) {
+        const incomingChange = incomingByKey.get(key);
+        if (incomingChange) {
+            conflicts.push({
+                objectType: localChange.objectType,
+                objectName: localChange.objectName,
+                localChange,
+                incomingChange,
+            });
+        }
+    }
+    return {
+        hasConflicts: conflicts.length > 0,
+        conflicts,
+    };
+}
+export function printConflictError(conflictInfo, operation) {
+    console.log('');
+    error(`Automatic ${operation} failed; fix conflicts and then commit the result.`);
+    console.log('');
+    console.log(`CONFLICT (content): Merge conflict in schema`);
+    console.log('');
+    for (const conflict of conflictInfo.conflicts.slice(0, 10)) {
+        console.log(`  ${colors.red('both modified:')}   ${conflict.objectType.toLowerCase()} ${conflict.objectName}`);
+    }
+    if (conflictInfo.conflicts.length > 10) {
+        console.log(`  ${colors.gray(`... and ${conflictInfo.conflicts.length - 10} more conflicts`)}`);
+    }
+    console.log('');
+    hint(`Fix conflicts manually and use:`);
+    hint(`  relq add .          - to mark resolution`);
+    hint(`  relq commit         - to complete the ${operation}`);
+    console.log('');
+    hint(`Or abort the ${operation} with:`);
+    hint(`  relq ${operation} --abort`);
+    console.log('');
+}
+export function checkUncommittedChanges(projectRoot = process.cwd()) {
+    const status = getWorkingTreeStatus(projectRoot);
+    if (status.isClean) {
+        return { status: 'clean' };
+    }
+    if (status.hasUnstagedChanges) {
+        return { status: 'needs_staging', changes: status.unstagedChanges };
+    }
+    if (status.hasUncommittedChanges) {
+        return { status: 'needs_commit', changes: status.stagedChanges };
+    }
+    return { status: 'clean' };
+}
+export function printMergeStrategyHelp() {
+    console.log('');
+    console.log('Resolution options:');
+    console.log(`  ${colors.cyan('--theirs')}   Accept all incoming changes (overwrite local)`);
+    console.log(`  ${colors.cyan('--ours')}     Keep all local changes (reject incoming)`);
+    console.log(`  ${colors.cyan('--force')}    Force operation, overwrite local changes`);
+    console.log(`  ${colors.cyan('--abort')}    Abort and restore previous state`);
+    console.log('');
+}
+export function validatePostgresSQL(content) {
+    const errors = [];
+    const warnings = [];
+    if (!content.trim()) {
+        errors.push('SQL file is empty');
+        return { valid: false, errors, warnings };
+    }
+    const hasValidStatements = /\b(CREATE|ALTER|DROP|INSERT|UPDATE|DELETE|SELECT|GRANT|REVOKE|COMMENT)\b/i.test(content);
+    if (!hasValidStatements) {
+        errors.push('No valid SQL statements found');
+    }
+    let contentForQuoteCheck = content;
+    contentForQuoteCheck = contentForQuoteCheck.replace(/--[^\n]*/g, '');
+    contentForQuoteCheck = contentForQuoteCheck.replace(/\/\*[\s\S]*?\*\//g, '');
+    contentForQuoteCheck = contentForQuoteCheck.replace(/\$([a-zA-Z_]*)\$[\s\S]*?\$\1\$/g, '');
+    const openParens = (contentForQuoteCheck.match(/\(/g) || []).length;
+    const closeParens = (contentForQuoteCheck.match(/\)/g) || []).length;
+    if (Math.abs(openParens - closeParens) > 5) {
+        errors.push(`Significantly unbalanced parentheses: ${openParens} opening, ${closeParens} closing`);
+    }
+    const hasPostgresPatterns = (/\bSERIAL\b/i.test(content) ||
+        /\bTEXT\b/i.test(content) ||
+        /\bJSONB?\b/i.test(content) ||
+        /\bUUID\b/i.test(content) ||
+        /\bTIMESTAMPTZ\b/i.test(content) ||
+        /\bBOOLEAN\b/i.test(content) ||
+        /\bCREATE\s+TABLE\b/i.test(content) ||
+        /\bCREATE\s+TYPE\b/i.test(content) ||
+        /\bCREATE\s+EXTENSION\b/i.test(content));
+    if (!hasPostgresPatterns) {
+        warnings.push('No PostgreSQL-specific syntax detected. Ensure this is a PostgreSQL schema.');
+    }
+    if (/\bDROP\s+DATABASE\b/i.test(content)) {
+        warnings.push('Found DROP DATABASE statement - this may be dangerous');
+    }
+    if (/\bTRUNCATE\b/i.test(content)) {
+        warnings.push('Found TRUNCATE statement - this will delete data');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+export function readSQLFile(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        return { error: `pathspec '${filePath}' did not match any files` };
+    }
+    const stat = fs.statSync(absolutePath);
+    if (stat.isDirectory()) {
+        return { error: `'${filePath}' is a directory, not a file` };
+    }
+    const content = fs.readFileSync(absolutePath, 'utf-8');
+    const validation = validatePostgresSQL(content);
+    return { content, validation };
+}
+export function createSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    let interval = null;
+    let currentMessage = '';
+    return {
+        start(message) {
+            currentMessage = message;
+            if (process.stdout.isTTY) {
+                interval = setInterval(() => {
+                    process.stdout.write(`\r${frames[frameIndex]} ${currentMessage}`);
+                    frameIndex = (frameIndex + 1) % frames.length;
+                }, 80);
+            }
+            else {
+                console.log(`  ${message}...`);
+            }
+        },
+        stop() {
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+                if (process.stdout.isTTY) {
+                    process.stdout.write('\r' + ' '.repeat(currentMessage.length + 4) + '\r');
+                }
+            }
+        },
+        succeed(message) {
+            this.stop();
+            console.log(`${colors.green('✓')} ${message}`);
+        },
+        fail(message) {
+            this.stop();
+            console.log(`${colors.red('✗')} ${message}`);
+        },
+        info(message) {
+            this.stop();
+            console.log(`${colors.blue('ℹ')} ${message}`);
+        },
+    };
+}
+import * as readline from 'readline';
+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} ${colors.gray(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(`${colors.gray('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`;
+}

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

@@ -0,0 +1,263 @@
+export function generateMigration(diff, options = {}) {
+    const { includeDown = true } = options;
+    const up = [];
+    const down = [];
+    for (const table of diff.tables.filter(t => t.action === 'remove')) {
+        up.push(...generateDropTable(table));
+        if (includeDown && table.before) {
+            down.unshift(...generateCreateTable(table.before));
+        }
+    }
+    for (const table of diff.tables.filter(t => t.action === 'add')) {
+        if (table.after) {
+            up.push(...generateCreateTable(table.after));
+            if (includeDown) {
+                down.unshift(`DROP TABLE IF EXISTS "${table.name}" CASCADE;`);
+            }
+        }
+    }
+    for (const table of diff.tables.filter(t => t.action === 'modify')) {
+        const { upSQL, downSQL } = generateAlterTable(table, includeDown);
+        up.push(...upSQL);
+        down.unshift(...downSQL);
+    }
+    return { up, down };
+}
+export function generateMigrationFile(diff, name, options = {}) {
+    const { message, includeComments = true } = options;
+    const { up, down } = generateMigration(diff, options);
+    const lines = [];
+    lines.push(`-- Migration: ${name}`);
+    if (message) {
+        lines.push(`-- ${message}`);
+    }
+    lines.push(`-- Generated: ${new Date().toISOString()}`);
+    lines.push('');
+    lines.push('-- UP');
+    if (up.length === 0) {
+        lines.push('-- No changes');
+    }
+    else {
+        if (includeComments) {
+            lines.push(`-- ${diff.summary.tablesAdded} tables added, ${diff.summary.tablesRemoved} removed, ${diff.summary.tablesModified} modified`);
+        }
+        lines.push('');
+        lines.push(...up);
+    }
+    lines.push('');
+    lines.push('-- DOWN');
+    if (down.length === 0) {
+        lines.push('-- No rollback');
+    }
+    else {
+        lines.push('');
+        lines.push(...down);
+    }
+    return {
+        name,
+        content: lines.join('\n'),
+        upSQL: up,
+        downSQL: down,
+    };
+}
+function generateCreateTable(table) {
+    const sql = [];
+    const columnDefs = [];
+    const constraintDefs = [];
+    for (const col of table.columns) {
+        columnDefs.push(`    ${generateColumnDefinition(col)}`);
+    }
+    const hasPKColumn = table.columns.some(c => c.isPrimaryKey);
+    for (const con of table.constraints || []) {
+        if (con.type === 'PRIMARY KEY' && hasPKColumn)
+            continue;
+        constraintDefs.push(`    CONSTRAINT "${con.name}" ${con.definition}`);
+    }
+    const allDefs = [...columnDefs, ...constraintDefs];
+    let createSQL = `CREATE TABLE "${table.name}" (\n${allDefs.join(',\n')}\n)`;
+    if (table.isPartitioned && table.partitionType && table.partitionKey?.length) {
+        createSQL += ` PARTITION BY ${table.partitionType} (${table.partitionKey.join(', ')})`;
+    }
+    sql.push(createSQL + ';');
+    for (const idx of table.indexes || []) {
+        if (idx.isPrimary)
+            continue;
+        sql.push(generateCreateIndex(table.name, idx));
+    }
+    return sql;
+}
+function generateDropTable(table) {
+    return [`DROP TABLE IF EXISTS "${table.name}" CASCADE;`];
+}
+function generateAlterTable(table, includeDown) {
+    const upSQL = [];
+    const downSQL = [];
+    const tableName = table.name;
+    for (const col of table.columns || []) {
+        const { up, down } = generateColumnChange(tableName, col);
+        upSQL.push(...up);
+        if (includeDown)
+            downSQL.unshift(...down);
+    }
+    for (const idx of table.indexes || []) {
+        const { up, down } = generateIndexChange(tableName, idx);
+        upSQL.push(...up);
+        if (includeDown)
+            downSQL.unshift(...down);
+    }
+    for (const con of table.constraints || []) {
+        const { up, down } = generateConstraintChange(tableName, con);
+        upSQL.push(...up);
+        if (includeDown)
+            downSQL.unshift(...down);
+    }
+    return { upSQL, downSQL };
+}
+function generateColumnDefinition(col) {
+    const parts = [`"${col.name}"`, mapDataType(col)];
+    if (col.isPrimaryKey) {
+        parts.push('PRIMARY KEY');
+    }
+    if (!col.isNullable && !col.isPrimaryKey) {
+        parts.push('NOT NULL');
+    }
+    if (col.isUnique && !col.isPrimaryKey) {
+        parts.push('UNIQUE');
+    }
+    if (col.defaultValue) {
+        parts.push(`DEFAULT ${col.defaultValue}`);
+    }
+    if (col.references) {
+        parts.push(`REFERENCES "${col.references.table}"("${col.references.column}")`);
+    }
+    return parts.join(' ');
+}
+function generateColumnChange(tableName, col) {
+    const up = [];
+    const down = [];
+    if (col.action === 'add' && col.after) {
+        up.push(`ALTER TABLE "${tableName}" ADD COLUMN ${generateColumnDefinition(col.after)};`);
+        down.push(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${col.name}";`);
+    }
+    if (col.action === 'remove' && col.before) {
+        up.push(`ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${col.name}";`);
+        down.push(`ALTER TABLE "${tableName}" ADD COLUMN ${generateColumnDefinition(col.before)};`);
+    }
+    if (col.action === 'modify' && col.changesV2 && col.before && col.after) {
+        if (col.changesV2.type) {
+            const newType = mapDataType(col.after);
+            up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" TYPE ${newType} USING "${col.name}"::${newType};`);
+            down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" TYPE ${mapDataType(col.before)} USING "${col.name}"::${mapDataType(col.before)};`);
+        }
+        if (col.changesV2.nullable) {
+            if (col.changesV2.nullable.to) {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP NOT NULL;`);
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET NOT NULL;`);
+            }
+            else {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET NOT NULL;`);
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP NOT NULL;`);
+            }
+        }
+        if (col.changesV2.default) {
+            if (col.changesV2.default.to) {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET DEFAULT ${col.changesV2.default.to};`);
+            }
+            else {
+                up.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP DEFAULT;`);
+            }
+            if (col.changesV2.default.from) {
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" SET DEFAULT ${col.changesV2.default.from};`);
+            }
+            else {
+                down.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${col.name}" DROP DEFAULT;`);
+            }
+        }
+    }
+    return { up, down };
+}
+function generateCreateIndex(tableName, idx) {
+    const unique = idx.isUnique ? 'UNIQUE ' : '';
+    const cols = Array.isArray(idx.columns) ? idx.columns : [idx.columns];
+    const colList = cols.map(c => `"${c}"`).join(', ');
+    const using = idx.type && idx.type !== 'btree' ? ` USING ${idx.type}` : '';
+    return `CREATE ${unique}INDEX IF NOT EXISTS "${idx.name}" ON "${tableName}"${using} (${colList});`;
+}
+function generateIndexChange(tableName, idx) {
+    const up = [];
+    const down = [];
+    if (idx.action === 'add' && idx.after) {
+        up.push(generateCreateIndex(tableName, idx.after));
+        down.push(`DROP INDEX IF EXISTS "${idx.name}";`);
+    }
+    if (idx.action === 'remove' && idx.before) {
+        up.push(`DROP INDEX IF EXISTS "${idx.name}";`);
+        down.push(generateCreateIndex(tableName, idx.before));
+    }
+    return { up, down };
+}
+function generateConstraintChange(tableName, con) {
+    const up = [];
+    const down = [];
+    if (con.action === 'add' && con.after) {
+        up.push(`ALTER TABLE "${tableName}" ADD CONSTRAINT "${con.name}" ${con.after.definition};`);
+        down.push(`ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${con.name}";`);
+    }
+    if (con.action === 'remove' && con.before) {
+        up.push(`ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${con.name}";`);
+        down.push(`ALTER TABLE "${tableName}" ADD CONSTRAINT "${con.name}" ${con.before.definition};`);
+    }
+    return { up, down };
+}
+function mapDataType(col) {
+    let type = col.dataType.toUpperCase();
+    if ((type === 'VARCHAR' || type === 'CHARACTER VARYING') && col.maxLength) {
+        return `VARCHAR(${col.maxLength})`;
+    }
+    if ((type === 'CHAR' || type === 'CHARACTER' || type === 'BPCHAR') && col.maxLength) {
+        return `CHAR(${col.maxLength})`;
+    }
+    if ((type === 'NUMERIC' || type === 'DECIMAL') && col.precision) {
+        if (col.scale) {
+            return `NUMERIC(${col.precision}, ${col.scale})`;
+        }
+        return `NUMERIC(${col.precision})`;
+    }
+    const typeMap = {
+        'INT4': 'INTEGER',
+        'INT8': 'BIGINT',
+        'INT2': 'SMALLINT',
+        'FLOAT4': 'REAL',
+        'FLOAT8': 'DOUBLE PRECISION',
+        'BOOL': 'BOOLEAN',
+        'TIMESTAMPTZ': 'TIMESTAMP WITH TIME ZONE',
+        'TIMETZ': 'TIME WITH TIME ZONE',
+    };
+    return typeMap[type] || type;
+}
+export function getNextMigrationNumber(migrationsDir) {
+    const fs = require('fs');
+    if (!fs.existsSync(migrationsDir)) {
+        return '001';
+    }
+    const files = fs.readdirSync(migrationsDir)
+        .filter((f) => f.endsWith('.sql'))
+        .sort();
+    if (files.length === 0) {
+        return '001';
+    }
+    const lastFile = files[files.length - 1];
+    const match = lastFile.match(/^(\d+)/);
+    if (match) {
+        const num = parseInt(match[1]) + 1;
+        return num.toString().padStart(3, '0');
+    }
+    return '001';
+}
+export function generateTimestampedName(name) {
+    const now = new Date();
+    const timestamp = now.toISOString()
+        .replace(/[-:T]/g, '')
+        .slice(0, 14);
+    return `${timestamp}_${name.replace(/\s+/g, '_').toLowerCase()}`;
+}

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

@@ -0,0 +1,74 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const DEFAULT_PATTERNS = [
+    '_relq_*',
+    'pg_*',
+    '_temp_*',
+    'tmp_*',
+];
+export function loadRelqignore(projectRoot = process.cwd()) {
+    const ignorePath = path.join(projectRoot, '.relqignore');
+    const patterns = [...DEFAULT_PATTERNS];
+    if (fs.existsSync(ignorePath)) {
+        const content = fs.readFileSync(ignorePath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            patterns.push(trimmed);
+        }
+    }
+    return patterns;
+}
+export function createDefaultRelqignore(projectRoot = process.cwd()) {
+    const ignorePath = path.join(projectRoot, '.relqignore');
+    if (fs.existsSync(ignorePath)) {
+        return;
+    }
+    const content = `# Relq Ignore File
+# Tables and functions matching these patterns will be ignored
+
+# Relq internal tables (always ignored)
+_relq_*
+
+# PostgreSQL system tables
+pg_*
+
+# Temporary tables
+_temp_*
+tmp_*
+
+# Add your tables/functions to ignore below:
+# analytics_raw
+# debug_*
+# test_*
+`;
+    fs.writeFileSync(ignorePath, content, 'utf-8');
+}
+export function isIgnored(name, patterns) {
+    for (const pattern of patterns) {
+        if (matchPattern(name, pattern)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function filterIgnored(items, patterns) {
+    return items.filter(item => !isIgnored(item.name, patterns));
+}
+function matchPattern(name, pattern) {
+    if (pattern.startsWith('!')) {
+        return !matchPattern(name, pattern.slice(1));
+    }
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    const regex = new RegExp(`^${regexPattern}$`, 'i');
+    return regex.test(name);
+}
+export function getIgnorePatterns(projectRoot = process.cwd()) {
+    return loadRelqignore(projectRoot);
+}