@developer-ayushanand/dbgit 0.1.0-beta.1

package/dist/commands/commit.js

@@ -0,0 +1,86 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import crypto from 'crypto';
+import { isInitialized, getHead, loadSnapshot, saveSnapshot, saveCommit, saveBranch, loadBranch, setHead, loadCommit } from '../core/store.js';
+import { createPool, getConnectionConfig } from '../core/connector.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import { diffSnapshots } from '../core/differ.js';
+import { loadIgnoreList } from '../core/ignore.js';
+export async function commitCommand(options) {
+    if (!isInitialized()) {
+        console.error(chalk.red("Not a DBGit repository. Run 'dbgit init' first."));
+        process.exit(1);
+    }
+    const head = getHead();
+    if (head.branch === null) {
+        console.error(chalk.red("Cannot commit in detached HEAD state. Run 'dbgit checkout <branch>' first."));
+        process.exit(1);
+    }
+    const ignoreList = loadIgnoreList();
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    const spinner = ora('Capturing schema snapshot...').start();
+    try {
+        const newSnapshot = await captureSnapshot(pool, ignoreList);
+        let oldSnapshot = { tables: {}, capturedAt: '', schemaHash: '' };
+        if (head.commit) {
+            const lastCommit = loadCommit(head.commit);
+            oldSnapshot = loadSnapshot(lastCommit.snapshotHash);
+        }
+        const changeset = diffSnapshots(oldSnapshot, newSnapshot);
+        if (changeset.changes.length === 0) {
+            spinner.stop();
+            console.log(chalk.gray("Nothing to commit."));
+            await pool.end();
+            return;
+        }
+        spinner.stop();
+        if (changeset.hasDestructive) {
+            const destructiveChanges = changeset.changes.filter(c => c.isDestructive);
+            console.warn(chalk.yellow('\nWarning: Destructive changes detected:'));
+            destructiveChanges.forEach(c => {
+                console.warn(chalk.red(`  - ${c.type}: ${c.table} ${c.objectName || ''}`));
+            });
+            const response = await prompts({
+                type: 'confirm',
+                name: 'value',
+                message: 'Continue?',
+                initial: false
+            });
+            if (!response.value) {
+                console.log(chalk.gray('Commit aborted.'));
+                await pool.end();
+                return;
+            }
+        }
+        const timestamp = new Date().toISOString();
+        const commitHash = crypto.createHash('sha256').update(options.message + timestamp + newSnapshot.schemaHash).digest('hex').substring(0, 7);
+        const commit = {
+            commitHash,
+            snapshotHash: newSnapshot.schemaHash,
+            parent: head.commit,
+            timestamp,
+            message: options.message,
+            branch: head.branch,
+            schemaHash: newSnapshot.schemaHash
+        };
+        saveSnapshot(newSnapshot.schemaHash, newSnapshot);
+        saveCommit(commit);
+        const branch = loadBranch(head.branch);
+        branch.headCommit = commitHash;
+        saveBranch(branch);
+        setHead({ ...head, commit: commitHash });
+        console.log(chalk.green(`\n✓ Commit ${commitHash} saved.`));
+        const tableCount = Object.keys(newSnapshot.tables).length;
+        const colCount = Object.values(newSnapshot.tables).reduce((sum, t) => sum + t.columns.length, 0);
+        const idxCount = Object.values(newSnapshot.tables).reduce((sum, t) => sum + t.indexes.length, 0);
+        console.log(chalk.gray(`${tableCount} tables · ${colCount} columns · ${idxCount} indexes`));
+        console.log(chalk.blue(`Branch: ${head.branch}`));
+        await pool.end();
+    }
+    catch (e) {
+        spinner.fail(chalk.red(`✗ Commit failed: ${e.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/diff.d.ts

@@ -0,0 +1 @@
+export declare function diffCommand(): Promise<void>;

package/dist/commands/diff.js

@@ -0,0 +1,91 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getHead, loadCommit, loadSnapshot } from '../core/store.js';
+import { createPool, getConnectionConfig, query } from '../core/connector.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import { diffSnapshots } from '../core/differ.js';
+import { loadIgnoreList } from '../core/ignore.js';
+import { ChangeType } from '../types/changes.js';
+export async function diffCommand() {
+    const head = getHead();
+    const ignoreList = loadIgnoreList();
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    const spinner = ora('Computing diff...').start();
+    try {
+        const liveSnapshot = await captureSnapshot(pool, ignoreList);
+        let oldSnapshot = { tables: {}, capturedAt: '', schemaHash: '' };
+        if (head.commit) {
+            const lastCommit = loadCommit(head.commit);
+            oldSnapshot = loadSnapshot(lastCommit.snapshotHash);
+        }
+        const changeset = diffSnapshots(oldSnapshot, liveSnapshot);
+        spinner.stop();
+        if (changeset.changes.length === 0) {
+            console.log(chalk.gray("No changes since last commit."));
+            await pool.end();
+            return;
+        }
+        // Stable sort by table name then change type
+        const sortedChanges = [...changeset.changes].sort((a, b) => {
+            if (a.table !== b.table)
+                return a.table.localeCompare(b.table);
+            return a.type.localeCompare(b.type);
+        });
+        for (const change of sortedChanges) {
+            let impact = '';
+            if (change.type === ChangeType.DROP_TABLE) {
+                const rows = await query(pool, `SELECT count(*) FROM ${change.table}`);
+                impact = chalk.gray(` (${rows[0].count} rows)`);
+            }
+            else if (change.type === ChangeType.DROP_COLUMN) {
+                const rows = await query(pool, `SELECT count(*) FROM ${change.table} WHERE ${change.objectName} IS NOT NULL`);
+                impact = chalk.gray(` (${rows[0].count} non-null rows)`);
+            }
+            switch (change.type) {
+                case ChangeType.ADD_TABLE:
+                    console.log(chalk.green(`  + table  ${change.table}`));
+                    break;
+                case ChangeType.DROP_TABLE:
+                    console.log(chalk.red(`  - table  ${change.table}${impact}`));
+                    break;
+                case ChangeType.ADD_COLUMN:
+                    console.log(chalk.green(`  + column ${change.table}.${change.objectName} ${change.after.type}`));
+                    break;
+                case ChangeType.DROP_COLUMN:
+                    console.log(chalk.red(`  - column ${change.table}.${change.objectName}${impact}`));
+                    break;
+                case ChangeType.MODIFY_COLUMN:
+                    console.log(chalk.yellow(`  ~ column ${change.table}.${change.objectName} ${change.before.type} → ${change.after.type}`));
+                    break;
+                case ChangeType.ADD_INDEX:
+                    console.log(chalk.green(`  + index  ${change.objectName} on ${change.table}`));
+                    break;
+                case ChangeType.DROP_INDEX:
+                    console.log(chalk.red(`  - index  ${change.objectName} on ${change.table}`));
+                    break;
+                case ChangeType.ADD_CONSTRAINT:
+                    console.log(chalk.green(`  + constr ${change.objectName} on ${change.table}`));
+                    break;
+                case ChangeType.DROP_CONSTRAINT:
+                    console.log(chalk.red(`  - constr ${change.objectName} on ${change.table}`));
+                    break;
+                case ChangeType.ADD_FOREIGN_KEY:
+                    console.log(chalk.green(`  + fk     ${change.objectName} on ${change.table}`));
+                    break;
+                case ChangeType.DROP_FOREIGN_KEY:
+                    console.log(chalk.red(`  - fk     ${change.objectName} on ${change.table}`));
+                    break;
+                default:
+                    console.log(chalk.blue(`  * ${change.type}: ${change.table} ${change.objectName || ''}`));
+            }
+        }
+        await pool.end();
+    }
+    catch (e) {
+        if (spinner.isSpinning)
+            spinner.stop();
+        console.error(chalk.red(`✗ Diff failed: ${e.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctorCommand(): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,115 @@
+import chalk from 'chalk';
+import boxen from 'boxen';
+import { isInitialized, getHead, loadCommit, loadSnapshot, loadConfig } from '../core/store.js';
+import { createPool, getConnectionConfig, query } from '../core/connector.js';
+import { listBackups } from '../core/backup.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import { diffSnapshots } from '../core/differ.js';
+import { computeSchemaHash } from '../core/validator.js';
+import { loadIgnoreList } from '../core/ignore.js';
+export async function doctorCommand() {
+    const repoInit = isInitialized();
+    if (!repoInit) {
+        console.log(chalk.red('\n✗ DBGit is not initialized in this directory.'));
+        console.log(chalk.yellow('Recommendation: Run \'dbgit init\' to initialize the repository.'));
+        process.exit(1);
+    }
+    let report = '';
+    report += `${chalk.green('✓')} Repository initialized\n`;
+    const ignoreList = loadIgnoreList();
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    let dbOk = false;
+    try {
+        await pool.query('SELECT 1');
+        report += `${chalk.green('✓')} Database connection: OK\n`;
+        dbOk = true;
+    }
+    catch (e) {
+        report += `${chalk.red('✗')} Database connection: FAILED (${e.message})\n`;
+    }
+    let riskScore = 0;
+    const head = getHead();
+    const dbConfig = loadConfig();
+    let drift = false;
+    let softDeletedCount = 0;
+    let hasPgDump = true; // We'll check this by trying to run it later if needed, but for now assume true
+    if (dbOk) {
+        const liveHash = await computeSchemaHash(pool, ignoreList);
+        if (head.commit) {
+            const lastCommit = loadCommit(head.commit);
+            if (liveHash !== lastCommit.schemaHash) {
+                drift = true;
+                riskScore += 40;
+            }
+        }
+        report += `Schema Drift:      ${drift ? chalk.red('DETECTED') : chalk.green('None')}\n`;
+        const liveSnapshot = await captureSnapshot(pool, ignoreList);
+        let oldSnapshot = { tables: {}, capturedAt: '', schemaHash: '' };
+        if (head.commit) {
+            oldSnapshot = loadSnapshot(loadCommit(head.commit).snapshotHash);
+        }
+        const changeset = diffSnapshots(oldSnapshot, liveSnapshot);
+        report += `Untracked Changes: ${changeset.changes.length} changes\n`;
+        if (changeset.changes.some(c => c.isDestructive)) {
+            riskScore += 30;
+        }
+        const softDeletedTables = await query(pool, "SELECT table_name FROM information_schema.tables WHERE table_name LIKE '_dbgit_deleted_%'");
+        const softDeletedColumns = await query(pool, "SELECT column_name FROM information_schema.columns WHERE column_name LIKE '_dbgit_deleted_%'");
+        softDeletedCount = softDeletedTables.length + softDeletedColumns.length;
+        report += `Soft Deleted:      ${softDeletedCount > 0 ? chalk.yellow(softDeletedCount + ' objects') : chalk.green('None')}\n`;
+    }
+    const backups = listBackups();
+    report += `Backups:           ${backups.length > 0 ? chalk.green('Available (' + backups.length + ')') : chalk.yellow('Missing')}\n`;
+    if (backups.length === 0)
+        riskScore += 20;
+    if (head.commit) {
+        const lastCommit = loadCommit(head.commit);
+        const lastCommitDate = new Date(lastCommit.timestamp);
+        const daysSinceLastCommit = (Date.now() - lastCommitDate.getTime()) / (1000 * 60 * 60 * 24);
+        report += `Last Commit:       ${chalk.blue(lastCommit.commitHash)} — ${lastCommit.message} (${Math.floor(daysSinceLastCommit)} days ago)\n`;
+        if (daysSinceLastCommit > 7)
+            riskScore += 10;
+    }
+    let safety = 'High';
+    if (riskScore > 30)
+        safety = 'Medium';
+    if (riskScore > 60)
+        safety = 'Low';
+    report += `Rollback Safety:   ${safety === 'High' ? chalk.green(safety) : safety === 'Medium' ? chalk.yellow(safety) : chalk.red(safety)}\n`;
+    report += `Risk Score:        ${riskScore}/100\n`;
+    console.log(boxen(report.trim(), { padding: 1, borderColor: 'cyan', title: 'DBGit Doctor Report' }));
+    console.log(chalk.bold('\nℹ Recommendations:'));
+    const recommendations = [];
+    if (drift) {
+        recommendations.push(chalk.yellow('- Schema Drift Detected: Run \'dbgit commit\' to capture current schema changes and resolve drift.'));
+    }
+    if (dbOk && !drift && head.commit) {
+        // Check if there are untracked changes that AREN'T drift (this shouldn't happen if drift check is correct, but good for clarity)
+    }
+    if (backups.length === 0) {
+        recommendations.push(chalk.yellow('- Missing Backups: Run \'dbgit rollback --safe\' on your next rollback to enable backup and restore support.'));
+    }
+    if (softDeletedCount > 0) {
+        recommendations.push(chalk.yellow(`- Soft Deleted Objects Exist: Run 'dbgit purge' to permanently remove ${softDeletedCount} archived objects.`));
+    }
+    if (riskScore > 50) {
+        recommendations.push(chalk.red('- Rollback Risk: High risk detected. Always use --safe before destructive rollbacks.'));
+    }
+    // Check for pg_dump availability
+    try {
+        const { execSync } = await import('child_process');
+        execSync('pg_dump --version', { stdio: 'ignore' });
+    }
+    catch (e) {
+        recommendations.push(chalk.red('- Missing pg_dump: Install PostgreSQL client tools to enable safe rollback and backup functionality.'));
+    }
+    if (recommendations.length === 0) {
+        console.log(chalk.green('  ✓ Your repository is in great shape!'));
+    }
+    else {
+        recommendations.forEach(rec => console.log('  ' + rec));
+    }
+    console.log('');
+    await pool.end();
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function initCommand(options: {
+    mode: string;
+    recover: boolean;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,84 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { initStore, isInitialized, setHead, saveBranch, saveConfig, saveCommit, saveSnapshot } from '../core/store.js';
+import { createPool, getConnectionConfig } from '../core/connector.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import crypto from 'crypto';
+export async function initCommand(options) {
+    if (isInitialized() && !options.recover) {
+        console.error(chalk.red('Error: .dbgit/ already exists. Use --recover to reconstruct state.'));
+        process.exit(1);
+    }
+    initStore();
+    const config = getConnectionConfig();
+    const dbConfig = {
+        DBGIT_MODE: options.mode,
+    };
+    if (config.connectionString) {
+        dbConfig.databaseUrl = config.connectionString;
+    }
+    else {
+        dbConfig.DBGIT_HOST = config.host || 'localhost';
+        dbConfig.DBGIT_PORT = config.port?.toString() || '5432';
+        dbConfig.DBGIT_DATABASE = config.database || '';
+        dbConfig.DBGIT_USER = config.user || '';
+        dbConfig.DBGIT_SSL = config.ssl?.toString() || 'false';
+        if (config.password) {
+            dbConfig.DBGIT_PASSWORD = config.password;
+        }
+    }
+    saveConfig(dbConfig);
+    if (options.recover) {
+        const spinner = ora('Recovering state from live database...').start();
+        try {
+            const pool = createPool(config);
+            const snapshot = await captureSnapshot(pool, []);
+            const timestamp = new Date().toISOString();
+            const message = "Recovered initial state";
+            const commitHash = crypto.createHash('sha256').update(message + timestamp + snapshot.schemaHash).digest('hex').substring(0, 7);
+            const commit = {
+                commitHash,
+                snapshotHash: snapshot.schemaHash,
+                parent: null,
+                timestamp,
+                message,
+                branch: 'main',
+                schemaHash: snapshot.schemaHash
+            };
+            saveSnapshot(snapshot.schemaHash, snapshot);
+            saveCommit(commit);
+            saveBranch({
+                name: 'main',
+                headCommit: commitHash,
+                createdAt: timestamp,
+                basedOn: null
+            });
+            setHead({ branch: 'main', commit: commitHash });
+            spinner.succeed(chalk.green('✓ Recovered DBGit state from live database.'));
+            await pool.end();
+        }
+        catch (e) {
+            spinner.fail(chalk.red(`✗ Recovery failed: ${e.message}`));
+            process.exit(1);
+        }
+    }
+    else {
+        saveBranch({
+            name: 'main',
+            headCommit: '',
+            createdAt: new Date().toISOString(),
+            basedOn: null
+        });
+        setHead({ branch: 'main', commit: null });
+        console.log(chalk.green('✓ Initialized empty DBGit repository.'));
+    }
+    if (config.connectionString) {
+        console.log(chalk.blue('ℹ Connected using connection string (details hidden for security)'));
+    }
+    else {
+        console.log(chalk.blue(`ℹ Connected to: ${config.database}@${config.host}`));
+    }
+    if (options.mode === 'prod') {
+        console.warn(chalk.yellow('⚠ Production mode: destructive operations require --safe (for backups)'));
+    }
+}

package/dist/commands/log.d.ts

@@ -0,0 +1 @@
+export declare function logCommand(): void;

package/dist/commands/log.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import { getHead, listCommits } from '../core/store.js';
+export function logCommand() {
+    const head = getHead();
+    const commits = listCommits(head.branch, head.commit);
+    if (commits.length === 0) {
+        console.log(chalk.gray("ℹ No commits found."));
+        return;
+    }
+    commits.forEach(commit => {
+        console.log(chalk.yellow(`commit ${commit.commitHash}`));
+        if (commit.branch) {
+            console.log(chalk.blue(`Branch: ${commit.branch}`));
+        }
+        console.log(chalk.gray(`Date:   ${new Date(commit.timestamp).toLocaleString()}`));
+        console.log(`\n    ${commit.message}\n`);
+    });
+}

package/dist/commands/merge.d.ts

@@ -0,0 +1 @@
+export declare function mergeCommand(branchName: string): Promise<void>;

package/dist/commands/merge.js

@@ -0,0 +1,101 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import crypto from 'crypto';
+import { getHead, loadBranch, loadCommit, loadSnapshot, saveCommit, saveSnapshot, saveBranch, setHead } from '../core/store.js';
+import { createPool, getConnectionConfig } from '../core/connector.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import { diffSnapshots } from '../core/differ.js';
+import { orderChanges } from '../core/dependencyGraph.js';
+import { generateForwardSQL } from '../core/generator.js';
+import { runInTransaction } from '../core/transaction.js';
+import { ChangeType } from '../types/changes.js';
+export async function mergeCommand(branchName) {
+    const head = getHead();
+    if (!head.branch) {
+        console.error(chalk.red("Cannot merge in detached HEAD state."));
+        process.exit(1);
+    }
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    const spinner = ora(`Merging branch '${branchName}' into '${head.branch}'...`).start();
+    try {
+        const targetBranch = loadBranch(branchName);
+        const targetCommit = loadCommit(targetBranch.headCommit);
+        const targetSnapshot = loadSnapshot(targetCommit.snapshotHash);
+        const headCommit = loadCommit(head.commit);
+        const headSnapshot = loadSnapshot(headCommit.snapshotHash);
+        // Simplistic merge: diff target against head and apply to live (which should match head)
+        const changeset = diffSnapshots(headSnapshot, targetSnapshot);
+        if (changeset.changes.length === 0) {
+            spinner.succeed("Already up to date.");
+            await pool.end();
+            return;
+        }
+        // Conflict detection
+        const conflicts = [];
+        const headTableNames = Object.keys(headSnapshot.tables);
+        changeset.changes.forEach(change => {
+            // 1. Table modified on target but dropped on head
+            if (change.type !== ChangeType.ADD_TABLE && change.type !== ChangeType.DROP_TABLE) {
+                if (!headSnapshot.tables[change.table] && headTableNames.includes(change.table)) {
+                    conflicts.push(`Table '${change.table}' was dropped on ${head.branch} but modified on ${branchName}`);
+                }
+            }
+            // 2. Table added on target but already exists on head (different schema)
+            if (change.type === ChangeType.ADD_TABLE) {
+                if (headSnapshot.tables[change.table]) {
+                    conflicts.push(`Table '${change.table}' exists on both branches with different definitions.`);
+                }
+            }
+            // 3. Foreign key added on target referencing a table dropped on head
+            if (change.type === ChangeType.ADD_FOREIGN_KEY) {
+                const fk = change.after;
+                if (!headSnapshot.tables[fk.targetTable] && headTableNames.includes(fk.targetTable)) {
+                    conflicts.push(`Foreign key '${fk.name}' on ${branchName} references table '${fk.targetTable}' which was dropped on ${head.branch}`);
+                }
+            }
+            // 4. Index added on target to a table dropped on head
+            if (change.type === ChangeType.ADD_INDEX) {
+                if (!headSnapshot.tables[change.table] && headTableNames.includes(change.table)) {
+                    conflicts.push(`Index '${change.objectName}' on ${branchName} added to table '${change.table}' which was dropped on ${head.branch}`);
+                }
+            }
+        });
+        if (conflicts.length > 0) {
+            spinner.fail(chalk.red("Merge aborted. Resolve conflicts manually."));
+            conflicts.forEach(c => console.log(chalk.red(`  Conflict: ${c}`)));
+            await pool.end();
+            process.exit(1);
+        }
+        const liveSnapshot = await captureSnapshot(pool, []);
+        const orderedChanges = orderChanges(changeset.changes, liveSnapshot);
+        const sqlStatements = generateForwardSQL({ ...changeset, changes: orderedChanges });
+        await runInTransaction(pool, sqlStatements);
+        // Create merge commit
+        const timestamp = new Date().toISOString();
+        const message = `Merge branch '${branchName}' into '${head.branch}'`;
+        const commitHash = crypto.createHash('sha256').update(message + timestamp + targetSnapshot.schemaHash).digest('hex').substring(0, 7);
+        const mergeCommit = {
+            commitHash,
+            snapshotHash: targetSnapshot.schemaHash,
+            parent: head.commit,
+            timestamp,
+            message,
+            branch: head.branch,
+            schemaHash: targetSnapshot.schemaHash
+        };
+        saveSnapshot(targetSnapshot.schemaHash, targetSnapshot);
+        saveCommit(mergeCommit);
+        const currentBranch = loadBranch(head.branch);
+        currentBranch.headCommit = commitHash;
+        saveBranch(currentBranch);
+        setHead({ ...head, commit: commitHash });
+        spinner.succeed(chalk.green(`Merged branch '${branchName}' into '${head.branch}'.`));
+        console.log(`Applied ${changeset.changes.length} changes.`);
+        await pool.end();
+    }
+    catch (e) {
+        spinner.fail(chalk.red(`Merge failed: ${e.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/purge.d.ts

@@ -0,0 +1 @@
+export declare function purgeCommand(): Promise<void>;

package/dist/commands/purge.js

@@ -0,0 +1,85 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import { isInitialized, loadConfig } from '../core/store.js';
+import { createPool, getConnectionConfig, query } from '../core/connector.js';
+import { runInTransaction } from '../core/transaction.js';
+export async function purgeCommand() {
+    if (!isInitialized()) {
+        console.error(chalk.red("Not a DBGit repository. Run 'dbgit init' first."));
+        process.exit(1);
+    }
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    const dbConfig = loadConfig();
+    const isProd = dbConfig.DBGIT_MODE === 'prod';
+    try {
+        const spinner = ora('Scanning for soft-deleted objects...').start();
+        // Find soft-deleted tables
+        const deletedTables = await query(pool, `
+      SELECT table_name FROM information_schema.tables
+      WHERE table_schema = 'public' AND table_name LIKE '_dbgit_deleted_%'
+    `);
+        // Find soft-deleted columns
+        const deletedColumns = await query(pool, `
+      SELECT table_name, column_name FROM information_schema.columns
+      WHERE table_schema = 'public' AND column_name LIKE '_dbgit_deleted_%'
+    `);
+        spinner.stop();
+        if (deletedTables.length === 0 && deletedColumns.length === 0) {
+            console.log(chalk.green('✓ No soft-deleted objects found.'));
+            await pool.end();
+            return;
+        }
+        console.log(chalk.yellow('ℹ Objects scheduled for permanent removal:'));
+        if (deletedTables.length > 0) {
+            console.log(chalk.red('\nTables:'));
+            deletedTables.forEach(t => console.log(chalk.red(`  ${t.table_name}`)));
+        }
+        if (deletedColumns.length > 0) {
+            console.log(chalk.red('\nColumns:'));
+            deletedColumns.forEach(c => console.log(chalk.red(`  ${c.table_name}.${c.column_name}`)));
+        }
+        if (isProd) {
+            console.warn(chalk.bgRed.white('\n WARNING: Production mode. Permanent deletion of data. '));
+        }
+        const response = await prompts({
+            type: 'confirm',
+            name: 'confirm',
+            message: 'Are you sure you want to permanently delete these objects?',
+            initial: false
+        });
+        if (!response.confirm) {
+            console.log(chalk.gray('Purge aborted.'));
+            await pool.end();
+            return;
+        }
+        if (isProd) {
+            const doubleCheck = await prompts({
+                type: 'text',
+                name: 'confirm',
+                message: 'Type PURGE to confirm permanent deletion:'
+            });
+            if (doubleCheck.confirm !== 'PURGE') {
+                console.log(chalk.gray('Purge aborted.'));
+                await pool.end();
+                return;
+            }
+        }
+        const sqlStatements = [];
+        deletedColumns.forEach(c => {
+            sqlStatements.push(`ALTER TABLE ${c.table_name} DROP COLUMN ${c.column_name}`);
+        });
+        deletedTables.forEach(t => {
+            sqlStatements.push(`DROP TABLE ${t.table_name}`);
+        });
+        const purgeSpinner = ora('Purging objects...').start();
+        await runInTransaction(pool, sqlStatements);
+        purgeSpinner.succeed(chalk.green('Purge complete. Soft-deleted objects permanently removed.'));
+        await pool.end();
+    }
+    catch (e) {
+        console.error(chalk.red(`Purge failed: ${e.message}`));
+        process.exit(1);
+    }
+}

package/dist/commands/restore-backup.d.ts

@@ -0,0 +1 @@
+export declare function restoreBackupCommand(hash: string): void;

package/dist/commands/restore-backup.js

@@ -0,0 +1,14 @@
+import chalk from 'chalk';
+import { getRestoreCommand, backupExists } from '../core/backup.js';
+import { getConnectionConfig } from '../core/connector.js';
+export function restoreBackupCommand(hash) {
+    const config = getConnectionConfig();
+    if (!backupExists(hash)) {
+        console.error(chalk.red(`Error: No backup found for commit ${hash}.`));
+        process.exit(1);
+    }
+    const command = getRestoreCommand(hash, config);
+    console.log(chalk.green('\nTo restore the backup, run the following command manually:'));
+    console.log(chalk.cyan(`\n  ${command}\n`));
+    console.log(chalk.yellow('Warning: This will overwrite data in your database.'));
+}

package/dist/commands/restore.d.ts

@@ -0,0 +1 @@
+export declare function restoreCommand(hash: string, tableName: string): Promise<void>;

package/dist/commands/restore.js

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { loadSnapshot, loadCommit } from '../core/store.js';
+import { createPool, getConnectionConfig } from '../core/connector.js';
+import { captureSnapshot } from '../core/snapshot.js';
+import { diffSnapshots } from '../core/differ.js';
+import { generateForwardSQL } from '../core/generator.js';
+import { runInTransaction } from '../core/transaction.js';
+export async function restoreCommand(hash, tableName) {
+    const config = getConnectionConfig();
+    const pool = createPool(config);
+    const spinner = ora(`Restoring table '${tableName}' to state at ${hash}...`).start();
+    try {
+        const targetSnapshot = loadSnapshot(loadCommit(hash).snapshotHash);
+        const targetTable = targetSnapshot.tables[tableName];
+        if (!targetTable) {
+            throw new Error(`Table '${tableName}' not found in commit ${hash}.`);
+        }
+        const liveSnapshot = await captureSnapshot(pool, []);
+        const liveTable = liveSnapshot.tables[tableName];
+        const tempFromSnapshot = { tables: liveTable ? { [tableName]: liveTable } : {}, capturedAt: '', schemaHash: '' };
+        const tempToSnapshot = { tables: { [tableName]: targetTable }, capturedAt: '', schemaHash: '' };
+        const changeset = diffSnapshots(tempFromSnapshot, tempToSnapshot);
+        const sqlStatements = generateForwardSQL(changeset);
+        await runInTransaction(pool, sqlStatements);
+        spinner.succeed(chalk.green(`Table '${tableName}' restored to state at ${hash}`));
+        await pool.end();
+    }
+    catch (e) {
+        spinner.fail(chalk.red(`Restore failed: ${e.message}`));
+        process.exit(1);
+    }
+}