relq 1.0.25 → 1.0.27

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;

package/dist/cjs/cli/commands/schema-ast.cjs

@@ -0,0 +1,219 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaAstCommand = schemaAstCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const jiti_1 = require("jiti");
+const config_loader_1 = require("../utils/config-loader.cjs");
+const schema_to_ast_1 = require("../utils/schema-to-ast.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+async function schemaAstCommand(context) {
+    const { config, args, flags, projectRoot } = context;
+    const spinner = (0, spinner_1.createSpinner)();
+    console.log('');
+    const options = {
+        json: Boolean(flags.json),
+        output: flags.output,
+        pretty: flags.pretty !== false,
+    };
+    let schemaPath;
+    if (args.length > 0) {
+        schemaPath = path.resolve(projectRoot, args[0]);
+    }
+    else {
+        schemaPath = path.resolve(projectRoot, (0, config_loader_1.getSchemaPath)(config ?? undefined));
+    }
+    const relativePath = path.relative(process.cwd(), schemaPath);
+    spinner.start(`Loading schema from ${spinner_1.colors.cyan(relativePath)}`);
+    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 from ${spinner_1.colors.cyan(relativePath)}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to load schema`);
+        console.log('');
+        console.log(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        console.log('');
+        console.log(spinner_1.colors.yellow('hint:') + ` Make sure ${relativePath} is a valid TypeScript schema file.`);
+        console.log('');
+        process.exit(1);
+    }
+    spinner.start('Converting schema to AST');
+    let ast;
+    try {
+        ast = (0, schema_to_ast_1.schemaToAST)(schemaModule);
+        spinner.succeed('Converted schema to AST');
+    }
+    catch (error) {
+        spinner.fail('Failed to convert schema');
+        console.log('');
+        console.log(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : String(error)}`));
+        console.log('');
+        process.exit(1);
+    }
+    const indent = options.pretty ? 2 : 0;
+    const output = JSON.stringify(ast, null, indent);
+    if (options.output) {
+        const outputPath = path.resolve(projectRoot, options.output);
+        const outputDir = path.dirname(outputPath);
+        if (!fs.existsSync(outputDir)) {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, output, 'utf-8');
+        console.log('');
+        console.log(`Written AST to ${spinner_1.colors.cyan(options.output)}`);
+    }
+    else if (options.json) {
+        console.log(output);
+    }
+    else {
+        console.log('');
+        printAstSummary(ast);
+        console.log('');
+        console.log(spinner_1.colors.muted(`Use ${spinner_1.colors.cyan('--json')} for full AST output or ${spinner_1.colors.cyan('--output <file>')} to write to file.`));
+    }
+    console.log('');
+}
+function printAstSummary(ast) {
+    console.log(spinner_1.colors.bold('Schema AST Summary'));
+    console.log('');
+    if (ast.extensions.length > 0) {
+        console.log(spinner_1.colors.cyan('Extensions:') + ` ${ast.extensions.length}`);
+        for (const ext of ast.extensions) {
+            console.log(`  ${spinner_1.colors.green('•')} ${ext}`);
+        }
+        console.log('');
+    }
+    if (ast.enums.length > 0) {
+        console.log(spinner_1.colors.cyan('Enums:') + ` ${ast.enums.length}`);
+        for (const e of ast.enums) {
+            const tid = e.trackingId ? spinner_1.colors.muted(` [${e.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${e.name}${tid}: (${e.values.join(', ')})`);
+        }
+        console.log('');
+    }
+    if (ast.domains.length > 0) {
+        console.log(spinner_1.colors.cyan('Domains:') + ` ${ast.domains.length}`);
+        for (const d of ast.domains) {
+            const tid = d.trackingId ? spinner_1.colors.muted(` [${d.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${d.name}${tid}: ${d.baseType}`);
+        }
+        console.log('');
+    }
+    if (ast.compositeTypes.length > 0) {
+        console.log(spinner_1.colors.cyan('Composite Types:') + ` ${ast.compositeTypes.length}`);
+        for (const c of ast.compositeTypes) {
+            const tid = c.trackingId ? spinner_1.colors.muted(` [${c.trackingId}]`) : '';
+            const attrs = c.attributes.map(a => a.name).join(', ');
+            console.log(`  ${spinner_1.colors.green('•')} ${c.name}${tid}: (${attrs})`);
+        }
+        console.log('');
+    }
+    if (ast.sequences.length > 0) {
+        console.log(spinner_1.colors.cyan('Sequences:') + ` ${ast.sequences.length}`);
+        for (const s of ast.sequences) {
+            const tid = s.trackingId ? spinner_1.colors.muted(` [${s.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${s.name}${tid}`);
+        }
+        console.log('');
+    }
+    if (ast.tables.length > 0) {
+        console.log(spinner_1.colors.cyan('Tables:') + ` ${ast.tables.length}`);
+        for (const t of ast.tables) {
+            const tid = t.trackingId ? spinner_1.colors.muted(` [${t.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${t.name}${tid}`);
+            console.log(`      Columns: ${t.columns.length}`);
+            for (const col of t.columns.slice(0, 5)) {
+                const colTid = col.trackingId ? spinner_1.colors.muted(` [${col.trackingId}]`) : '';
+                const pk = col.isPrimaryKey ? spinner_1.colors.yellow(' PK') : '';
+                const nullable = col.isNullable ? '' : spinner_1.colors.red(' NOT NULL');
+                console.log(`        - ${col.name}${colTid}: ${col.type}${pk}${nullable}`);
+            }
+            if (t.columns.length > 5) {
+                console.log(`        ${spinner_1.colors.muted(`... and ${t.columns.length - 5} more`)}`);
+            }
+            if (t.indexes.length > 0) {
+                console.log(`      Indexes: ${t.indexes.length}`);
+            }
+            if (t.constraints.length > 0) {
+                console.log(`      Constraints: ${t.constraints.length}`);
+            }
+        }
+        console.log('');
+    }
+    if (ast.views.length > 0) {
+        console.log(spinner_1.colors.cyan('Views:') + ` ${ast.views.length}`);
+        for (const v of ast.views) {
+            const tid = v.trackingId ? spinner_1.colors.muted(` [${v.trackingId}]`) : '';
+            const mat = v.isMaterialized ? spinner_1.colors.yellow(' (materialized)') : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${v.name}${tid}${mat}`);
+        }
+        console.log('');
+    }
+    if (ast.functions.length > 0) {
+        console.log(spinner_1.colors.cyan('Functions:') + ` ${ast.functions.length}`);
+        for (const f of ast.functions) {
+            const tid = f.trackingId ? spinner_1.colors.muted(` [${f.trackingId}]`) : '';
+            const args = f.args.map(a => a.type).join(', ');
+            console.log(`  ${spinner_1.colors.green('•')} ${f.name}${tid}(${args}) -> ${f.returnType}`);
+        }
+        console.log('');
+    }
+    if (ast.triggers.length > 0) {
+        console.log(spinner_1.colors.cyan('Triggers:') + ` ${ast.triggers.length}`);
+        for (const tr of ast.triggers) {
+            const tid = tr.trackingId ? spinner_1.colors.muted(` [${tr.trackingId}]`) : '';
+            console.log(`  ${spinner_1.colors.green('•')} ${tr.name}${tid} on ${tr.table}`);
+        }
+        console.log('');
+    }
+    const total = ast.tables.length + ast.enums.length + ast.views.length +
+        ast.functions.length + ast.triggers.length + ast.sequences.length +
+        ast.domains.length + ast.compositeTypes.length;
+    console.log(spinner_1.colors.bold(`Total: ${total} schema objects`));
+}
+exports.default = schemaAstCommand;

package/dist/cjs/cli/index.cjs

@@ -58,6 +58,7 @@ const tag_1 = require("./commands/tag.cjs");
 const cherry_pick_1 = require("./commands/cherry-pick.cjs");
 const remote_1 = require("./commands/remote.cjs");
 const validate_1 = require("./commands/validate.cjs");
+const schema_ast_1 = require("./commands/schema-ast.cjs");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 function loadEnvFile() {
@@ -168,6 +169,7 @@ Other Commands:
   introspect          Parse database schema
   import <sql-file>   Import SQL file to schema
   export [file]       Export schema to SQL file
+  schema:ast [file]   Convert schema to AST (JSON)
 
 Options:
   --help, -h          Show this help
@@ -359,6 +361,10 @@ async function main() {
             case 'validate':
                 await (0, validate_1.validateCommand)(context);
                 break;
+            case 'schema:ast':
+            case 'ast':
+                await (0, schema_ast_1.schemaAstCommand)(context);
+                break;
             case 'sync':
                 await (0, sync_1.syncCommand)(context);
                 break;