@coldge.com/gitbase 1.0.2 → 1.0.3

package/dist/commands/stash.js

@@ -0,0 +1,211 @@
+/**
+ * stash.ts — Save and restore uncommitted local schema changes.
+ *
+ * Stash entries are stored as tree objects in .gitbase/objects/ (same as
+ * regular commits), with an index at .gitbase/stash (JSON array).
+ *
+ * Usage:
+ *   gitb stash              Save current supabase/ state (alias for 'push')
+ *   gitb stash push [-m "msg"]  Save with a custom message
+ *   gitb stash pop          Restore top stash entry and remove it
+ *   gitb stash apply [n]    Restore stash entry N (0-indexed) but keep it
+ *   gitb stash list         List all stash entries
+ *   gitb stash drop [n]     Delete stash entry N without applying
+ *   gitb stash clear        Delete all stash entries
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { hashString } from '../utils/hashing.js';
+const GITBASE_DIR = '.gitbase';
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+const STASH_FILE = path.join(GITBASE_DIR, 'stash');
+const HEAD_FILE = path.join(GITBASE_DIR, 'HEAD');
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+async function readStash() {
+    try {
+        const raw = await fs.readFile(STASH_FILE, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+async function writeStash(entries) {
+    await fs.writeFile(STASH_FILE, JSON.stringify(entries, null, 2), 'utf-8');
+}
+async function saveObject(hash, content) {
+    await fs.mkdir(OBJECTS_DIR, { recursive: true });
+    await fs.writeFile(path.join(OBJECTS_DIR, hash), content, 'utf-8');
+}
+/** Walk supabase/ and build a tree map {relPath -> content} */
+async function buildTree() {
+    const tree = {};
+    async function walk(dir, base) {
+        const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relPath = path.join(base, entry.name).replace(/\\/g, '/');
+            if (entry.isDirectory()) {
+                await walk(fullPath, relPath);
+            }
+            else if (entry.name.endsWith('.sql')) {
+                tree[relPath] = await fs.readFile(fullPath, 'utf-8');
+            }
+        }
+    }
+    await walk('supabase', '').catch(() => { }); // supabase/ may not exist
+    return tree;
+}
+/** Save a tree from {relPath -> content} to objects/, return tree hash */
+async function saveTree(tree) {
+    const hashed = {};
+    for (const [relPath, content] of Object.entries(tree)) {
+        const h = hashString(content);
+        await saveObject(h, content);
+        hashed[relPath] = h;
+    }
+    const sorted = Object.fromEntries(Object.entries(hashed).sort(([a], [b]) => a.localeCompare(b)));
+    const treeJson = JSON.stringify(sorted);
+    const treeHash = hashString(treeJson);
+    await saveObject(treeHash, treeJson);
+    return treeHash;
+}
+/** Restore a tree from a tree hash to supabase/, optionally wiping first */
+async function restoreTree(treeHash) {
+    const treeStr = await fs.readFile(path.join(OBJECTS_DIR, treeHash), 'utf-8');
+    const tree = JSON.parse(treeStr);
+    await fs.rm('supabase', { recursive: true, force: true });
+    for (const [relPath, blobHash] of Object.entries(tree)) {
+        const fullPath = path.join('supabase', relPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        const content = await fs.readFile(path.join(OBJECTS_DIR, blobHash), 'utf-8');
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+}
+async function getCurrentBranch() {
+    try {
+        const raw = await fs.readFile(path.join(GITBASE_DIR, 'config'), 'utf-8');
+        return JSON.parse(raw).currentBranch ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+// ---------------------------------------------------------------------------
+// Subcommands
+// ---------------------------------------------------------------------------
+async function stashPush(message) {
+    const tree = await buildTree();
+    if (Object.keys(tree).length === 0) {
+        console.log(chalk.yellow('Nothing to stash (supabase/ is empty or missing).'));
+        return;
+    }
+    const branch = await getCurrentBranch();
+    const treeHash = await saveTree(tree);
+    const msg = message ?? `On ${branch}: WIP`;
+    const entry = {
+        tree: treeHash,
+        message: msg,
+        timestamp: new Date().toISOString(),
+        branch
+    };
+    const entries = await readStash();
+    entries.unshift(entry); // newest first, like git stash
+    await writeStash(entries);
+    console.log(chalk.green(`Saved working state as stash@{0}: ${msg}`));
+    console.log(chalk.gray(`  ${Object.keys(tree).length} file(s) stashed. Run 'gitb stash pop' to restore.`));
+}
+async function stashList() {
+    const entries = await readStash();
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No stash entries found.'));
+        return;
+    }
+    console.log(chalk.cyan('Stash list:'));
+    entries.forEach((e, i) => {
+        const date = new Date(e.timestamp).toLocaleString();
+        console.log(`  stash@{${i}}: ${e.message} ${chalk.gray(`(${e.branch}, ${date})`)}`);
+    });
+}
+async function stashApply(index, remove) {
+    const entries = await readStash();
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No stash entries to apply.'));
+        return;
+    }
+    if (index < 0 || index >= entries.length) {
+        console.error(chalk.red(`Invalid stash index ${index}. Use 'gitb stash list' to see available entries.`));
+        return;
+    }
+    const entry = entries[index];
+    console.log(chalk.blue(`Restoring stash@{${index}}: ${entry.message}`));
+    await restoreTree(entry.tree);
+    if (remove) {
+        entries.splice(index, 1);
+        await writeStash(entries);
+        console.log(chalk.green(`Stash@{${index}} applied and removed.`));
+    }
+    else {
+        console.log(chalk.green(`Stash@{${index}} applied (entry kept — use 'gitb stash drop ${index}' to remove).`));
+    }
+}
+async function stashDrop(index) {
+    const entries = await readStash();
+    if (index < 0 || index >= entries.length) {
+        console.error(chalk.red(`Invalid stash index ${index}.`));
+        return;
+    }
+    const dropped = entries.splice(index, 1)[0];
+    await writeStash(entries);
+    console.log(chalk.red(`Dropped stash@{${index}}: ${dropped.message}`));
+}
+async function stashClear() {
+    await writeStash([]);
+    console.log(chalk.red('All stash entries cleared.'));
+}
+// ---------------------------------------------------------------------------
+// Entry point — router
+// ---------------------------------------------------------------------------
+export async function stash(argv) {
+    // Verify gitbase is initialized
+    try {
+        await fs.access(path.join(GITBASE_DIR, 'config'));
+    }
+    catch {
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
+        return;
+    }
+    const sub = argv.subcommand ?? argv._?.[1] ?? 'push';
+    switch (sub) {
+        case 'push':
+        case 'save':
+            await stashPush(argv.message ?? argv.m);
+            break;
+        case 'pop':
+            await stashApply(0, true);
+            break;
+        case 'apply': {
+            const idx = typeof argv.index === 'number' ? argv.index : parseInt(argv.index ?? '0', 10);
+            await stashApply(isNaN(idx) ? 0 : idx, false);
+            break;
+        }
+        case 'list':
+        case 'ls':
+            await stashList();
+            break;
+        case 'drop': {
+            const idx = typeof argv.index === 'number' ? argv.index : parseInt(argv.index ?? '0', 10);
+            await stashDrop(isNaN(idx) ? 0 : idx);
+            break;
+        }
+        case 'clear':
+            await stashClear();
+            break;
+        default:
+            // Default bare 'gitb stash' saves
+            await stashPush(argv.message ?? argv.m);
+    }
+}

package/dist/commands/status.js

@@ -3,32 +3,20 @@ import path from 'path';
 import chalk from 'chalk';
 import { extractSchema } from '../schema/extractor.js';
 import { canonicalize } from '../utils/hashing.js';
+import { createPool, endPool } from '../api/supabase.js';
 const GITBASE_DIR = '.gitbase';
 const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+const ALL_TYPES = [
+    'extensions', 'types', 'sequences', 'tables', 'matviews',
+    'views', 'functions', 'triggers', 'policies', 'grants', 'publications'
+];
 export async function status() {
-    const changes = await getStatus();
+    const changes = await getStatus(false);
     if (!changes)
         return;
-    if (changes.length === 0) {
-        console.log(chalk.green('No changes detected. Working tree clean.'));
-    }
-    else {
-        console.log(chalk.yellow('Unsynced Changes (Database -> Local):'));
-        for (const change of changes) {
-            if (change.type === 'new') {
-                console.log(chalk.green(`  [NEW]      ${change.path}`));
-            }
-            else if (change.type === 'modified') {
-                console.log(chalk.yellow(`  [MODIFIED] ${change.path}`));
-            }
-            else if (change.type === 'deleted') {
-                console.log(chalk.red(`  [DELETED]  ${change.path}`));
-            }
-        }
-    }
+    // printing is now handled by getStatus directly during the check to maintain structure.
 }
-export async function getStatus() {
-    // Check if initialized
+export async function getStatus(silent = false) {
     try {
         await fs.access(CONFIG_FILE);
     }
@@ -37,29 +25,52 @@ export async function getStatus() {
         return null;
     }
     const config = JSON.parse(await fs.readFile(CONFIG_FILE, 'utf-8'));
-    const projectRef = config.projectRef;
-    // console.log(chalk.blue(`Fetching schema from ${projectRef}...`));
-    // Silence this log for `status` or keep it? Maybe ok. 
-    // But `add` might want to be silent?
+    // BUG FIX 1.5: support the current multi-branch config format
+    const branchData = config.branches?.[config.currentBranch];
+    const projectRef = branchData?.projectRef ?? config.projectRef;
+    if (!projectRef) {
+        console.error(chalk.red('Project ref not found in config. Run `gitb init --force` to re-initialize.'));
+        return null;
+    }
     let liveSchema;
     try {
+        await createPool(projectRef);
         liveSchema = await extractSchema(projectRef);
     }
     catch (e) {
         console.error(chalk.red(`Failed to fetch schema: ${e.message}`));
         return null;
     }
+    finally {
+        await endPool(projectRef);
+    }
     const changes = [];
-    await checkType(liveSchema.tables, 'tables', changes);
-    await checkType(liveSchema.functions, 'functions', changes);
-    await checkType(liveSchema.views, 'views', changes);
-    await checkType(liveSchema.triggers, 'triggers', changes);
-    await checkType(liveSchema.policies, 'policies', changes);
+    for (const type of ALL_TYPES) {
+        await checkType(liveSchema[type] ?? {}, type, changes);
+    }
+    if (!silent) {
+        if (changes.length === 0) {
+            console.log(chalk.green('No changes detected. Working tree clean.'));
+        }
+        else {
+            console.log(chalk.yellow('Unsynced Changes (Database → Local):'));
+            for (const change of changes) {
+                if (change.type === 'new') {
+                    console.log(chalk.green(`  [NEW]      ${change.path}`));
+                }
+                else if (change.type === 'modified') {
+                    console.log(chalk.yellow(`  [MODIFIED] ${change.path}`));
+                }
+                else if (change.type === 'deleted') {
+                    console.log(chalk.red(`  [DELETED]  ${change.path}`));
+                }
+            }
+        }
+    }
     return changes;
 }
 async function checkType(liveObjects, type, changes) {
     const dir = path.join('supabase', type);
-    // Ensure dir exists
     try {
         await fs.mkdir(dir, { recursive: true });
     }
@@ -73,22 +84,19 @@ async function checkType(liveObjects, type, changes) {
         const content = await fs.readFile(path.join(dir, file), 'utf-8');
         localMap[name] = content;
     }
-    // Check for New or Modified
+    // New or modified
     for (const [name, content] of Object.entries(liveObjects)) {
-        // Sanitize name for filename
         const safeName = name.replace(/\//g, '_');
         if (!localMap[safeName]) {
             changes.push({ type: 'new', path: `${type}/${safeName}.sql`, content, rawName: name });
         }
-        else {
-            if (canonicalize(content) !== canonicalize(localMap[safeName])) {
-                changes.push({ type: 'modified', path: `${type}/${safeName}.sql`, content, rawName: name });
-            }
+        else if (canonicalize(content) !== canonicalize(localMap[safeName])) {
+            changes.push({ type: 'modified', path: `${type}/${safeName}.sql`, content, rawName: name });
         }
     }
-    // Check for Deleted
+    // Deleted (in local but gone from live DB)
+    const liveKeysSafe = Object.keys(liveObjects).map(k => k.replace(/\//g, '_'));
     for (const name of Object.keys(localMap)) {
-        const liveKeysSafe = Object.keys(liveObjects).map(k => k.replace(/\//g, '_'));
         if (!liveKeysSafe.includes(name)) {
             changes.push({ type: 'deleted', path: `${type}/${name}.sql`, rawName: name });
         }

package/dist/commands/verify.js

@@ -0,0 +1,120 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { getConfig, getConnectionString } from '../api/supabase.js';
+import pg from 'pg';
+const { Client } = pg;
+export async function verify() {
+    console.log(chalk.blue('Verifying local schema against current database...'));
+    const config = await getConfig();
+    if (!config) {
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
+        return;
+    }
+    const currentBranch = config.branches ? config.branches[config.currentBranch] : null;
+    const projectRef = currentBranch ? currentBranch.projectRef : config.projectRef;
+    if (!projectRef) {
+        console.error(chalk.red('Could not determine project ref. Check config.'));
+        return;
+    }
+    // 1. Load all local SQL files
+    const localFiles = await loadAllSqlFiles('supabase');
+    if (localFiles.length === 0) {
+        console.log(chalk.yellow('No local SQL files found to verify.'));
+        return;
+    }
+    const connString = await getConnectionString(projectRef);
+    const client = new Client({ connectionString: connString, ssl: { rejectUnauthorized: false } });
+    try {
+        await client.connect();
+    }
+    catch (e) {
+        console.error(chalk.red(`Failed to connect to database: ${e.message}`));
+        return;
+    }
+    let hasErrors = false;
+    console.log(chalk.cyan(`Found ${localFiles.length} local SQL files. Validating syntax and dependencies...`));
+    try {
+        // We use a transaction so we can roll it back immediately.
+        await client.query('BEGIN');
+        // We need to apply files somewhat in order so references exist.
+        // It's not a perfect graph, but simple enough for demonstration:
+        // Types -> Tables -> Views -> Functions -> Policies -> Triggers
+        const sortedFiles = localFiles.sort((a, b) => {
+            const getRank = (p) => {
+                if (p.includes('/types/'))
+                    return 1;
+                if (p.includes('/tables/'))
+                    return 2;
+                if (p.includes('/views/'))
+                    return 3;
+                if (p.includes('/functions/'))
+                    return 4;
+                if (p.includes('/policies/'))
+                    return 5;
+                if (p.includes('/triggers/'))
+                    return 6;
+                return 7;
+            };
+            return getRank(a.path) - getRank(b.path);
+        });
+        for (const file of sortedFiles) {
+            try {
+                // Some Postgres DDL (like CREATE INDEX CONCURRENTLY or DROP DATABASE) can't run in a transaction block.
+                // We'll swallow those specific errors if they occur, but standard CREATE TABLE/FUNCTION/POLICY works fine.
+                await client.query(file.content);
+            }
+            catch (err) {
+                // If the error is about running outside a transaction block, we ignore the verification failure
+                // (it relies on the live DB to tell us)
+                if (err.message && err.message.includes('cannot run inside a transaction block')) {
+                    console.log(chalk.yellow(`  ⚠ Skipped ${file.path} (cannot be verified inside a transaction block)`));
+                    continue;
+                }
+                hasErrors = true;
+                console.error(chalk.red(`\n❌ Error in ${file.path}:`));
+                console.error(chalk.red(`   ${err.message}`));
+                if (err.position) {
+                    console.error(chalk.yellow(`   Position: ${err.position}`));
+                }
+                // Once a transaction errors, subsequent queries in the same transaction will fail with "current transaction is aborted".
+                // So we stop checking further files.
+                break;
+            }
+        }
+    }
+    finally {
+        // ABSOLUTELY ESSENTIAL: Rollback the transaction so we don't actually modify the live database.
+        await client.query('ROLLBACK');
+        await client.end();
+    }
+    if (!hasErrors) {
+        console.log(chalk.green('\n✅ Schema is valid. Ready to push.'));
+    }
+    else {
+        console.error(chalk.red('\nVerification failed. Please fix the SQL errors before pushing.'));
+        process.exitCode = 1;
+    }
+}
+async function loadAllSqlFiles(dir, baseDir = dir) {
+    let results = [];
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results = results.concat(await loadAllSqlFiles(fullPath, baseDir));
+            }
+            else if (entry.isFile() && fullPath.endsWith('.sql')) {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                // Use posix paths internally for consistency
+                const relPath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+                results.push({ path: relPath, content });
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist
+    }
+    return results;
+}

package/dist/index.js

@@ -26,15 +26,25 @@ yargs(hideBin(process.argv))
     const { status } = await import('./commands/status.js');
     await status();
 })
-    .command(['pull [files..]', 'add [files..]'], 'Pull changes from database to local files', (yargs) => {
-    return yargs.positional('files', {
-        describe: 'Files to pull',
+    .command(['pull [files..]', 'add [files..]'], 'Pull schema from database to local files', (yargs) => {
+    return yargs
+        .positional('files', {
+        describe: 'Specific files to pull',
         type: 'string',
         array: true
+    })
+        .option('auto-commit', {
+        type: 'boolean',
+        description: 'Automatically commit after pulling with an auto-generated message'
+    })
+        .option('message', {
+        alias: 'm',
+        type: 'string',
+        description: 'Commit message (implies auto-commit)'
     });
 }, async (argv) => {
-    const { add } = await import('./commands/add.js');
-    await add(argv);
+    const { pull } = await import('./commands/pull.js');
+    await pull(argv);
 })
     .command('commit', 'Record changes to the repository', (yargs) => {
     return yargs.option('message', {
@@ -60,14 +70,47 @@ yargs(hideBin(process.argv))
     const { revert } = await import('./commands/revert.js');
     await revert(argv);
 })
-    .command('log', 'Show commit logs', {}, async (argv) => {
+    .command('log [file]', 'Show commit history', (yargs) => {
+    return yargs
+        .positional('file', {
+        describe: 'Only show commits that touched this file (e.g. tables/users.sql)',
+        type: 'string'
+    })
+        .option('oneline', {
+        type: 'boolean',
+        description: 'Compact one-line format'
+    })
+        .option('since', {
+        type: 'string',
+        description: 'Only show commits after this date (ISO format, e.g. 2026-01-01)'
+    })
+        .option('n', {
+        alias: 'max-count',
+        type: 'number',
+        description: 'Limit to last N commits'
+    });
+}, async (argv) => {
     const { log } = await import('./commands/log.js');
-    await log();
+    await log(argv);
 })
-    .command('diff [commit]', 'Show changes between commits or live database', (yargs) => {
-    return yargs.positional('commit', {
-        describe: 'Commit hash to compare with Live Database (defaults to HEAD)',
+    .command('diff [commit] [commit2]', 'Show changes between commits or live database', (yargs) => {
+    return yargs
+        .positional('commit', {
+        describe: 'First commit hash (or HEAD~N). Compared against local files by default.',
+        type: 'string'
+    })
+        .positional('commit2', {
+        describe: 'Second commit hash — compare two commits directly',
         type: 'string'
+    })
+        .option('live', {
+        type: 'boolean',
+        description: 'Compare commit against live database instead of local files'
+    })
+        .option('files', {
+        type: 'string',
+        array: true,
+        description: 'Filter to specific files (e.g. tables/users.sql)'
     });
 }, async (argv) => {
     const { diff } = await import('./commands/diff.js');
@@ -125,6 +168,43 @@ yargs(hideBin(process.argv))
 }, async (argv) => {
     const { remote } = await import('./commands/remote.js');
     await remote(argv);
+})
+    .command('stash [subcommand]', 'Stash and restore uncommitted local schema changes', (yargs) => {
+    return yargs
+        .positional('subcommand', {
+        describe: 'Stash subcommand: push (default), pop, apply, list, drop, clear',
+        type: 'string',
+        choices: ['push', 'save', 'pop', 'apply', 'list', 'ls', 'drop', 'clear'],
+        default: 'push'
+    })
+        .option('message', {
+        alias: 'm',
+        type: 'string',
+        description: 'Stash message (for push/save)'
+    })
+        .option('index', {
+        alias: 'n',
+        type: 'number',
+        description: 'Stash entry index (for apply/drop)',
+        default: 0
+    });
+}, async (argv) => {
+    const { stash } = await import('./commands/stash.js');
+    await stash(argv);
+})
+    .command('verify', 'Dry-run local schema files against the database to catch errors', {}, async (argv) => {
+    const { verify } = await import('./commands/verify.js');
+    await verify();
+})
+    .command('snapshot', 'Start a background daemon that automatically commits remote changes', (yargs) => {
+    return yargs.option('interval', {
+        type: 'number',
+        description: 'Interval in minutes to check for changes',
+        default: 60
+    });
+}, async (argv) => {
+    const { snapshot } = await import('./commands/snapshot.js');
+    await snapshot(argv);
 })
     .help()
     .parse();