relq 1.0.24 → 1.0.26

package/dist/cjs/cli/commands/commit.cjs

@@ -40,8 +40,11 @@ const repo_manager_1 = require("../utils/repo-manager.cjs");
 const config_1 = require("../../config/config.cjs");
 const config_loader_1 = require("../utils/config-loader.cjs");
 const change_tracker_1 = require("../utils/change-tracker.cjs");
+const commit_manager_1 = require("../utils/commit-manager.cjs");
+const schema_to_ast_1 = require("../utils/schema-to-ast.cjs");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const jiti_1 = require("jiti");
 async function commitCommand(context) {
     const { config, flags, args, projectRoot } = context;
     const author = config?.author || 'Developer <dev@example.com>';
@@ -52,6 +55,9 @@ async function commitCommand(context) {
     const schemaPath = path.resolve(projectRoot, (0, config_loader_1.getSchemaPath)(config ?? undefined));
     const { requireValidSchema } = await Promise.resolve().then(() => __importStar(require("../utils/config-loader.cjs")));
     await requireValidSchema(schemaPath, flags);
+    if (flags['from-schema']) {
+        return commitFromSchema(context, schemaPath, author);
+    }
     const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
     if (staged.length === 0) {
         console.log('nothing to commit, working tree clean');
@@ -76,6 +82,8 @@ async function commitCommand(context) {
     }
     const sortedChanges = (0, change_tracker_1.sortChangesByDependency)(staged);
     const sql = (0, change_tracker_1.generateCombinedSQL)(sortedChanges);
+    const downSQL = (0, change_tracker_1.generateDownSQL)(sortedChanges);
+    const snapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
     const creates = staged.filter(c => c.type === 'CREATE').length;
     const alters = staged.filter(c => c.type === 'ALTER').length;
     const drops = staged.filter(c => c.type === 'DROP').length;
@@ -96,6 +104,8 @@ async function commitCommand(context) {
         timestamp: new Date().toISOString(),
         changes: sortedChanges,
         sql,
+        downSQL,
+        schema: snapshot,
         snapshotHash: hash.substring(0, 12),
         stats: {
             creates,
@@ -149,4 +159,74 @@ async function commitCommand(context) {
     (0, cli_utils_1.hint)("run 'relq export' to export as SQL file");
     console.log('');
 }
+async function commitFromSchema(context, schemaPath, author) {
+    const { config, flags, args, projectRoot } = context;
+    const spinner = (0, cli_utils_1.createSpinner)();
+    let message = flags['m'] || flags['message'];
+    if (!message) {
+        if (args.length > 0) {
+            message = args.join(' ');
+        }
+        else {
+            (0, cli_utils_1.fatal)('commit message required', "usage: relq commit --from-schema -m '<message>'");
+        }
+    }
+    spinner.start('Loading schema file');
+    let schemaModule;
+    try {
+        const jiti = (0, jiti_1.createJiti)(path.dirname(schemaPath), { interopDefault: true });
+        const module = await jiti.import(schemaPath);
+        if (module && module.default && typeof module.default === 'object') {
+            schemaModule = module.default;
+        }
+        else if (module && typeof module === 'object') {
+            schemaModule = module;
+        }
+        else {
+            throw new Error('Schema file must export an object with table/enum definitions');
+        }
+        spinner.succeed('Loaded schema file');
+    }
+    catch (err) {
+        spinner.fail('Failed to load schema');
+        (0, cli_utils_1.fatal)(`Could not load schema: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    spinner.start('Converting schema to AST');
+    const ast = (0, schema_to_ast_1.schemaToAST)(schemaModule);
+    spinner.succeed('Converted schema to AST');
+    const schemaHash = (0, commit_manager_1.generateASTHash)(ast);
+    spinner.start('Creating commit');
+    try {
+        const commit = (0, commit_manager_1.createCommitFromSchema)(schemaModule, author, message, config?.commitLimit ?? 1000, projectRoot);
+        spinner.succeed('Created commit');
+        const tableCount = ast.tables.length;
+        const enumCount = ast.enums.length;
+        const functionCount = ast.functions.length;
+        const viewCount = ast.views.length;
+        const triggerCount = ast.triggers.length;
+        console.log('');
+        console.log(`[${(0, repo_manager_1.shortHash)(commit.hash)}] ${message}`);
+        const statsParts = [];
+        if (tableCount > 0)
+            statsParts.push(`${tableCount} table(s)`);
+        if (enumCount > 0)
+            statsParts.push(`${enumCount} enum(s)`);
+        if (functionCount > 0)
+            statsParts.push(`${functionCount} function(s)`);
+        if (viewCount > 0)
+            statsParts.push(`${viewCount} view(s)`);
+        if (triggerCount > 0)
+            statsParts.push(`${triggerCount} trigger(s)`);
+        console.log(` ${statsParts.length > 0 ? statsParts.join(', ') : 'empty schema'}`);
+        console.log('');
+        console.log(cli_utils_1.colors.muted(`Schema hash: ${schemaHash.substring(0, 12)}`));
+        console.log('');
+        (0, cli_utils_1.hint)("run 'relq push' to apply changes to database");
+        (0, cli_utils_1.hint)("run 'relq log' to view commit history");
+    }
+    catch (err) {
+        spinner.fail('Failed to create commit');
+        (0, cli_utils_1.fatal)(`Could not create commit: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 exports.default = commitCommand;

package/dist/cjs/cli/commands/import.cjs

@@ -211,6 +211,7 @@ async function importCommand(sqlFilePath, options = {}, projectRoot = process.cw
         tables: filteredTables,
         enums: filteredEnums,
         domains: filteredDomains,
+        compositeTypes: parsedSchema.compositeTypes || [],
         sequences: filteredSequences,
         views: parsedSchema.views,
         functions: parsedSchema.functions,

package/dist/cjs/cli/commands/pull.cjs

@@ -413,13 +413,18 @@ async function pullCommand(context) {
                 console.log(`   ${cli_utils_1.colors.red(`-${removed.length}`)} tables removed`);
             }
             console.log('');
-            if (!dryRun) {
+            const noAutoMerge = flags['no-auto-merge'] === true;
+            if (!dryRun && noAutoMerge) {
                 const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.bold('Pull these changes?')}`, true);
                 if (!proceed) {
                     (0, cli_utils_1.fatal)('Operation cancelled by user');
                 }
                 console.log('');
             }
+            else if (!dryRun) {
+                console.log(`${cli_utils_1.colors.green('Auto-merging')} (no conflicts detected)`);
+                console.log('');
+            }
         }
         else if (schemaExists && !force) {
             (0, cli_utils_1.warning)('Local schema exists but not tracked');
@@ -481,6 +486,7 @@ async function pullCommand(context) {
         }
         spinner.start('Generating TypeScript schema...');
         const parsedSchema = await (0, ast_transformer_1.introspectedToParsedSchema)(dbSchema);
+        (0, ast_codegen_1.assignTrackingIds)(parsedSchema);
         const typescript = (0, ast_codegen_1.generateTypeScriptFromAST)(parsedSchema, {
             camelCase: config.generate?.camelCase ?? true,
             importPath: 'relq/schema-builder',
@@ -586,7 +592,7 @@ async function pullCommand(context) {
             triggers: filteredTriggers || [],
         };
         const schemaChanges = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
-        applyTrackingIdsToSnapshot(typescript, currentSchema);
+        (0, ast_codegen_1.copyTrackingIdsToNormalized)(parsedSchema, currentSchema);
         (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
         const duration = Date.now() - startTime;
         if (noCommit) {
@@ -692,26 +698,3 @@ function detectObjectConflicts(local, remote) {
     }
     return conflicts;
 }
-function applyTrackingIdsToSnapshot(typescript, snapshot) {
-    for (const table of snapshot.tables) {
-        const tablePattern = new RegExp(`defineTable\\s*\\(\\s*['"]${table.name}['"]\\s*,\\s*\\{[^}]+\\}\\s*,\\s*\\{[^}]*\\$trackingId:\\s*['"]([^'"]+)['"]`, 's');
-        const tableMatch = typescript.match(tablePattern);
-        if (tableMatch) {
-            table.trackingId = tableMatch[1];
-        }
-        for (const col of table.columns) {
-            const colPattern = new RegExp(`(?:${col.tsName}|${col.name}):\\s*\\w+\\([^)]*\\)[^\\n]*\\.\\\$id\\(['"]([^'"]+)['"]\\)`);
-            const colMatch = typescript.match(colPattern);
-            if (colMatch) {
-                col.trackingId = colMatch[1];
-            }
-        }
-        for (const idx of table.indexes) {
-            const idxPattern = new RegExp(`index\\s*\\(\\s*['"]${idx.name}['"]\\s*\\)[^\\n]*\\.\\\$id\\(['"]([^'"]+)['"]\\)`);
-            const idxMatch = typescript.match(idxPattern);
-            if (idxMatch) {
-                idx.trackingId = idxMatch[1];
-            }
-        }
-    }
-}

package/dist/cjs/cli/commands/push.cjs

@@ -52,7 +52,7 @@ async function pushCommand(context) {
     const { projectRoot } = context;
     const force = flags['force'] === true;
     const dryRun = flags['dry-run'] === true;
-    const applySQL = flags['apply'] === true;
+    const metadataOnly = flags['metadata-only'] === true;
     const noVerify = flags['no-verify'] === true;
     const skipPrompt = flags['yes'] === true || flags['y'] === true;
     const includeFunctions = config.includeFunctions ?? false;
@@ -165,9 +165,46 @@ async function pushCommand(context) {
             console.log('');
         }
         if (dryRun) {
-            console.log(`${cli_utils_1.colors.yellow('Dry run')} - no changes applied`);
+            console.log(`${cli_utils_1.colors.yellow('Dry run')} - showing changes that would be applied`);
             console.log('');
-            console.log(`${cli_utils_1.colors.muted('Use')} ${cli_utils_1.colors.cyan('relq push --apply')} ${cli_utils_1.colors.muted('to execute.')}`);
+            if (hasObjectsToDrop && force) {
+                console.log(`${cli_utils_1.colors.red('DROP statements:')}`);
+                for (const obj of analysis.objectsToDrop.slice(0, 5)) {
+                    console.log(`   ${generateDropSQL(obj)}`);
+                }
+                if (analysis.objectsToDrop.length > 5) {
+                    console.log(`   ${cli_utils_1.colors.muted(`... and ${analysis.objectsToDrop.length - 5} more`)}`);
+                }
+                console.log('');
+            }
+            const commitsToProcess = [...toPush].reverse();
+            let totalStatements = 0;
+            for (const commit of commitsToProcess) {
+                const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
+                if (fs.existsSync(commitPath)) {
+                    const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                    if (enhancedCommit.sql && enhancedCommit.sql.trim()) {
+                        const statements = enhancedCommit.sql.split(';').filter(s => s.trim());
+                        totalStatements += statements.length;
+                        console.log(`${cli_utils_1.colors.cyan(`Commit ${(0, repo_manager_1.shortHash)(commit.hash)}:`)} ${commit.message}`);
+                        for (const stmt of statements.slice(0, 3)) {
+                            console.log(`   ${stmt.trim().substring(0, 80)}${stmt.trim().length > 80 ? '...' : ''};`);
+                        }
+                        if (statements.length > 3) {
+                            console.log(`   ${cli_utils_1.colors.muted(`... and ${statements.length - 3} more statements`)}`);
+                        }
+                        console.log('');
+                    }
+                }
+            }
+            if (totalStatements === 0 && !hasObjectsToDrop) {
+                console.log(`${cli_utils_1.colors.muted('No SQL changes to apply')}`);
+            }
+            else {
+                console.log(`${cli_utils_1.colors.muted('Total:')} ${totalStatements + (hasObjectsToDrop ? analysis.objectsToDrop.length : 0)} statements`);
+            }
+            console.log('');
+            console.log(`${cli_utils_1.colors.muted('Remove')} ${cli_utils_1.colors.cyan('--dry-run')} ${cli_utils_1.colors.muted('to execute these changes.')}`);
             console.log('');
             return;
         }
@@ -180,8 +217,8 @@ async function pushCommand(context) {
             }
             spinner.succeed(`Pushed ${toPush.length} commit(s) to ${(0, repo_manager_1.getConnectionLabel)(connection)}`);
         }
-        if (applySQL) {
-            spinner.start('Applying SQL changes...');
+        if (!metadataOnly && !dryRun) {
+            spinner.start('Applying schema changes...');
             const pg = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
             const client = new pg.Client({
                 host: connection.host,
@@ -218,6 +255,9 @@ async function pushCommand(context) {
                 }
                 await client.query('COMMIT');
                 spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+                for (const commit of commitsToProcess) {
+                    await (0, repo_manager_1.markCommitAsApplied)(connection, commit.hash);
+                }
                 let hasRenameOperations = false;
                 for (const commit of commitsToProcess) {
                     const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
@@ -262,13 +302,13 @@ async function pushCommand(context) {
         const oldHash = remoteHead ? (0, repo_manager_1.shortHash)(remoteHead) : '(none)';
         const newHash = (0, repo_manager_1.shortHash)(localHead);
         console.log(`   ${oldHash}..${newHash}  ${cli_utils_1.colors.muted('main -> main')}`);
-        if (hasObjectsToDrop && force && applySQL) {
+        if (hasObjectsToDrop && force && !metadataOnly && !dryRun) {
             console.log('');
             (0, cli_utils_1.warning)(`Dropped ${analysis.objectsToDrop.length} object(s) from remote`);
         }
-        if (!applySQL) {
+        if (metadataOnly) {
             console.log('');
-            console.log(`${cli_utils_1.colors.muted('Use')} ${cli_utils_1.colors.cyan('relq push --apply')} ${cli_utils_1.colors.muted('to execute SQL.')}`);
+            console.log(`${cli_utils_1.colors.muted('Metadata only - SQL not executed. Remove')} ${cli_utils_1.colors.cyan('--metadata-only')} ${cli_utils_1.colors.muted('to apply changes.')}`);
         }
         console.log('');
     }

package/dist/cjs/cli/commands/rollback.cjs

@@ -39,109 +39,230 @@ const path = __importStar(require("path"));
 const config_loader_1 = require("../utils/config-loader.cjs");
 const env_loader_1 = require("../utils/env-loader.cjs");
 const cli_utils_1 = require("../utils/cli-utils.cjs");
-function parseMigration(content) {
-    const upMatch = content.match(/--\s*UP\s*\n([\s\S]*?)(?=--\s*DOWN|$)/i);
-    const downMatch = content.match(/--\s*DOWN\s*\n([\s\S]*?)$/i);
-    return {
-        up: upMatch?.[1]?.trim() || '',
-        down: downMatch?.[1]?.trim() || '',
-    };
-}
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+const schema_diff_1 = require("../utils/schema-diff.cjs");
+const migration_generator_1 = require("../utils/migration-generator.cjs");
 async function rollbackCommand(context) {
     const { config, args, flags } = context;
     if (!config) {
-        (0, cli_utils_1.fatal)('No configuration found', `run ${cli_utils_1.colors.cyan('relq init')} to create a configuration file`);
-        return;
+        (0, cli_utils_1.fatal)('No configuration found', `Run ${cli_utils_1.colors.cyan('relq init')} to create one.`);
     }
     await (0, config_loader_1.requireValidConfig)(config, { calledFrom: 'rollback' });
     const connection = config.connection;
-    const migrationsDir = config.migrations?.directory || './migrations';
-    const tableName = config.migrations?.tableName || '_relq_migrations';
-    const count = parseInt(args[0]) || 1;
-    const dryRun = flags['dry-run'] === true;
-    const force = flags['force'] === true;
-    console.log(`Rolling back ${count} migration(s)...`);
-    console.log(`   Connection: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
+    const { projectRoot } = context;
+    const preview = flags['preview'] === true || flags['dry-run'] === true;
+    const skipPrompt = flags['yes'] === true || flags['y'] === true;
     console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        (0, cli_utils_1.fatal)('not a relq repository (or any parent directories): .relq', `Run ${cli_utils_1.colors.cyan('relq init')} to initialize.`);
+    }
+    const localHead = (0, repo_manager_1.getHead)(projectRoot);
+    if (!localHead) {
+        (0, cli_utils_1.fatal)('no commits to rollback', 'Repository has no commits.');
+    }
+    const targetRef = args[0] || 'HEAD~1';
+    const target = resolveTarget(projectRoot, targetRef, localHead);
+    if (!target) {
+        (0, cli_utils_1.fatal)(`invalid rollback target: ${targetRef}`, 'Use a commit hash or HEAD~N notation.');
+    }
+    if (target.commitsToRollback.length === 0) {
+        console.log('Nothing to rollback - already at target commit.');
+        console.log('');
+        return;
+    }
+    const spinner = (0, cli_utils_1.createSpinner)();
     try {
-        const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
-        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 FROM "${tableName}" 
-                ORDER BY id DESC 
-                LIMIT $1;
-            `, [count]);
-            if (result.rows.length === 0) {
-                console.log('No migrations to rollback.');
-                return;
-            }
-            const toRollback = result.rows.map(r => r.name);
-            console.log('Migrations to rollback:');
-            for (const name of toRollback) {
-                console.log(`  - ${name}`);
-            }
+        console.log(`Rolling back to ${cli_utils_1.colors.yellow((0, repo_manager_1.shortHash)(target.hash))}`);
+        console.log(`${cli_utils_1.colors.muted(target.message)}`);
+        console.log('');
+        console.log(`${cli_utils_1.colors.red('Commits to rollback:')} ${target.commitsToRollback.length}`);
+        for (const commit of target.commitsToRollback.slice(0, 5)) {
+            console.log(`   ${cli_utils_1.colors.red('↩')} ${(0, repo_manager_1.shortHash)(commit.hash)} ${commit.message}`);
+        }
+        if (target.commitsToRollback.length > 5) {
+            console.log(`   ${cli_utils_1.colors.muted(`... and ${target.commitsToRollback.length - 5} more`)}`);
+        }
+        console.log('');
+        const currentCommitPath = path.join(projectRoot, '.relq', 'commits', `${localHead}.json`);
+        const targetCommitPath = path.join(projectRoot, '.relq', 'commits', `${target.hash}.json`);
+        if (!fs.existsSync(currentCommitPath)) {
+            (0, cli_utils_1.fatal)(`current commit not found: ${localHead}`);
+        }
+        if (!fs.existsSync(targetCommitPath)) {
+            (0, cli_utils_1.fatal)(`target commit not found: ${target.hash}`);
+        }
+        const currentCommit = JSON.parse(fs.readFileSync(currentCommitPath, 'utf-8'));
+        const targetCommit = JSON.parse(fs.readFileSync(targetCommitPath, 'utf-8'));
+        let rollbackSQL = [];
+        if (currentCommit.schemaAST && targetCommit.schemaAST) {
+            const comparison = (0, schema_diff_1.compareSchemas)(currentCommit.schemaAST, targetCommit.schemaAST);
+            const migration = (0, migration_generator_1.generateMigrationFromComparison)(comparison);
+            rollbackSQL = migration.down;
+        }
+        else {
+            (0, cli_utils_1.warning)('No schema AST found - using commit SQL reversal (may be incomplete)');
             console.log('');
-            if (!force && !dryRun) {
-                const proceed = await (0, cli_utils_1.confirm)(`${cli_utils_1.colors.red('This will undo ' + toRollback.length + ' migration(s). Continue?')}`, false);
-                if (!proceed) {
-                    console.log('Cancelled.');
-                    return;
+            for (const commit of target.commitsToRollback) {
+                const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
+                if (fs.existsSync(commitPath)) {
+                    const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                    if (enhancedCommit.downSQL) {
+                        rollbackSQL.push(enhancedCommit.downSQL);
+                    }
                 }
             }
-            for (const name of toRollback) {
-                const filePath = path.join(migrationsDir, name);
-                if (!fs.existsSync(filePath)) {
-                    (0, cli_utils_1.warning)(`Migration file not found: ${name}`);
-                    continue;
-                }
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const { down } = parseMigration(content);
-                if (!down) {
-                    (0, cli_utils_1.warning)(`No DOWN section in: ${name}`);
-                    continue;
+        }
+        if (rollbackSQL.length === 0) {
+            (0, cli_utils_1.warning)('No rollback SQL generated - manual intervention may be required');
+            console.log('');
+        }
+        if (preview) {
+            console.log(`${cli_utils_1.colors.yellow('Preview')} - showing rollback SQL`);
+            console.log('');
+            if (rollbackSQL.length > 0) {
+                for (const sql of rollbackSQL.slice(0, 10)) {
+                    console.log(`   ${sql.substring(0, 100)}${sql.length > 100 ? '...' : ''}`);
                 }
-                if (dryRun) {
-                    console.log(`[dry-run] Would rollback: ${name}`);
-                    console.log(down);
-                    console.log('');
+                if (rollbackSQL.length > 10) {
+                    console.log(`   ${cli_utils_1.colors.muted(`... and ${rollbackSQL.length - 10} more statements`)}`);
                 }
-                else {
-                    console.log(`Rolling back: ${name}...`);
-                    const client = await pool.connect();
-                    try {
-                        await client.query('BEGIN');
-                        await client.query(down);
-                        await client.query(`DELETE FROM "${tableName}" WHERE name = $1`, [name]);
-                        await client.query('COMMIT');
-                        console.log('   Rolled back');
-                    }
-                    catch (error) {
-                        await client.query('ROLLBACK');
-                        throw error;
-                    }
-                    finally {
-                        client.release();
+            }
+            else {
+                console.log(`   ${cli_utils_1.colors.muted('(no SQL statements)')}`);
+            }
+            console.log('');
+            console.log(`${cli_utils_1.colors.muted('Remove')} ${cli_utils_1.colors.cyan('--preview')} ${cli_utils_1.colors.muted('to execute rollback.')}`);
+            console.log('');
+            return;
+        }
+        if (!skipPrompt) {
+            (0, cli_utils_1.warning)('This will modify your database!');
+            console.log('');
+            const confirmed = await (0, cli_utils_1.confirm)(`Rollback ${target.commitsToRollback.length} commit(s)?`, false);
+            if (!confirmed) {
+                (0, cli_utils_1.fatal)('Rollback cancelled by user');
+            }
+        }
+        spinner.start('Connecting to remote...');
+        await (0, repo_manager_1.ensureRemoteTable)(connection);
+        spinner.succeed(`Connected to ${cli_utils_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+        if (rollbackSQL.length > 0) {
+            spinner.start('Executing rollback...');
+            const pg = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
+            const client = new pg.Client({
+                host: connection.host,
+                port: connection.port,
+                database: connection.database,
+                user: connection.user,
+                password: connection.password,
+            });
+            try {
+                await client.connect();
+                await client.query('BEGIN');
+                let statementsRun = 0;
+                for (const sql of rollbackSQL) {
+                    if (sql.trim()) {
+                        await client.query(sql);
+                        statementsRun++;
                     }
                 }
+                await client.query('COMMIT');
+                spinner.succeed(`Executed ${statementsRun} rollback statement(s)`);
+            }
+            catch (error) {
+                try {
+                    await client.query('ROLLBACK');
+                    spinner.fail('Rollback failed - transaction rolled back');
+                }
+                catch {
+                    spinner.fail('Rollback failed');
+                }
+                throw error;
             }
-            if (!dryRun) {
-                console.log('');
-                console.log(`Rolled back ${toRollback.length} migration(s).`);
+            finally {
+                await client.end();
             }
         }
-        finally {
-            await pool.end();
+        spinner.start('Updating commit status...');
+        for (const commit of target.commitsToRollback) {
+            await (0, repo_manager_1.markCommitAsRolledBack)(connection, commit.hash);
+        }
+        spinner.succeed('Marked commits as rolled back');
+        const headPath = path.join(projectRoot, '.relq', 'HEAD');
+        fs.writeFileSync(headPath, target.hash);
+        if (targetCommit.schema) {
+            const snapshotPath = path.join(projectRoot, '.relq', 'snapshot.json');
+            fs.writeFileSync(snapshotPath, JSON.stringify(targetCommit.schema, null, 2));
         }
+        console.log('');
+        console.log(`${cli_utils_1.colors.green('Rollback complete')}`);
+        console.log(`   ${(0, repo_manager_1.shortHash)(localHead)} → ${(0, repo_manager_1.shortHash)(target.hash)}`);
+        console.log('');
     }
-    catch (error) {
-        (0, cli_utils_1.fatal)('Rollback failed', error instanceof Error ? error.message : String(error));
+    catch (err) {
+        spinner.fail('Rollback failed');
+        (0, cli_utils_1.fatal)(err instanceof Error ? err.message : String(err));
     }
 }
+function resolveTarget(projectRoot, ref, currentHead) {
+    const commits = (0, repo_manager_1.getAllCommits)(projectRoot);
+    const commitsByHash = new Map(commits.map(c => [c.hash, c]));
+    if (ref.startsWith('HEAD~')) {
+        const n = parseInt(ref.slice(5), 10);
+        if (isNaN(n) || n < 1)
+            return null;
+        let current = currentHead;
+        const commitsToRollback = [];
+        for (let i = 0; i < n; i++) {
+            const commitPath = path.join(projectRoot, '.relq', 'commits', `${current}.json`);
+            if (!fs.existsSync(commitPath))
+                return null;
+            const commit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+            commitsToRollback.push(commit);
+            if (!commit.parentHash) {
+                if (i < n - 1) {
+                    return null;
+                }
+                return {
+                    hash: commit.hash,
+                    message: '(initial state)',
+                    commitsToRollback: commitsToRollback.slice(0, -1),
+                };
+            }
+            current = commit.parentHash;
+        }
+        const targetPath = path.join(projectRoot, '.relq', 'commits', `${current}.json`);
+        if (!fs.existsSync(targetPath))
+            return null;
+        const targetCommit = JSON.parse(fs.readFileSync(targetPath, 'utf-8'));
+        return {
+            hash: current,
+            message: targetCommit.message,
+            commitsToRollback,
+        };
+    }
+    const normalizedRef = ref.length < 40 ? commits.find(c => c.hash.startsWith(ref))?.hash : ref;
+    if (!normalizedRef || !commitsByHash.has(normalizedRef)) {
+        return null;
+    }
+    const commitsToRollback = [];
+    let current = currentHead;
+    while (current && current !== normalizedRef) {
+        const commitPath = path.join(projectRoot, '.relq', 'commits', `${current}.json`);
+        if (!fs.existsSync(commitPath))
+            break;
+        const commit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+        commitsToRollback.push(commit);
+        current = commit.parentHash || '';
+    }
+    if (current !== normalizedRef) {
+        return null;
+    }
+    const targetCommit = commitsByHash.get(normalizedRef);
+    return {
+        hash: normalizedRef,
+        message: targetCommit?.message || '',
+        commitsToRollback,
+    };
+}
+exports.default = rollbackCommand;