relq 1.0.0

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

@@ -0,0 +1,401 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { loadEnvConfig } from "../utils/env-loader.js";
+import { initRepository, ensureRemoteTable, isInitialized } from "../utils/repo-manager.js";
+import { createDefaultRelqignore } from "../utils/relqignore.js";
+import { colors, createSpinner } from "../utils/spinner.js";
+function ask(rl, question, defaultValue) {
+    const suffix = defaultValue ? ` ${colors.muted(`[${defaultValue}]`)}` : '';
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            resolve(answer.trim() || defaultValue || '');
+        });
+    });
+}
+function askYesNo(rl, question, defaultYes = true) {
+    const suffix = defaultYes ? colors.muted('[Y/n]') : colors.muted('[y/N]');
+    return new Promise((resolve) => {
+        rl.question(`${question} ${suffix}: `, (answer) => {
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+function detectSchemaPath() {
+    const cwd = process.cwd();
+    if (fs.existsSync(path.join(cwd, 'src'))) {
+        return './src/db/schema.ts';
+    }
+    if (fs.existsSync(path.join(cwd, 'app'))) {
+        return './app/db/schema.ts';
+    }
+    if (fs.existsSync(path.join(cwd, 'db'))) {
+        return './db/schema.ts';
+    }
+    if (fs.existsSync(path.join(cwd, 'lib'))) {
+        return './lib/db/schema.ts';
+    }
+    return './src/db/schema.ts';
+}
+function checkEnvVars() {
+    const vars = {
+        DATABASE_HOST: process.env.DATABASE_HOST,
+        DATABASE_PORT: process.env.DATABASE_PORT,
+        DATABASE_NAME: process.env.DATABASE_NAME,
+        DATABASE_USER: process.env.DATABASE_USER,
+        DATABASE_PASSWORD: process.env.DATABASE_PASSWORD,
+        RELQ_PG_CONN_URL: process.env.RELQ_PG_CONN_URL,
+    };
+    const hasConnUrl = !!vars.RELQ_PG_CONN_URL;
+    const hasIndividual = !!(vars.DATABASE_HOST && vars.DATABASE_NAME);
+    return {
+        found: hasConnUrl || hasIndividual,
+        vars,
+    };
+}
+function generateConfig(options) {
+    let connectionBlock;
+    if (options.useEnv) {
+        if (process.env.RELQ_PG_CONN_URL) {
+            connectionBlock = `    connection: {
+        url: process.env.RELQ_PG_CONN_URL,
+    },`;
+        }
+        else {
+            connectionBlock = `    connection: {
+        host: process.env.DATABASE_HOST,
+        port: parseInt(process.env.DATABASE_PORT || '5432'),
+        database: process.env.DATABASE_NAME,
+        user: process.env.DATABASE_USER,
+        password: process.env.DATABASE_PASSWORD,
+    },`;
+        }
+    }
+    else {
+        connectionBlock = `    connection: {
+        host: '${options.host}',
+        port: ${options.port},
+        database: '${options.database}',
+        user: '${options.user}',
+        password: '${options.password}',
+    },`;
+    }
+    return `import { defineConfig } from 'relq/config';
+
+export default defineConfig({
+${connectionBlock}
+
+    // Author for commits (required)
+    author: '${options.author}',
+
+    // Schema file path
+    schema: '${options.schemaPath}',
+
+    // What to track
+    generate: {
+        includeFunctions: ${options.includeFunctions},
+        includeTriggers: ${options.includeTriggers},
+        includeRLS: false,
+        camelCase: true,
+    },
+
+    // Migrations
+    migrations: {
+        directory: './migrations',
+        tableName: '_relq_migrations',
+    },
+
+    // Sync settings
+    sync: {
+        commitLimit: 1000,
+    },
+});
+`;
+}
+export async function initCommand(context) {
+    const cwd = process.cwd();
+    const spinner = createSpinner();
+    console.log('');
+    console.log(`${colors.bold('Relq')} - Git-like schema versioning for PostgreSQL`);
+    console.log('');
+    const { findConfigFileRecursive } = await import("../utils/config-loader.js");
+    const existingConfig = findConfigFileRecursive(cwd);
+    const localRelqExists = isInitialized(cwd);
+    let projectRoot = cwd;
+    let existingConfigValues = null;
+    if (existingConfig) {
+        projectRoot = existingConfig.directory;
+        try {
+            const { loadConfig } = await import("../../config/config.js");
+            existingConfigValues = await loadConfig(existingConfig.path);
+        }
+        catch {
+        }
+        if (existingConfig.directory !== cwd) {
+            console.log(`${colors.cyan('ℹ')}  Found ${colors.cyan('relq.config.ts')} in parent directory:`);
+            console.log(`   ${colors.muted(existingConfig.path)}`);
+            console.log('');
+            console.log(`${colors.muted('Run commands from project root:')} ${colors.cyan(existingConfig.directory)}`);
+            console.log('');
+            return;
+        }
+        const relqFolderExists = isInitialized(projectRoot);
+        if (relqFolderExists) {
+            console.log(`${colors.green('✓')} Relq is already initialized.`);
+            console.log('');
+            console.log(`   ${colors.green('●')} ${colors.muted('relq.config.ts')}`);
+            console.log(`   ${colors.green('●')} ${colors.muted('.relq/')} folder`);
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq status')} ${colors.muted('to see current state.')}`);
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq pull')} ${colors.muted('to sync with database.')}`);
+            return;
+        }
+        else {
+            console.log(`${colors.yellow('⚠')}  Found ${colors.cyan('relq.config.ts')} but ${colors.cyan('.relq/')} folder is missing.`);
+            console.log('');
+            console.log(`${colors.muted('This could mean the setup was incomplete.')}`);
+            console.log('');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            try {
+                const upgrade = await askYesNo(rl, `Complete setup using existing config?`, true);
+                if (upgrade) {
+                    const missingFields = [];
+                    if (!existingConfigValues?.author || existingConfigValues.author === 'Developer <dev@example.com>') {
+                        missingFields.push('author');
+                    }
+                    if (!existingConfigValues?.schema) {
+                        missingFields.push('schema');
+                    }
+                    if (!existingConfigValues?.connection?.host && !existingConfigValues?.connection?.url) {
+                        const hasEnvConnection = process.env.DATABASE_HOST || process.env.RELQ_PG_CONN_URL;
+                        if (!hasEnvConnection) {
+                            missingFields.push('connection');
+                        }
+                    }
+                    if (missingFields.length > 0) {
+                        console.log('');
+                        console.log(`${colors.yellow('⚠')}  Your config is missing required fields:`);
+                        for (const field of missingFields) {
+                            console.log(`   ${colors.red('●')} ${field}`);
+                        }
+                        console.log('');
+                        console.log(`${colors.cyan('●')} Let's fill in the missing fields:`);
+                        console.log('');
+                        let authorValue = existingConfigValues?.author;
+                        let schemaValue = existingConfigValues?.schema;
+                        if (missingFields.includes('author')) {
+                            authorValue = await ask(rl, 'Author (Name <email>)', 'Developer <dev@example.com>');
+                        }
+                        if (missingFields.includes('schema')) {
+                            schemaValue = await ask(rl, 'Schema file path', detectSchemaPath());
+                        }
+                        if (missingFields.includes('connection')) {
+                            console.log('');
+                            console.log(`${colors.red('●')} Connection not configured.`);
+                            console.log(`   ${colors.muted('Set DATABASE_* environment variables in .env')}`);
+                            console.log(`   ${colors.muted('or update relq.config.ts with connection details.')}`);
+                            rl.close();
+                            return;
+                        }
+                        if (authorValue || schemaValue) {
+                            console.log('');
+                            spinner.start('Updating relq.config.ts...');
+                            const configContent = fs.readFileSync(existingConfig.path, 'utf-8');
+                            let updatedContent = configContent;
+                            if (missingFields.includes('author') && authorValue) {
+                                if (updatedContent.includes('connection:')) {
+                                    updatedContent = updatedContent.replace(/(connection:\s*\{[^}]+\},?)/, `$1\n\n    // Author for commits (required)\n    author: '${authorValue}',`);
+                                }
+                            }
+                            if (missingFields.includes('schema') && schemaValue) {
+                                if (updatedContent.includes('author:')) {
+                                    updatedContent = updatedContent.replace(/(author:\s*['"][^'"]+['"],?)/, `$1\n\n    // Schema file path\n    schema: '${schemaValue}',`);
+                                }
+                            }
+                            fs.writeFileSync(existingConfig.path, updatedContent, 'utf-8');
+                            spinner.succeed('Updated relq.config.ts');
+                            existingConfigValues = { ...existingConfigValues, author: authorValue, schema: schemaValue };
+                        }
+                    }
+                    rl.close();
+                    console.log('');
+                    console.log(`${colors.cyan('●')} Completing setup...`);
+                    console.log('');
+                    initRepository(projectRoot);
+                    console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relq/')} folder`);
+                    createDefaultRelqignore(projectRoot);
+                    console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relqignore')}`);
+                    const gitignorePath = path.join(projectRoot, '.gitignore');
+                    if (fs.existsSync(gitignorePath)) {
+                        const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+                        if (!gitignore.includes('.relq')) {
+                            fs.appendFileSync(gitignorePath, '\n# Relq local state\n.relq/\n');
+                            console.log(`   ${colors.green('✓')} Added ${colors.cyan('.relq/')} to .gitignore`);
+                        }
+                    }
+                    if (existingConfigValues?.connection) {
+                        spinner.start('Creating _relq_commits table...');
+                        try {
+                            await ensureRemoteTable(existingConfigValues.connection);
+                            spinner.succeed('Created _relq_commits table');
+                        }
+                        catch (error) {
+                            spinner.fail('Could not create table (check connection)');
+                        }
+                    }
+                    console.log('');
+                    console.log(`${colors.green('✓')} Setup complete!`);
+                    console.log('');
+                    console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('to sync with database.')}`);
+                    return;
+                }
+                rl.close();
+                console.log('');
+                console.log(`${colors.muted('Cancelled.')}`);
+                return;
+            }
+            catch {
+                rl.close();
+                return;
+            }
+        }
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        console.log(`${colors.cyan('●')} Checking for database connection...`);
+        console.log('');
+        const envCheck = checkEnvVars();
+        let useEnv = false;
+        let host = 'localhost';
+        let port = '5432';
+        let database = '';
+        let user = 'postgres';
+        let password = '';
+        if (envCheck.found) {
+            console.log(`${colors.green('✓')} Found database environment variables:`);
+            if (envCheck.vars.RELQ_PG_CONN_URL) {
+                console.log(`   ${colors.green('✓')} RELQ_PG_CONN_URL`);
+            }
+            else {
+                if (envCheck.vars.DATABASE_HOST)
+                    console.log(`   ${colors.green('✓')} DATABASE_HOST: ${envCheck.vars.DATABASE_HOST}`);
+                if (envCheck.vars.DATABASE_PORT)
+                    console.log(`   ${colors.green('✓')} DATABASE_PORT: ${envCheck.vars.DATABASE_PORT}`);
+                if (envCheck.vars.DATABASE_NAME)
+                    console.log(`   ${colors.green('✓')} DATABASE_NAME: ${envCheck.vars.DATABASE_NAME}`);
+                if (envCheck.vars.DATABASE_USER)
+                    console.log(`   ${colors.green('✓')} DATABASE_USER: ${envCheck.vars.DATABASE_USER}`);
+                if (envCheck.vars.DATABASE_PASSWORD)
+                    console.log(`   ${colors.green('✓')} DATABASE_PASSWORD: ***`);
+            }
+            console.log('');
+            useEnv = await askYesNo(rl, 'Use these environment variables?', true);
+            console.log('');
+        }
+        if (!useEnv) {
+            console.log(`${colors.cyan('●')} Database Connection`);
+            console.log('');
+            host = await ask(rl, '  Host', 'localhost');
+            port = await ask(rl, '  Port', '5432');
+            database = await ask(rl, '  Database');
+            user = await ask(rl, '  User', 'postgres');
+            password = await ask(rl, '  Password');
+            console.log('');
+        }
+        const detectedPath = detectSchemaPath();
+        console.log(`${colors.cyan('●')} Schema Configuration`);
+        console.log('');
+        const schemaPath = await ask(rl, '  Schema file path', detectedPath);
+        console.log('');
+        console.log(`${colors.cyan('●')} Author (for commit history)`);
+        console.log('');
+        const author = await ask(rl, '  Name <email>', 'Developer <dev@example.com>');
+        console.log('');
+        console.log(`${colors.cyan('●')} Features to track`);
+        console.log('');
+        const includeFunctions = await askYesNo(rl, '  Include functions?', false);
+        const includeTriggers = await askYesNo(rl, '  Include triggers?', false);
+        console.log('');
+        rl.close();
+        console.log(`${colors.cyan('●')} Creating files...`);
+        console.log('');
+        const configPath = path.join(cwd, 'relq.config.ts');
+        if (!fs.existsSync(configPath)) {
+            const configContent = generateConfig({
+                useEnv,
+                host,
+                port,
+                database,
+                user,
+                password,
+                schemaPath,
+                author,
+                includeFunctions,
+                includeTriggers,
+            });
+            fs.writeFileSync(configPath, configContent, 'utf-8');
+            console.log(`   ${colors.green('✓')} Created ${colors.cyan('relq.config.ts')}`);
+        }
+        else {
+            console.log(`   ${colors.yellow('○')} ${colors.cyan('relq.config.ts')} already exists`);
+        }
+        initRepository(cwd);
+        console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relq/')} folder`);
+        createDefaultRelqignore(cwd);
+        console.log(`   ${colors.green('✓')} Created ${colors.cyan('.relqignore')}`);
+        const schemaDir = path.dirname(schemaPath);
+        if (!fs.existsSync(schemaDir)) {
+            fs.mkdirSync(schemaDir, { recursive: true });
+            console.log(`   ${colors.green('✓')} Created ${colors.cyan(schemaDir + '/')}`);
+        }
+        const gitignorePath = path.join(cwd, '.gitignore');
+        if (fs.existsSync(gitignorePath)) {
+            const gitignore = fs.readFileSync(gitignorePath, 'utf-8');
+            if (!gitignore.includes('.relq')) {
+                fs.appendFileSync(gitignorePath, '\n# Relq local state\n.relq/\n');
+                console.log(`   ${colors.green('✓')} Added ${colors.cyan('.relq/')} to ${colors.cyan('.gitignore')}`);
+            }
+        }
+        console.log('');
+        spinner.start('Connecting to database...');
+        try {
+            const envConfig = loadEnvConfig();
+            const connection = useEnv && envConfig ? envConfig : {
+                host,
+                port: parseInt(port),
+                database,
+                user,
+                password,
+            };
+            await ensureRemoteTable(connection);
+            spinner.succeed('Created _relq_commits table');
+        }
+        catch (error) {
+            spinner.fail('Could not connect to database');
+            console.log(`   ${colors.yellow('⚠')}  ${colors.muted('Run relq pull after fixing connection')}`);
+        }
+        console.log('');
+        console.log(`${colors.green('✓')} ${colors.bold('Relq initialized successfully!')}`);
+        console.log('');
+        console.log(`${colors.bold('Next steps:')}`);
+        console.log(`  1. Review ${colors.cyan('relq.config.ts')}`);
+        console.log(`  2. Run ${colors.cyan('relq pull')} to sync with database`);
+        console.log(`  3. Run ${colors.cyan('relq status')} to see current state`);
+        console.log('');
+    }
+    catch (error) {
+        rl.close();
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,106 @@
+import * as fs from 'fs';
+import * as readline from 'readline';
+import { parseSqlToDefineTable } from "../../introspect/index.js";
+function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf-8');
+        process.stdin.on('data', chunk => data += chunk);
+        process.stdin.on('end', () => resolve(data));
+    });
+}
+function readInteractive() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    console.log('Enter SQL (CREATE TABLE statements). End with empty line:\n');
+    return new Promise((resolve) => {
+        const lines = [];
+        let emptyLineCount = 0;
+        rl.on('line', (line) => {
+            if (line.trim() === '') {
+                emptyLineCount++;
+                if (emptyLineCount >= 2) {
+                    rl.close();
+                    resolve(lines.join('\n'));
+                }
+            }
+            else {
+                emptyLineCount = 0;
+                lines.push(line);
+            }
+        });
+        rl.on('close', () => {
+            resolve(lines.join('\n'));
+        });
+    });
+}
+export async function introspectCommand(context) {
+    const { flags } = context;
+    const filePath = flags['file'];
+    const useStdin = flags['stdin'] === true;
+    let sql;
+    if (filePath) {
+        if (!fs.existsSync(filePath)) {
+            console.error(`Error: File not found: ${filePath}`);
+            process.exit(1);
+        }
+        sql = fs.readFileSync(filePath, 'utf-8');
+        console.log(`📄 Reading from: ${filePath}\n`);
+    }
+    else if (useStdin || !process.stdin.isTTY) {
+        sql = await readStdin();
+    }
+    else {
+        sql = await readInteractive();
+    }
+    if (!sql.trim()) {
+        console.error('Error: No SQL input provided.');
+        console.error('Usage: relq introspect --file schema.sql');
+        console.error('   or: cat schema.sql | relq introspect');
+        process.exit(1);
+    }
+    console.log('🔍 Parsing SQL...\n');
+    try {
+        const tables = parseSqlToDefineTable(sql);
+        if (tables.length === 0) {
+            console.log('No CREATE TABLE statements found.');
+            return;
+        }
+        console.log(`Found ${tables.length} table(s):\n`);
+        const output = [
+            "import { defineTable, serial, integer, bigint, varchar, text, boolean, uuid, jsonb, json, timestamp, date, numeric, vector } from 'relq/schema-builder';",
+            '',
+        ];
+        for (const table of tables) {
+            output.push(generateDefineTableCode(table));
+            output.push('');
+        }
+        console.log(output.join('\n'));
+    }
+    catch (error) {
+        console.error('Error parsing SQL:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+function generateDefineTableCode(table) {
+    const columns = table.columns.map(col => {
+        const parts = [];
+        parts.push(col.typeCode);
+        if (col.isPrimaryKey)
+            parts.push('.primaryKey()');
+        if (!col.isNullable && !col.isPrimaryKey)
+            parts.push('.notNull()');
+        if (col.isUnique)
+            parts.push('.unique()');
+        if (col.references)
+            parts.push(`.references('${col.references.table}', '${col.references.column}')`);
+        if (col.defaultValue)
+            parts.push(`.default(${col.defaultValue})`);
+        return `    ${col.name}: ${parts.join('')},`;
+    });
+    return `export const ${table.name} = defineTable('${table.name}', {
+${columns.join('\n')}
+});`;
+}

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

@@ -0,0 +1,59 @@
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getHead, getCommitHistory, shortHash, } from "../utils/repo-manager.js";
+function formatDate(timestamp) {
+    const date = new Date(timestamp);
+    const days = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const dayName = days[date.getDay()];
+    const monthName = months[date.getMonth()];
+    const day = date.getDate();
+    const time = date.toTimeString().split(' ')[0];
+    const year = date.getFullYear();
+    return `${dayName} ${monthName} ${day} ${time} ${year}`;
+}
+export async function logCommand(context) {
+    const { flags } = context;
+    const projectRoot = process.cwd();
+    const limit = parseInt(flags['n']) || 10;
+    const oneline = flags['oneline'] === true;
+    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 head = getHead(projectRoot);
+    const commits = getCommitHistory(limit, projectRoot);
+    if (commits.length === 0) {
+        console.log(`${colors.muted('No commits yet.')}`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to create first commit.')}`);
+        console.log('');
+        return;
+    }
+    for (const commit of commits) {
+        const isHead = commit.hash === head;
+        if (oneline) {
+            const headMarker = isHead ? `${colors.cyan('(HEAD)')} ` : '';
+            console.log(`${colors.yellow(shortHash(commit.hash))} ${headMarker}${commit.message}`);
+        }
+        else {
+            console.log(`${colors.yellow(`commit ${commit.hash}`)}`);
+            if (isHead) {
+                console.log(`${colors.cyan('(HEAD)')}`);
+            }
+            console.log(`Author: ${commit.author}`);
+            console.log(`Date:   ${formatDate(commit.timestamp)}`);
+            console.log('');
+            console.log(`    ${commit.message}`);
+            console.log('');
+            console.log(`    ${colors.muted(`${commit.stats.tables} tables, ${commit.stats.columns} columns`)}`);
+            console.log('');
+        }
+    }
+    if (!oneline) {
+        console.log('');
+    }
+}
+export { logCommand as historyCommand };