@coldge.com/gitbase 1.0.2 → 1.0.3

package/dist/commands/merge.js

@@ -1,15 +1,161 @@
+/**
+ * merge.ts — 3-way merge using diff3 algorithm.
+ *
+ * Finds the common ancestor commit, then per-file:
+ *   - Auto-merges if only one side changed
+ *   - Emits <<<<<<< / ======= / >>>>>>> conflict markers when both sides changed
+ *
+ * After merge, local files are updated. Run `gitb push` to apply to the DB.
+ */
 import fs from 'fs/promises';
 import path from 'path';
 import chalk from 'chalk';
 import { readCommit, readTree, readObject } from '../storage/git.js';
+import * as diffLib from 'diff';
 const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+// ---------------------------------------------------------------------------
+// Common ancestor search
+// ---------------------------------------------------------------------------
+async function getAncestorChain(startHash) {
+    const chain = new Set();
+    let hash = startHash;
+    while (hash) {
+        chain.add(hash);
+        try {
+            const commit = await readCommit(hash);
+            hash = commit.parent ?? null;
+        }
+        catch {
+            break;
+        }
+    }
+    return chain;
+}
+async function findCommonAncestor(hashA, hashB) {
+    const chainA = await getAncestorChain(hashA);
+    let hash = hashB;
+    while (hash) {
+        if (chainA.has(hash))
+            return hash;
+        try {
+            const commit = await readCommit(hash);
+            hash = commit.parent ?? null;
+        }
+        catch {
+            break;
+        }
+    }
+    return null;
+}
+// ---------------------------------------------------------------------------
+// Tree loader
+// ---------------------------------------------------------------------------
+async function loadTreeFiles(treeHash) {
+    const files = {};
+    try {
+        const raw = await fs.readFile(path.join(OBJECTS_DIR, treeHash), 'utf-8');
+        const tree = JSON.parse(raw);
+        for (const [relPath, blobHash] of Object.entries(tree)) {
+            files[relPath] = await readObject(blobHash);
+        }
+    }
+    catch { }
+    return files;
+}
+// ---------------------------------------------------------------------------
+// diff3 merge — for SQL DDL, we treat any simultaneous edit as a conflict
+// rather than trying to merge at the line level. This is the safest approach.
+// ---------------------------------------------------------------------------
+function merge3(base, ours, theirs, ourLabel, theirLabel) {
+    // Quick exits: if one side matches base, take the other
+    if (ours === base)
+        return { merged: theirs, hasConflict: false };
+    if (theirs === base)
+        return { merged: ours, hasConflict: false };
+    if (ours === theirs)
+        return { merged: ours, hasConflict: false };
+    // Both sides changed relative to base.
+    // Check if the changes are to different regions by diffing base→ours and base→theirs.
+    const diffOurs = diffLib.diffLines(base, ours);
+    const diffTheirs = diffLib.diffLines(base, theirs);
+    // Build a set of base-line indices that each side touched
+    const ourChangedLines = new Set();
+    const theirChangedLines = new Set();
+    let lineIdx = 0;
+    for (const part of diffOurs) {
+        const n = part.count ?? part.value.split('\n').length - 1;
+        if (part.removed) {
+            for (let i = 0; i < n; i++)
+                ourChangedLines.add(lineIdx + i);
+        }
+        else if (!part.added) {
+            lineIdx += n;
+        }
+    }
+    lineIdx = 0;
+    for (const part of diffTheirs) {
+        const n = part.count ?? part.value.split('\n').length - 1;
+        if (part.removed) {
+            for (let i = 0; i < n; i++)
+                theirChangedLines.add(lineIdx + i);
+        }
+        else if (!part.added) {
+            lineIdx += n;
+        }
+    }
+    // Check for overlapping line changes
+    let overlap = false;
+    for (const line of ourChangedLines) {
+        if (theirChangedLines.has(line)) {
+            overlap = true;
+            break;
+        }
+    }
+    if (overlap) {
+        // Conflicting edit — emit markers
+        const merged = [
+            `<<<<<<< ${ourLabel}`,
+            ours.trimEnd(),
+            `=======`,
+            theirs.trimEnd(),
+            `>>>>>>> ${theirLabel}`
+        ].join('\n') + '\n';
+        return { merged, hasConflict: true };
+    }
+    // Non-overlapping changes — safe to auto-merge
+    // If only ours changed, take ours; if only theirs changed, take theirs.
+    if (ourChangedLines.size > 0)
+        return { merged: ours, hasConflict: false };
+    return { merged: theirs, hasConflict: false };
+}
+// ---------------------------------------------------------------------------
+// Fast-forward helper
+// ---------------------------------------------------------------------------
+async function fastForward(sourceHead, sourceBranch, currentBranch) {
+    const sourceCommit = await readCommit(sourceHead);
+    const sourceTree = await readTree(sourceCommit.tree);
+    await fs.rm('supabase', { recursive: true, force: true });
+    for (const [relPath, hash] of Object.entries(sourceTree)) {
+        const fullPath = path.join('supabase', relPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        const content = await readObject(hash);
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+    console.log(chalk.green(`\nFast-forward merge complete.`));
+    console.log(chalk.yellow(`Run 'gitb push' to apply to the '${currentBranch}' database.`));
+}
+// ---------------------------------------------------------------------------
+// Main command
+// ---------------------------------------------------------------------------
 export async function merge(argv) {
     const sourceBranch = argv.name;
     if (!sourceBranch) {
         console.error(chalk.red('Source branch name required.'));
         return;
     }
-    const configContent = await fs.readFile(path.join(GITBASE_DIR, 'config'), 'utf-8');
+    const configContent = await fs.readFile(CONFIG_FILE, 'utf-8');
     const config = JSON.parse(configContent);
     if (!config.branches[sourceBranch]) {
         console.error(chalk.red(`Branch '${sourceBranch}' does not exist.`));
@@ -25,6 +171,7 @@ export async function merge(argv) {
         return;
     }
     const currentBranch = config.currentBranch;
+    const currentHead = config.branches[currentBranch]?.head ?? null;
     const projectRef = config.branches[currentBranch].projectRef;
     // RBAC: Production Protection
     if (currentBranch === 'production') {
@@ -37,23 +184,87 @@ export async function merge(argv) {
         }
         console.log(chalk.green('Permission verified.'));
     }
-    console.log(chalk.blue(`Merging files from '${sourceBranch}' into '${currentBranch}'...`));
-    // 1. Load source tree
-    const commit = await readCommit(sourceHead);
-    const tree = await readTree(commit.tree);
-    // 2. Clear current supabase dir and copy files
-    // In a real merge, we would do a 3-way merge. 
-    // For MVP, we just overwrite local files with the source branch's files.
-    try {
-        await fs.rm('supabase', { recursive: true, force: true });
+    // Fast-forward if current has no history
+    if (!currentHead) {
+        console.log(chalk.blue(`No local commits — fast-forwarding to '${sourceBranch}'...`));
+        await fastForward(sourceHead, sourceBranch, currentBranch);
+        return;
+    }
+    // Find common ancestor
+    console.log(chalk.blue(`Finding common ancestor between '${currentBranch}' and '${sourceBranch}'...`));
+    const ancestorHash = await findCommonAncestor(currentHead, sourceHead);
+    if (ancestorHash === sourceHead) {
+        console.log(chalk.green(`Already up to date. '${sourceBranch}' is an ancestor of '${currentBranch}'.`));
+        return;
     }
-    catch (e) { }
-    for (const [relPath, hash] of Object.entries(tree)) {
+    if (ancestorHash === currentHead) {
+        console.log(chalk.blue('Fast-forward possible...'));
+        await fastForward(sourceHead, sourceBranch, currentBranch);
+        return;
+    }
+    // True 3-way merge
+    const ourLabel = currentBranch;
+    const theirLabel = sourceBranch;
+    console.log(chalk.blue(ancestorHash
+        ? `Common ancestor: ${ancestorHash.substring(0, 7)}`
+        : `No common ancestor found — performing a criss-cross merge from scratch.`));
+    console.log(chalk.blue('\nPerforming 3-way merge...'));
+    const [currentCommit, sourceCommit] = await Promise.all([
+        readCommit(currentHead),
+        readCommit(sourceHead)
+    ]);
+    const baseTreeHash = ancestorHash ? (await readCommit(ancestorHash)).tree : null;
+    const [baseFiles, oursFiles, theirsFiles] = await Promise.all([
+        baseTreeHash ? loadTreeFiles(baseTreeHash) : Promise.resolve({}),
+        loadTreeFiles(currentCommit.tree),
+        loadTreeFiles(sourceCommit.tree)
+    ]);
+    const allPaths = new Set([...Object.keys(oursFiles), ...Object.keys(theirsFiles)]);
+    const merged = {};
+    let conflictCount = 0;
+    let autoMergedCount = 0;
+    let addedCount = 0;
+    for (const relPath of allPaths) {
+        const base = baseFiles[relPath] ?? '';
+        const ours = oursFiles[relPath] ?? '';
+        const theirs = theirsFiles[relPath] ?? '';
+        if (!oursFiles[relPath]) {
+            // Added only by theirs
+            merged[relPath] = theirs;
+            addedCount++;
+            console.log(chalk.green(`  + ${relPath} (added by ${theirLabel})`));
+            continue;
+        }
+        if (!theirsFiles[relPath]) {
+            // Only in ours (theirs deleted or never had it)
+            merged[relPath] = ours;
+            continue;
+        }
+        const { merged: mergedContent, hasConflict } = merge3(base, ours, theirs, ourLabel, theirLabel);
+        merged[relPath] = mergedContent;
+        if (hasConflict) {
+            conflictCount++;
+            console.log(chalk.red(`  ✗ CONFLICT: ${relPath}`));
+        }
+        else if (mergedContent !== ours) {
+            autoMergedCount++;
+            console.log(chalk.cyan(`  ✓ Auto-merged: ${relPath}`));
+        }
+    }
+    // Write merged result to supabase/
+    await fs.rm('supabase', { recursive: true, force: true });
+    for (const [relPath, content] of Object.entries(merged)) {
         const fullPath = path.join('supabase', relPath);
         await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        const content = await readObject(hash);
         await fs.writeFile(fullPath, content, 'utf-8');
     }
-    console.log(chalk.green(`\nSuccessfully merged branch '${sourceBranch}' into your local files.`));
-    console.log(chalk.yellow(`Run 'gitb push' to apply these changes to the live '${config.currentBranch}' database.`));
+    console.log();
+    if (conflictCount > 0) {
+        console.log(chalk.red(`Merge complete with ${conflictCount} conflict(s).`));
+        console.log(chalk.yellow(`Find <<<<<<< markers, resolve them, then run 'gitb commit' and 'gitb push'.`));
+    }
+    else {
+        console.log(chalk.green(`Merge complete. ${autoMergedCount} auto-merged, ${addedCount} added.`));
+        console.log(chalk.yellow(`Run 'gitb commit -m "Merge ${sourceBranch} into ${currentBranch}"' then 'gitb push'.`));
+    }
 }

package/dist/commands/pull.js

@@ -0,0 +1,171 @@
+/**
+ * pull.ts — Sync local supabase/ files with the live database schema.
+ *
+ * Usage:
+ *   gitb pull                     Pull schema to local files
+ *   gitb pull --auto-commit       Pull + auto-commit with generated message
+ *   gitb pull -m "my message"     Pull + commit with specific message
+ */
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { getConfig } from '../api/supabase.js';
+import { extractSchema } from '../schema/extractor.js';
+import { canonicalize, hashString } from '../utils/hashing.js';
+const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+const HEAD_FILE = path.join(GITBASE_DIR, 'HEAD');
+// All schema types in write order
+const ALL_TYPES = [
+    'extensions', 'types', 'sequences', 'tables', 'matviews',
+    'views', 'functions', 'triggers', 'policies', 'grants', 'publications'
+];
+export async function pull(argv) {
+    const config = await getConfig();
+    if (!config) {
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
+        return;
+    }
+    const branchData = config.branches?.[config.currentBranch];
+    const projectRef = branchData?.projectRef ?? config.projectRef;
+    if (!projectRef) {
+        console.error(chalk.red('No project reference found. Re-run `gitb init`.'));
+        return;
+    }
+    console.log(chalk.blue(`Pulling schema from project ${projectRef}...`));
+    const schema = await extractSchema(projectRef);
+    // Write all schema files to supabase/<type>/<name>.sql
+    let written = 0;
+    let changed = 0;
+    const changedFiles = [];
+    for (const type of ALL_TYPES) {
+        const objects = schema[type];
+        if (!objects)
+            continue;
+        const dir = path.join('supabase', type);
+        await fs.mkdir(dir, { recursive: true });
+        for (const [name, sql] of Object.entries(objects)) {
+            const filePath = path.join(dir, `${name}.sql`);
+            const newContent = sql.trim() + '\n';
+            // Check if file changed
+            let existingContent = null;
+            try {
+                existingContent = await fs.readFile(filePath, 'utf-8');
+            }
+            catch { /* file doesn't exist yet */ }
+            const isChanged = existingContent === null ||
+                canonicalize(existingContent) !== canonicalize(newContent);
+            await fs.writeFile(filePath, newContent, 'utf-8');
+            written++;
+            if (isChanged) {
+                changed++;
+                changedFiles.push(`${type}/${name}.sql`);
+            }
+        }
+    }
+    if (changed === 0) {
+        console.log(chalk.green('\nAlready up to date. No schema changes detected.'));
+    }
+    else {
+        console.log(chalk.green(`\nPull complete. ${changed} file(s) updated:`));
+        for (const f of changedFiles.slice(0, 20)) {
+            console.log(chalk.cyan(`  ${f}`));
+        }
+        if (changedFiles.length > 20) {
+            console.log(chalk.gray(`  ... and ${changedFiles.length - 20} more`));
+        }
+    }
+    // --auto-commit or -m: auto-commit after pull
+    const autoCommit = argv['auto-commit'] || argv['autoCommit'];
+    const commitMessage = argv.m || argv.message;
+    if (autoCommit || commitMessage) {
+        if (changed === 0 && !commitMessage) {
+            console.log(chalk.gray('Nothing changed — skipping auto-commit.'));
+            return;
+        }
+        const message = commitMessage
+            || generateAutoCommitMessage(changedFiles);
+        await commitCurrentState(message, projectRef, config);
+    }
+}
+/**
+ * Generates a readable auto-commit message from the list of changed files.
+ * e.g. "Auto-snapshot: modified tables/users, new functions/send_email"
+ */
+function generateAutoCommitMessage(changedFiles) {
+    if (changedFiles.length === 0)
+        return 'Auto-snapshot: no changes';
+    if (changedFiles.length <= 3) {
+        return `Auto-snapshot: ${changedFiles.join(', ')}`;
+    }
+    return `Auto-snapshot: ${changedFiles.slice(0, 3).join(', ')} (+${changedFiles.length - 3} more)`;
+}
+/**
+ * Commits the current supabase/ working tree state.
+ * Mirrors the logic in commit.ts but callable as a function.
+ */
+async function commitCurrentState(message, projectRef, config) {
+    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.isFile() && entry.name.endsWith('.sql')) {
+                const content = await fs.readFile(fullPath, 'utf-8');
+                const hash = hashString(content);
+                await saveObject(hash, content);
+                tree[relPath] = hash;
+            }
+        }
+    }
+    await walk('supabase', '');
+    if (Object.keys(tree).length === 0) {
+        console.log(chalk.yellow('Nothing to commit.'));
+        return;
+    }
+    const sortedTree = Object.fromEntries(Object.entries(tree).sort(([a], [b]) => a.localeCompare(b)));
+    const treeJson = JSON.stringify(sortedTree);
+    const treeHash = hashString(treeJson);
+    await saveObject(treeHash, treeJson);
+    // Check if anything actually changed since last commit
+    let parent = null;
+    let parentTreeHash = null;
+    try {
+        parent = await fs.readFile(HEAD_FILE, 'utf-8');
+        if (parent) {
+            const parentCommitStr = await fs.readFile(path.join(OBJECTS_DIR, parent), 'utf-8');
+            parentTreeHash = JSON.parse(parentCommitStr).tree;
+        }
+    }
+    catch { }
+    if (parentTreeHash === treeHash) {
+        console.log(chalk.yellow('Nothing to commit (working tree clean).'));
+        return;
+    }
+    const commitObj = {
+        tree: treeHash,
+        parent,
+        message,
+        timestamp: new Date().toISOString(),
+        author: process.env.USERNAME || process.env.USER || 'unknown'
+    };
+    const commitJson = JSON.stringify(commitObj, null, 2);
+    const commitHash = hashString(commitJson);
+    await saveObject(commitHash, commitJson);
+    await fs.writeFile(HEAD_FILE, commitHash, 'utf-8');
+    // Update branch head in config
+    if (config.branches && config.currentBranch) {
+        config.branches[config.currentBranch].head = commitHash;
+        await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+    }
+    console.log(chalk.green(`\n[${commitHash.substring(0, 7)}] ${message}`));
+}
+async function saveObject(hash, content) {
+    await fs.mkdir(OBJECTS_DIR, { recursive: true });
+    await fs.writeFile(path.join(OBJECTS_DIR, hash), content, 'utf-8');
+}