@coldge.com/gitbase 1.0.2 → 1.0.3

package/dist/commands/diff.js

@@ -7,8 +7,125 @@ import { extractSchema } from '../schema/extractor.js';
 import { canonicalize } from '../utils/hashing.js';
 const GITBASE_DIR = '.gitbase';
 const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+const HEAD_FILE = path.join(GITBASE_DIR, 'HEAD');
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+const ALL_TYPES = [
+    'extensions', 'types', 'sequences', 'tables', 'matviews',
+    'views', 'functions', 'triggers', 'policies', 'grants', 'publications'
+];
+// ---------------------------------------------------------------------------
+// HEAD~N resolution
+// ---------------------------------------------------------------------------
+async function resolveRef(ref) {
+    // HEAD~N syntax
+    const tildeMatch = ref.match(/^HEAD~(\d+)$/i);
+    if (tildeMatch || ref.toUpperCase() === 'HEAD') {
+        const steps = tildeMatch ? parseInt(tildeMatch[1], 10) : 0;
+        let hash = await fs.readFile(HEAD_FILE, 'utf-8').catch(() => null);
+        if (!hash)
+            throw new Error('No HEAD commit found.');
+        for (let i = 0; i < steps; i++) {
+            const commit = await readCommit(hash);
+            if (!commit.parent)
+                throw new Error(`HEAD~${steps} does not exist (only ${i} ancestors).`);
+            hash = commit.parent;
+        }
+        return hash;
+    }
+    // Otherwise treat as a raw commit hash (prefix search)
+    if (ref.length < 40) {
+        const objects = await fs.readdir(OBJECTS_DIR).catch(() => []);
+        const match = objects.find(h => h.startsWith(ref));
+        if (!match)
+            throw new Error(`Commit '${ref}' not found.`);
+        return match;
+    }
+    return ref;
+}
+// ---------------------------------------------------------------------------
+// Tree loader — commit hash → { type: { name: sql } }
+// ---------------------------------------------------------------------------
+async function loadCommitSchema(commitHash) {
+    const schema = {};
+    for (const t of ALL_TYPES)
+        schema[t] = {};
+    const commit = await readCommit(commitHash);
+    const tree = await readTree(commit.tree);
+    for (const [relPath, hash] of Object.entries(tree)) {
+        const parts = relPath.split('/');
+        if (parts.length < 2)
+            continue;
+        const type = parts[0];
+        const name = path.basename(relPath, '.sql');
+        if (schema[type] !== undefined) {
+            schema[type][name] = await readObject(hash);
+        }
+    }
+    return schema;
+}
+// ---------------------------------------------------------------------------
+// Local files → schema map
+// ---------------------------------------------------------------------------
+async function loadLocalSchema() {
+    const schema = {};
+    for (const type of ALL_TYPES) {
+        schema[type] = {};
+        const dir = path.join('supabase', type);
+        try {
+            const files = await fs.readdir(dir);
+            for (const file of files) {
+                if (!file.endsWith('.sql'))
+                    continue;
+                schema[type][path.basename(file, '.sql')] = await fs.readFile(path.join(dir, file), 'utf-8');
+            }
+        }
+        catch { }
+    }
+    return schema;
+}
+// ---------------------------------------------------------------------------
+// Diff renderer
+// ---------------------------------------------------------------------------
+function renderDiff(aSchema, bSchema, aLabel, bLabel, filterFiles) {
+    let hasDiff = false;
+    for (const type of ALL_TYPES) {
+        const keys = Array.from(new Set([
+            ...Object.keys(aSchema[type] ?? {}),
+            ...Object.keys(bSchema[type] ?? {})
+        ])).sort();
+        for (const key of keys) {
+            const filePath = `${type}/${key}.sql`;
+            if (filterFiles.length > 0 && !filterFiles.includes(filePath))
+                continue;
+            const aSql = aSchema[type]?.[key] ?? '';
+            const bSql = bSchema[type]?.[key] ?? '';
+            if (canonicalize(aSql) === canonicalize(bSql))
+                continue;
+            hasDiff = true;
+            console.log(chalk.bold(`\ndiff --git a/${filePath} b/${filePath}`));
+            const patch = diffLib.createTwoFilesPatch(`a/${filePath}`, `b/${filePath}`, aSql, bSql, aLabel, bLabel);
+            for (const line of patch.split('\n')) {
+                if (line.startsWith('+') && !line.startsWith('+++')) {
+                    process.stdout.write(chalk.green(line) + '\n');
+                }
+                else if (line.startsWith('-') && !line.startsWith('---')) {
+                    process.stdout.write(chalk.red(line) + '\n');
+                }
+                else if (line.startsWith('@@')) {
+                    process.stdout.write(chalk.cyan(line) + '\n');
+                }
+                else {
+                    process.stdout.write(line + '\n');
+                }
+            }
+        }
+    }
+    return hasDiff;
+}
+// ---------------------------------------------------------------------------
+// Main command
+// ---------------------------------------------------------------------------
 export async function diff(argv) {
-    // 1. Check Config
     try {
         await fs.access(CONFIG_FILE);
     }
@@ -17,109 +134,78 @@ export async function diff(argv) {
         return;
     }
     const config = JSON.parse(await fs.readFile(CONFIG_FILE, 'utf-8'));
-    // Support new config format (branches)
-    const currentBranch = config.branches ? config.branches[config.currentBranch] : null;
-    const projectRef = currentBranch ? currentBranch.projectRef : config.projectRef;
+    const branchData = config.branches?.[config.currentBranch];
+    const projectRef = branchData?.projectRef ?? config.projectRef;
     if (!projectRef) {
-        console.error(chalk.red('Project Ref not found in config.'));
+        console.error(chalk.red('Project ref not found in config.'));
         return;
     }
-    console.log(chalk.blue(`Fetching current database state...`));
-    const liveSchema = await extractSchema(projectRef);
-    let targetSchema = { tables: {}, functions: {}, views: {}, triggers: {}, policies: {}, types: {} };
-    let targetLabel = '';
-    // Filter files if provided
     const filterFiles = argv.files || [];
-    // 2. Load Target Schema (Commit or Local Files)
-    const commitHash = argv.commit;
-    if (commitHash) {
-        // Compare with specific commit
-        targetLabel = `Commit ${commitHash.substring(0, 7)}`;
+    // Positional args: could be one commit (vs live/local) or two commits
+    const args = (argv._ ?? []).filter((a) => typeof a === 'string' && a !== 'diff');
+    const commitArg1 = argv.commit ?? args[0];
+    const commitArg2 = args[1];
+    // ── Case 1: two commit hashes ──────────────────────────────────────────
+    if (commitArg1 && commitArg2) {
+        let hash1, hash2;
         try {
-            const commit = await readCommit(commitHash);
-            const tree = await readTree(commit.tree);
-            for (const [relPath, hash] of Object.entries(tree)) {
-                const parts = relPath.split('/');
-                const type = parts[0];
-                const name = path.basename(relPath, '.sql');
-                const content = await readObject(hash);
-                if (targetSchema[type])
-                    targetSchema[type][name] = content;
-            }
+            [hash1, hash2] = await Promise.all([resolveRef(commitArg1), resolveRef(commitArg2)]);
         }
-        catch {
-            console.error(chalk.red(`Commit ${commitHash} not found.`));
+        catch (e) {
+            console.error(chalk.red(e.message));
             return;
         }
+        const [schemaA, schemaB] = await Promise.all([
+            loadCommitSchema(hash1),
+            loadCommitSchema(hash2)
+        ]);
+        const label1 = `${commitArg1} (${hash1.substring(0, 7)})`;
+        const label2 = `${commitArg2} (${hash2.substring(0, 7)})`;
+        console.log(chalk.blue(`Comparing ${label1} → ${label2}`));
+        const hasDiff = renderDiff(schemaA, schemaB, label1, label2, filterFiles);
+        if (!hasDiff)
+            console.log(chalk.green('\nNo differences between the two commits.'));
+        return;
     }
-    else {
-        // Compare with Local Files (equivalent to git diff)
-        targetLabel = 'Local Files';
-        const types = ['tables', 'functions', 'views', 'triggers', 'policies', 'types'];
-        for (const type of types) {
-            const dir = path.join('supabase', type);
-            try {
-                const files = await fs.readdir(dir);
-                for (const file of files) {
-                    if (!file.endsWith('.sql'))
-                        continue;
-                    const name = path.basename(file, '.sql');
-                    // Un-sanitize name if needed? 
-                    // In our extractor, we replace '/' with '_' for local files.
-                    // But for functions and tables they don't usually have '/'.
-                    const content = await fs.readFile(path.join(dir, file), 'utf-8');
-                    targetSchema[type][name] = content;
-                }
-            }
-            catch (e) {
-                // Directory doesn't exist, ignore
-            }
+    // ── Case 2: one commit (or HEAD~N) vs live DB / local files ───────────
+    if (commitArg1) {
+        let resolvedHash;
+        try {
+            resolvedHash = await resolveRef(commitArg1);
         }
-    }
-    // 4. Compare and Print Diff
-    let hasDifferences = false;
-    const types = ['tables', 'functions', 'views', 'triggers', 'policies', 'types'];
-    for (const type of types) {
-        const keys = Array.from(new Set([
-            ...Object.keys(liveSchema[type]),
-            ...Object.keys(targetSchema[type])
-        ])).sort();
-        for (const key of keys) {
-            const filePath = `${type}/${key}.sql`;
-            if (filterFiles.length > 0 && !filterFiles.includes(filePath))
-                continue;
-            const liveSql = liveSchema[type][key] || '';
-            const targetSql = targetSchema[type][key] || '';
-            if (canonicalize(liveSql) !== canonicalize(targetSql)) {
-                hasDifferences = true;
-                console.log(chalk.bold(`\ndiff --git a/${type}/${key}.sql b/${type}/${key}.sql`));
-                const patch = diffLib.createTwoFilesPatch(`a/${type}/${key}.sql`, `b/${type}/${key}.sql`, targetSql, liveSql, targetLabel, 'Live Database');
-                // Colorize patch output, skipping the first 4 header lines usually
-                const lines = patch.split('\n');
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i];
-                    if (i < 4) {
-                        // Print headers in default or bold
-                        console.log(chalk.white(line));
-                        continue;
-                    }
-                    if (line.startsWith('+') && !line.startsWith('+++')) {
-                        console.log(chalk.green(line));
-                    }
-                    else if (line.startsWith('-') && !line.startsWith('---')) {
-                        console.log(chalk.red(line));
-                    }
-                    else if (line.startsWith('@@')) {
-                        console.log(chalk.cyan(line));
-                    }
-                    else {
-                        console.log(line);
-                    }
-                }
-            }
+        catch (e) {
+            console.error(chalk.red(e.message));
+            return;
         }
+        const label = `${commitArg1} (${resolvedHash.substring(0, 7)})`;
+        if (argv.live) {
+            // vs live DB
+            console.log(chalk.blue(`Fetching live database state...`));
+            const liveSchema = await extractSchema(projectRef);
+            const commitSchema = await loadCommitSchema(resolvedHash);
+            const hasDiff = renderDiff(commitSchema, liveSchema, label, 'Live Database', filterFiles);
+            if (!hasDiff)
+                console.log(chalk.green(`\nNo differences. Live DB matches ${label}.`));
+        }
+        else {
+            // vs local files (default for one-commit comparison)
+            const [commitSchema, localSchema] = await Promise.all([
+                loadCommitSchema(resolvedHash),
+                loadLocalSchema()
+            ]);
+            const hasDiff = renderDiff(commitSchema, localSchema, label, 'Local Files', filterFiles);
+            if (!hasDiff)
+                console.log(chalk.green(`\nNo differences. Local files match ${label}.`));
+        }
+        return;
     }
-    if (!hasDifferences) {
-        console.log(chalk.green(`\nNo differences found. Live database matches ${targetLabel} exactly.`));
-    }
+    // ── Case 3: no commits — compare live DB vs local files (original behavior) ──
+    console.log(chalk.blue('Fetching current database state...'));
+    const [liveSchema, localSchema] = await Promise.all([
+        extractSchema(projectRef),
+        loadLocalSchema()
+    ]);
+    const hasDiff = renderDiff(localSchema, liveSchema, 'Local Files', 'Live Database', filterFiles);
+    if (!hasDiff)
+        console.log(chalk.green('\nNo differences found. Live database matches local files exactly.'));
 }

package/dist/commands/init.js

@@ -64,13 +64,18 @@ export async function init(argv = {}) {
     };
     await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
     console.log(chalk.green(`\nLinked to project: ${ref.trim()} (Branch: production)`));
-    // Create supabase directory structure
+    // Create supabase directory structure (all tracked schema types)
+    await fs.mkdir('supabase/extensions', { recursive: true });
+    await fs.mkdir('supabase/types', { recursive: true });
+    await fs.mkdir('supabase/sequences', { recursive: true });
     await fs.mkdir('supabase/tables', { recursive: true });
-    await fs.mkdir('supabase/functions', { recursive: true });
+    await fs.mkdir('supabase/matviews', { recursive: true });
     await fs.mkdir('supabase/views', { recursive: true });
-    await fs.mkdir('supabase/types', { recursive: true });
+    await fs.mkdir('supabase/functions', { recursive: true });
     await fs.mkdir('supabase/triggers', { recursive: true });
     await fs.mkdir('supabase/policies', { recursive: true });
+    await fs.mkdir('supabase/grants', { recursive: true });
+    await fs.mkdir('supabase/publications', { recursive: true });
     // Auto-ignore .gitbase
     try {
         const gitignorePath = '.gitignore';

package/dist/commands/log.js

@@ -1,30 +1,104 @@
 import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
-import { readCommit } from '../storage/git.js';
+import { readCommit, readTree } from '../storage/git.js';
 const GITBASE_DIR = '.gitbase';
 const HEAD_FILE = path.join(GITBASE_DIR, 'HEAD');
-export async function log() {
-    let currentHash;
+export async function log(argv = {}) {
+    let startHash = null;
     try {
-        currentHash = await fs.readFile(HEAD_FILE, 'utf-8');
+        startHash = await fs.readFile(HEAD_FILE, 'utf-8');
     }
     catch {
         console.log(chalk.red('No commits yet.'));
         return;
     }
-    console.log(chalk.cyan('Commit History:'));
+    if (!startHash) {
+        console.log(chalk.red('No commits yet.'));
+        return;
+    }
+    // Parse flags
+    const oneline = argv.oneline ?? argv['one-line'] ?? false;
+    const sinceStr = argv.since;
+    const filterFile = argv.file ?? argv._?.[0]; // e.g. tables/users.sql
+    const maxCount = parseInt(argv.n ?? argv['max-count'] ?? '0', 10) || 0;
+    // Parse --since into a Date threshold
+    let sinceDate = null;
+    if (sinceStr) {
+        sinceDate = new Date(sinceStr);
+        if (isNaN(sinceDate.getTime())) {
+            console.error(chalk.red(`Invalid --since value: "${sinceStr}". Use ISO date format, e.g. 2026-01-01`));
+            return;
+        }
+    }
+    if (!oneline) {
+        console.log(chalk.cyan('Commit History:'));
+    }
+    let currentHash = startHash;
+    let count = 0;
     while (currentHash) {
+        let commit;
         try {
-            const commit = await readCommit(currentHash);
-            console.log(chalk.yellow(`commit ${currentHash}`));
-            console.log(`Author: ${commit.author}`);
-            console.log(`Date:   ${commit.timestamp}`);
-            console.log(`\n    ${commit.message}\n`);
+            commit = await readCommit(currentHash);
+        }
+        catch {
+            break;
+        }
+        const commitDate = new Date(commit.timestamp);
+        // --since filter
+        if (sinceDate && commitDate < sinceDate) {
             currentHash = commit.parent;
+            continue;
+        }
+        // File filter: only include commits that touched the given file
+        if (filterFile) {
+            let touched = false;
+            try {
+                const tree = await readTree(commit.tree);
+                touched = Object.keys(tree).some(p => p === filterFile || p.endsWith('/' + filterFile));
+                // Also check parent tree to detect if file actually changed
+                if (touched && commit.parent) {
+                    const parentCommit = await readCommit(commit.parent).catch(() => null);
+                    if (parentCommit) {
+                        const parentTree = (await readTree(parentCommit.tree).catch(() => ({})));
+                        const fileHash = tree[filterFile] ?? Object.entries(tree).find(([p]) => p.endsWith('/' + filterFile))?.[1];
+                        const parentHash = parentTree[filterFile] ?? Object.entries(parentTree).find(([p]) => p.endsWith('/' + filterFile))?.[1];
+                        if (fileHash === parentHash)
+                            touched = false; // file didn't actually change
+                    }
+                }
+            }
+            catch { }
+            if (!touched) {
+                currentHash = commit.parent;
+                continue;
+            }
+        }
+        // Render
+        const shortHash = chalk.yellow(currentHash.substring(0, 7));
+        if (oneline) {
+            console.log(`${shortHash} ${commit.message}`);
+        }
+        else {
+            console.log(chalk.yellow(`\ncommit ${currentHash}`));
+            console.log(chalk.gray(`Author: ${commit.author}`));
+            console.log(chalk.gray(`Date:   ${commitDate.toLocaleString()}`));
+            console.log(`\n    ${commit.message}`);
         }
-        catch (e) {
+        count++;
+        if (maxCount > 0 && count >= maxCount)
             break;
+        currentHash = commit.parent;
+    }
+    if (count === 0) {
+        if (filterFile) {
+            console.log(chalk.yellow(`No commits found that touched '${filterFile}'.`));
+        }
+        else if (sinceDate) {
+            console.log(chalk.yellow(`No commits found since ${sinceStr}.`));
+        }
+        else {
+            console.log(chalk.yellow('No commits found.'));
         }
     }
 }