pgpm 0.0.1

package/esm/commands/init/module.js

@@ -0,0 +1,68 @@
+import { LaunchQLPackage, sluggify } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { errors, getGitConfigInfo } from '@launchql/types';
+const log = new Logger('module-init');
+export default async function runModuleSetup(argv, prompter) {
+    const { email, username } = getGitConfigInfo();
+    const { cwd = process.cwd() } = argv;
+    const project = new LaunchQLPackage(cwd);
+    if (!project.workspacePath) {
+        log.error('Not inside a LaunchQL workspace.');
+        throw errors.NOT_IN_WORKSPACE({});
+    }
+    if (!project.isInsideAllowedDirs(cwd) && !project.isInWorkspace()) {
+        log.error('You must be inside one of the workspace packages.');
+        throw errors.NOT_IN_WORKSPACE_MODULE({});
+    }
+    const availExtensions = project.getAvailableModules();
+    const moduleQuestions = [
+        {
+            name: 'MODULENAME',
+            message: 'Enter the module name',
+            required: true,
+            type: 'text',
+        },
+        {
+            name: 'extensions',
+            message: 'Which extensions?',
+            options: availExtensions,
+            type: 'checkbox',
+            allowCustomOptions: true,
+            required: true,
+        },
+    ];
+    const answers = await prompter.prompt(argv, moduleQuestions);
+    const modName = sluggify(answers.MODULENAME);
+    const extensions = answers.extensions
+        .filter((opt) => opt.selected)
+        .map((opt) => opt.name);
+    // Determine template source
+    let templateSource;
+    if (argv.repo) {
+        templateSource = {
+            type: 'github',
+            path: argv.repo,
+            branch: argv.fromBranch
+        };
+        log.info(`Loading templates from GitHub repository: ${argv.repo}`);
+    }
+    else if (argv.templatePath) {
+        templateSource = {
+            type: 'local',
+            path: argv.templatePath
+        };
+        log.info(`Loading templates from local path: ${argv.templatePath}`);
+    }
+    project.initModule({
+        ...argv,
+        ...answers,
+        name: modName,
+        // @ts-ignore
+        USERFULLNAME: username,
+        USEREMAIL: email,
+        extensions,
+        templateSource
+    });
+    log.success(`Initialized module: ${modName}`);
+    return { ...argv, ...answers };
+}

package/esm/commands/init/workspace.js

@@ -0,0 +1,46 @@
+import { sluggify } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+// @ts-ignore - TypeScript module resolution issue with @launchql/templatizer
+import { workspaceTemplate, writeRenderedTemplates, loadTemplates } from '@launchql/templatizer';
+import { mkdirSync } from 'fs';
+import path from 'path';
+const log = new Logger('workspace-init');
+export default async function runWorkspaceSetup(argv, prompter) {
+    const workspaceQuestions = [
+        {
+            name: 'name',
+            message: 'Enter workspace name',
+            required: true,
+            type: 'text',
+        }
+    ];
+    const answers = await prompter.prompt(argv, workspaceQuestions);
+    const { cwd } = argv;
+    const targetPath = path.join(cwd, sluggify(answers.name));
+    mkdirSync(targetPath, { recursive: true });
+    log.success(`Created workspace directory: ${targetPath}`);
+    // Determine template source
+    let templates = workspaceTemplate;
+    if (argv.repo) {
+        const source = {
+            type: 'github',
+            path: argv.repo,
+            branch: argv.fromBranch
+        };
+        log.info(`Loading templates from GitHub repository: ${argv.repo}`);
+        const compiledTemplates = loadTemplates(source, 'workspace');
+        templates = compiledTemplates.map((t) => t.render);
+    }
+    else if (argv.templatePath) {
+        const source = {
+            type: 'local',
+            path: argv.templatePath
+        };
+        log.info(`Loading templates from local path: ${argv.templatePath}`);
+        const compiledTemplates = loadTemplates(source, 'workspace');
+        templates = compiledTemplates.map((t) => t.render);
+    }
+    writeRenderedTemplates(templates, targetPath, { ...argv, ...answers });
+    log.success('Workspace templates rendered.');
+    return { ...argv, ...answers, cwd: targetPath };
+}

package/esm/commands/install.js

@@ -0,0 +1,35 @@
+import { LaunchQLPackage } from '@launchql/core';
+const installUsageText = `
+LaunchQL Install Command:
+
+  lql install <package>...
+
+  Install LaunchQL modules into current module.
+
+Arguments:
+  package                 One or more package names to install
+
+Options:
+  --help, -h              Show this help message
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql install @launchql/base32                    Install single package
+  lql install @launchql/base32 @launchql/utils   Install multiple packages
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(installUsageText);
+        process.exit(0);
+    }
+    const { cwd = process.cwd() } = argv;
+    const project = new LaunchQLPackage(cwd);
+    if (!project.isInModule()) {
+        throw new Error('You must run this command inside a LaunchQL module.');
+    }
+    if (argv._.length === 0) {
+        throw new Error('You must provide a package name to install, e.g. `@launchql/base32`');
+    }
+    await project.installModules(...argv._);
+};

package/esm/commands/kill.js

@@ -0,0 +1,105 @@
+import { Logger } from '@launchql/logger';
+import { getPgPool } from 'pg-cache';
+const log = new Logger('db-kill');
+const killUsageText = `
+LaunchQL Kill Command:
+
+  lql kill [OPTIONS]
+
+  Terminate database connections and optionally drop databases.
+
+Options:
+  --help, -h              Show this help message
+  --drop                  Drop databases after killing connections (default: true)
+  --no-drop               Only kill connections, don't drop databases
+  --pattern <pattern>     Pattern to match database names (supports SQL LIKE syntax)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql kill                Kill connections and drop selected databases (interactive)
+  lql kill --no-drop      Only kill connections, preserve databases (interactive)
+  lql kill --pattern test_%   Kill connections to databases matching 'test_%' pattern
+  lql kill --pattern %dev --no-drop  Kill connections to databases ending with 'dev' but don't drop
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(killUsageText);
+        process.exit(0);
+    }
+    const db = await getPgPool({
+        database: 'postgres'
+    });
+    let selectedDbNames;
+    if (argv.pattern) {
+        // Pattern mode: automatically find databases matching the pattern
+        const databasesResult = await db.query(`
+      SELECT datname FROM pg_catalog.pg_database
+      WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_' AND datname LIKE $1;
+    `, [argv.pattern]);
+        if (!databasesResult.rows.length) {
+            log.info(`ℹ️  No databases found matching pattern "${argv.pattern}". Exiting.`);
+            return;
+        }
+        selectedDbNames = databasesResult.rows.map(row => row.datname);
+        log.info(`🎯 Found ${selectedDbNames.length} database(s) matching pattern "${argv.pattern}": ${selectedDbNames.join(', ')}`);
+    }
+    else {
+        // Interactive mode: prompt user to select databases
+        const databasesResult = await db.query(`
+      SELECT datname FROM pg_catalog.pg_database
+      WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_';
+    `);
+        if (!databasesResult.rows.length) {
+            log.info('ℹ️  No databases found to process. Exiting.');
+            return;
+        }
+        let databases;
+        ({ databases } = await prompter.prompt(argv, [
+            {
+                type: 'checkbox',
+                name: 'databases',
+                message: 'Select database(s) to terminate connections and optionally drop',
+                options: databasesResult.rows.map(row => row.datname),
+                required: true
+            }
+        ]));
+        selectedDbNames = databases.filter(d => d.selected).map(d => d.value);
+    }
+    const actionText = argv.drop === false ? 'kill connections to' : 'kill connections and DROP';
+    const patternText = argv.pattern ? ` (matched by pattern "${argv.pattern}")` : '';
+    const { yes } = await prompter.prompt(argv, [
+        {
+            type: 'confirm',
+            name: 'yes',
+            message: `Are you sure you want to ${actionText}: ${selectedDbNames.join(', ')}${patternText}?`,
+            default: false
+        }
+    ]);
+    if (!yes) {
+        log.info('❌ Aborted. No actions were taken.');
+        return;
+    }
+    for (const dbname of selectedDbNames) {
+        const killResult = await db.query(`
+      SELECT pg_terminate_backend(pid)
+      FROM pg_stat_activity
+      WHERE datname = $1 AND pid <> pg_backend_pid();
+      `, [dbname]);
+        log.warn(`💀 Terminated ${killResult.rowCount} connection(s) to "${dbname}".`);
+        if (argv.drop === false) {
+            log.info(`⚠️  Skipping DROP for "${dbname}" due to --no-drop flag.`);
+            continue;
+        }
+        try {
+            await db.query(`DROP DATABASE "${dbname}";`);
+            log.success(`🗑️  Dropped database "${dbname}" successfully.`);
+        }
+        catch (err) {
+            log.error(`❌ Failed to drop "${dbname}": ${err.message}`);
+        }
+    }
+    log.success('✅ Done processing databases.');
+};

package/esm/commands/migrate/deps.js

@@ -0,0 +1,184 @@
+import { LaunchQLMigrate } from '@launchql/core';
+import { parsePlanFile } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getPgEnvOptions } from 'pg-env';
+import { getTargetDatabase } from '../../utils/database';
+const log = new Logger('migrate-deps');
+export default async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = join(cwd, 'launchql.plan');
+    if (!existsSync(planPath)) {
+        log.error(`No launchql.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get specific change to analyze
+    let changeName = argv._?.[0] || argv.change;
+    const planResult = parsePlanFile(planPath);
+    if (!planResult.data || planResult.errors.length > 0) {
+        log.error('Failed to parse plan file:', planResult.errors);
+        process.exit(1);
+    }
+    const plan = planResult.data;
+    const allChanges = plan.changes;
+    // If no change specified, prompt
+    if (!changeName && !argv.all) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'change',
+                message: 'Which change do you want to analyze?',
+                options: allChanges.map(c => ({
+                    name: c.name,
+                    value: c.name,
+                    description: c.dependencies.length > 0 ? `Depends on: ${c.dependencies.join(', ')}` : 'No dependencies'
+                }))
+            }
+        ]);
+        changeName = answer.change;
+    }
+    try {
+        if (argv.all) {
+            // Show dependency graph for all changes
+            console.log('\n🔗 Dependency Graph\n');
+            console.log(`Package: ${plan.package}`);
+            console.log(`Total Changes: ${allChanges.length}\n`);
+            // Build dependency tree
+            const dependencyTree = buildDependencyTree(allChanges);
+            // Show changes with no dependencies first (roots)
+            const roots = allChanges.filter(c => c.dependencies.length === 0);
+            console.log('📌 Root Changes (no dependencies):\n');
+            roots.forEach(change => {
+                console.log(`  • ${change.name}`);
+                showDependents(change.name, dependencyTree, '    ');
+            });
+            // Show orphaned changes (have dependencies but aren't depended on)
+            const orphans = allChanges.filter(c => c.dependencies.length > 0 &&
+                !allChanges.some(other => other.dependencies.includes(c.name)));
+            if (orphans.length > 0) {
+                console.log('\n🔸 Leaf Changes (not depended on by others):\n');
+                orphans.forEach(change => {
+                    console.log(`  • ${change.name} → [${change.dependencies.join(', ')}]`);
+                });
+            }
+        }
+        else {
+            // Show dependencies for specific change
+            const change = allChanges.find(c => c.name === changeName);
+            if (!change) {
+                log.error(`Change '${changeName}' not found in plan file`);
+                process.exit(1);
+            }
+            console.log(`\n🔍 Dependency Analysis: ${changeName}\n`);
+            // Direct dependencies
+            if (change.dependencies.length > 0) {
+                console.log('📥 Direct Dependencies:');
+                change.dependencies.forEach(dep => {
+                    console.log(`  • ${dep}`);
+                });
+            }
+            else {
+                console.log('📥 Direct Dependencies: None');
+            }
+            // All dependencies (recursive)
+            const allDeps = getAllDependencies(change.name, allChanges);
+            if (allDeps.size > 0) {
+                console.log(`\n📦 All Dependencies (${allDeps.size} total):`);
+                Array.from(allDeps).forEach(dep => {
+                    console.log(`  • ${dep}`);
+                });
+            }
+            // Dependents (what depends on this)
+            const dependents = allChanges.filter(c => c.dependencies.includes(changeName));
+            if (dependents.length > 0) {
+                console.log(`\n📤 Depended on by (${dependents.length} changes):`);
+                dependents.forEach(dep => {
+                    console.log(`  • ${dep.name}`);
+                });
+            }
+            else {
+                console.log('\n📤 Depended on by: None');
+            }
+            // Check deployment status if connected to database
+            const pgEnv = getPgEnvOptions();
+            const targetDatabase = await getTargetDatabase(argv, prompter, {
+                message: 'Select database to check deployment status'
+            });
+            const client = new LaunchQLMigrate({
+                host: pgEnv.host,
+                port: pgEnv.port,
+                user: pgEnv.user,
+                password: pgEnv.password,
+                database: pgEnv.database
+            });
+            try {
+                const deployedChanges = await client.getDeployedChanges(targetDatabase, plan.package);
+                const deployedMap = new Map(deployedChanges.map(c => [c.change_name, c]));
+                console.log('\n📊 Deployment Status:');
+                // Check if this change is deployed
+                const isDeployed = deployedMap.has(changeName);
+                console.log(`  This change: ${isDeployed ? '✅ Deployed' : '⏳ Not deployed'}`);
+                // Check dependencies
+                const undeployedDeps = Array.from(allDeps).filter(dep => !deployedMap.has(dep));
+                if (undeployedDeps.length > 0) {
+                    console.log(`  ⚠️  Undeployed dependencies: ${undeployedDeps.join(', ')}`);
+                }
+                else if (allDeps.size > 0) {
+                    console.log('  ✅ All dependencies deployed');
+                }
+                // Check dependents
+                const deployedDependents = dependents.filter(d => deployedMap.has(d.name));
+                if (deployedDependents.length > 0) {
+                    console.log(`  ⚠️  Deployed dependents: ${deployedDependents.map(d => d.name).join(', ')}`);
+                }
+            }
+            catch (dbError) {
+                // Database connection optional for dependency analysis
+                log.debug('Could not connect to database for deployment status');
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to analyze dependencies:', error);
+        process.exit(1);
+    }
+};
+function buildDependencyTree(changes) {
+    const tree = new Map();
+    changes.forEach(change => {
+        change.dependencies.forEach((dep) => {
+            if (!tree.has(dep)) {
+                tree.set(dep, []);
+            }
+            tree.get(dep).push(change.name);
+        });
+    });
+    return tree;
+}
+function showDependents(changeName, tree, indent) {
+    const dependents = tree.get(changeName) || [];
+    dependents.forEach(dep => {
+        console.log(`${indent}└─ ${dep}`);
+        showDependents(dep, tree, indent + '   ');
+    });
+}
+function getAllDependencies(changeName, changes) {
+    const deps = new Set();
+    const change = changes.find(c => c.name === changeName);
+    if (!change)
+        return deps;
+    function addDeps(change) {
+        change.dependencies.forEach((dep) => {
+            if (!deps.has(dep)) {
+                deps.add(dep);
+                const depChange = changes.find(c => c.name === dep);
+                if (depChange) {
+                    addDeps(depChange);
+                }
+            }
+        });
+    }
+    addDeps(change);
+    return deps;
+}

package/esm/commands/migrate/init.js

@@ -0,0 +1,63 @@
+import { LaunchQLMigrate } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { getPgEnvOptions } from 'pg-env';
+import { getTargetDatabase } from '../../utils/database';
+const log = new Logger('migrate-init');
+export default async (argv, prompter, _options) => {
+    const pgEnv = getPgEnvOptions();
+    // Get target database
+    const database = await getTargetDatabase(argv, prompter, {
+        message: 'Select database to initialize migration tracking'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: `Initialize LaunchQL migration schema in database "${database}"?`,
+            required: true
+        }
+    ];
+    const { yes } = await prompter.prompt(argv, questions);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return;
+    }
+    log.info(`Initializing migration schema in database ${database}...`);
+    const config = {
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database
+    };
+    const client = new LaunchQLMigrate(config);
+    try {
+        await client.initialize();
+        log.success('Migration schema initialized successfully.');
+        // Check if there's an existing Sqitch deployment to import
+        const hasSquitch = await client.hasSqitchTables();
+        if (hasSquitch) {
+            const { importSquitch } = await prompter.prompt(argv, [
+                {
+                    name: 'importSquitch',
+                    type: 'confirm',
+                    message: 'Existing Sqitch deployment detected. Import it?',
+                    required: true
+                }
+            ]);
+            if (importSquitch) {
+                log.info('Importing Sqitch deployment history...');
+                await client.importFromSqitch();
+                log.success('Sqitch deployment imported successfully.');
+            }
+        }
+    }
+    catch (error) {
+        log.error(`Failed to initialize migration schema: ${error instanceof Error ? error.message : error}`);
+        throw error;
+    }
+    finally {
+        await client.close();
+    }
+    return argv;
+};

package/esm/commands/migrate/list.js

@@ -0,0 +1,83 @@
+import { LaunchQLMigrate } from '@launchql/core';
+import { parsePlanFile } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getPgEnvOptions } from 'pg-env';
+import { getTargetDatabase } from '../../utils/database';
+const log = new Logger('migrate-list');
+export default async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = join(cwd, 'launchql.plan');
+    if (!existsSync(planPath)) {
+        log.error(`No launchql.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get database configuration
+    const pgEnv = getPgEnvOptions();
+    const targetDatabase = await getTargetDatabase(argv, prompter, {
+        message: 'Select database to list migrations'
+    });
+    const client = new LaunchQLMigrate({
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database: pgEnv.database
+    });
+    try {
+        // Get all changes from plan file
+        const planResult = parsePlanFile(planPath);
+        if (!planResult.data || planResult.errors.length > 0) {
+            log.error('Failed to parse plan file:', planResult.errors);
+            process.exit(1);
+        }
+        const plan = planResult.data;
+        const allChanges = plan.changes;
+        // Get deployed changes from database
+        const deployedChanges = await client.getDeployedChanges(targetDatabase, plan.package);
+        console.log('\n📋 All Changes\n');
+        console.log(`Package: ${plan.package}`);
+        console.log(`Total Changes: ${allChanges.length}`);
+        console.log(`Deployed: ${deployedChanges.length}`);
+        console.log(`Pending: ${allChanges.length - deployedChanges.length}\n`);
+        // Create a map for quick lookup
+        const deployedMap = new Map(deployedChanges.map(c => [c.change_name, c]));
+        // List all changes with their status
+        const showAll = argv.all || allChanges.length <= 20;
+        const changesToShow = showAll ? allChanges : allChanges.slice(0, 20);
+        console.log('Status  Change Name                    Dependencies');
+        console.log('------  -----------------------------  --------------------------------');
+        changesToShow.forEach(change => {
+            const deployed = deployedMap.get(change.name);
+            const status = deployed ? '✅' : '⏳';
+            const deps = change.dependencies.length > 0 ? change.dependencies.join(', ') : '-';
+            const depsDisplay = deps.length > 30 ? deps.substring(0, 27) + '...' : deps;
+            console.log(`${status}      ${change.name.padEnd(30)} ${depsDisplay}`);
+        });
+        if (!showAll && allChanges.length > 20) {
+            console.log(`\n... and ${allChanges.length - 20} more changes. Use --all to see all changes.`);
+        }
+        // Show summary by status
+        if (argv.summary !== false) {
+            console.log('\n📊 Summary by Status:\n');
+            const pending = allChanges.filter(c => !deployedMap.has(c.name));
+            const deployed = allChanges.filter(c => deployedMap.has(c.name));
+            console.log(`✅ Deployed: ${deployed.length}`);
+            console.log(`⏳ Pending:  ${pending.length}`);
+            // Show deployment timeline
+            if (deployedChanges.length > 0) {
+                const sortedDeployed = [...deployedChanges].sort((a, b) => new Date(a.deployed_at).getTime() - new Date(b.deployed_at).getTime());
+                const firstDeploy = new Date(sortedDeployed[0].deployed_at);
+                const lastDeploy = new Date(sortedDeployed[sortedDeployed.length - 1].deployed_at);
+                console.log(`\n📅 Deployment Timeline:`);
+                console.log(`   First: ${firstDeploy.toLocaleString()}`);
+                console.log(`   Last:  ${lastDeploy.toLocaleString()}`);
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to list changes:', error);
+        process.exit(1);
+    }
+};

package/esm/commands/migrate/status.js

@@ -0,0 +1,92 @@
+import { LaunchQLMigrate } from '@launchql/core';
+import { parsePlanFile } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getPgEnvOptions } from 'pg-env';
+import { getTargetDatabase } from '../../utils/database';
+const log = new Logger('migrate-status');
+export default async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = join(cwd, 'launchql.plan');
+    if (!existsSync(planPath)) {
+        log.error(`No launchql.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get database configuration
+    const pgEnv = getPgEnvOptions();
+    const targetDatabase = await getTargetDatabase(argv, prompter, {
+        message: 'Select database to check migration status'
+    });
+    const client = new LaunchQLMigrate({
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database: pgEnv.database
+    });
+    try {
+        // Parse plan file to get package name
+        const planResult = parsePlanFile(planPath);
+        if (!planResult.data || planResult.errors.length > 0) {
+            log.error('Failed to parse plan file:', planResult.errors);
+            process.exit(1);
+        }
+        const plan = planResult.data;
+        // Switch to target database
+        const targetClient = new LaunchQLMigrate({
+            host: pgEnv.host,
+            port: pgEnv.port,
+            user: pgEnv.user,
+            password: pgEnv.password,
+            database: targetDatabase
+        });
+        const statusResults = await targetClient.status(plan.package);
+        console.log('\n📊 Migration Status\n');
+        console.log(`Database: ${targetDatabase}`);
+        if (statusResults.length > 0) {
+            const status = statusResults[0];
+            console.log(`Package: ${status.package}`);
+            console.log(`Total Deployed: ${status.totalDeployed}`);
+            if (status.lastChange) {
+                console.log(`Last Change: ${status.lastChange}`);
+                console.log(`Last Deployed: ${status.lastDeployed.toLocaleString()}`);
+            }
+            else {
+                console.log('No changes deployed yet');
+            }
+        }
+        else {
+            console.log(`Package: ${plan.package}`);
+            console.log('No deployment history found');
+        }
+        // Show recent changes
+        const recentChanges = await targetClient.getRecentChanges(targetDatabase, 5);
+        if (recentChanges.length > 0) {
+            console.log('\n📋 Recent Changes:\n');
+            recentChanges.forEach((change) => {
+                const status = change.deployed_at ? '✅' : '⏳';
+                const date = change.deployed_at ? new Date(change.deployed_at).toLocaleString() : 'Not deployed';
+                console.log(`${status} ${change.change_name.padEnd(30)} ${date}`);
+            });
+        }
+        // Show pending changes
+        const pendingChanges = await targetClient.getPendingChanges(planPath, targetDatabase);
+        if (pendingChanges.length > 0) {
+            console.log(`\n⏳ Pending Changes: ${pendingChanges.length}\n`);
+            pendingChanges.slice(0, 5).forEach((change) => {
+                console.log(`   - ${change}`);
+            });
+            if (pendingChanges.length > 5) {
+                console.log(`   ... and ${pendingChanges.length - 5} more`);
+            }
+        }
+        else {
+            console.log('\n✅ All changes deployed');
+        }
+    }
+    catch (error) {
+        log.error('Failed to get migration status:', error);
+        process.exit(1);
+    }
+};