@coldge.com/gitbase 1.0.2

package/dist/commands/remote.js

@@ -0,0 +1,142 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { getConfig, ensureBucket, listObjects, uploadObject, downloadObject } from '../api/supabase.js';
+const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+const OBJECTS_DIR = path.join(GITBASE_DIR, 'objects');
+const REFS_DIR = path.join(GITBASE_DIR, 'refs');
+export async function remote(argv) {
+    const subcommand = argv._[1];
+    switch (subcommand) {
+        case 'add':
+            await addRemote(argv);
+            break;
+        case 'list':
+            await listRemotes();
+            break;
+        case 'push':
+            await pushRemote(argv);
+            break;
+        case 'pull':
+            await pullRemote(argv);
+            break;
+        default:
+            console.log(chalk.yellow('Usage: gitb remote <add|list|push|pull> [args]'));
+    }
+}
+async function addRemote(argv) {
+    const name = argv.name || argv._[2];
+    const bucket = argv.bucket || argv._[3];
+    if (!name || !bucket) {
+        console.error(chalk.red('Usage: gitb remote add <name> <bucket>'));
+        return;
+    }
+    const config = await getConfig();
+    if (!config)
+        return;
+    config.remotes = config.remotes || {};
+    config.remotes[name] = { bucket };
+    await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+    console.log(chalk.green(`Remote '${name}' added pointing to bucket '${bucket}'.`));
+}
+async function listRemotes() {
+    const config = await getConfig();
+    if (!config || !config.remotes) {
+        console.log(chalk.yellow('No remotes configured.'));
+        return;
+    }
+    console.log(chalk.cyan('Remotes:'));
+    for (const [name, data] of Object.entries(config.remotes)) {
+        console.log(`  ${name} -> ${data.bucket}`);
+    }
+}
+async function pushRemote(argv) {
+    const name = argv.name || argv._[2];
+    if (!name) {
+        console.error(chalk.red('Remote name required.'));
+        return;
+    }
+    const config = await getConfig();
+    if (!config || !config.remotes || !config.remotes[name]) {
+        console.error(chalk.red(`Remote '${name}' not found.`));
+        return;
+    }
+    const bucket = config.remotes[name].bucket;
+    const projectRef = config.branches[config.currentBranch].projectRef;
+    console.log(chalk.blue(`Pushing history to remote '${name}' (${bucket})...`));
+    try {
+        await ensureBucket(projectRef, bucket);
+        // 1. Sync Objects
+        console.log(chalk.blue('Syncing objects...'));
+        const remoteObjects = await listObjects(projectRef, bucket, 'objects/');
+        const remoteHashes = new Set(remoteObjects.map((o) => o.name));
+        const localObjects = await fs.readdir(OBJECTS_DIR).catch(() => []);
+        let uploadedCount = 0;
+        for (const hash of localObjects) {
+            if (!remoteHashes.has(hash)) {
+                const content = await fs.readFile(path.join(OBJECTS_DIR, hash));
+                await uploadObject(projectRef, bucket, `objects/${hash}`, content);
+                uploadedCount++;
+            }
+        }
+        console.log(chalk.green(`Uploaded ${uploadedCount} new objects.`));
+        // 2. Sync Refs (Heads)
+        console.log(chalk.blue('Syncing refs...'));
+        for (const branchName of Object.keys(config.branches)) {
+            const head = config.branches[branchName].head;
+            if (head) {
+                // Check for conflict (non-fast-forward) would go here
+                // For MVP: Overwrite remote ref
+                await uploadObject(projectRef, bucket, `refs/heads/${branchName}`, head);
+            }
+        }
+        console.log(chalk.green('Refs updated.'));
+    }
+    catch (e) {
+        console.error(chalk.red(`Push failed: ${e.message}`));
+    }
+}
+async function pullRemote(argv) {
+    const name = argv.name || argv._[2];
+    if (!name) {
+        console.error(chalk.red('Remote name required.'));
+        return;
+    }
+    const config = await getConfig();
+    if (!config || !config.remotes || !config.remotes[name]) {
+        console.error(chalk.red(`Remote '${name}' not found.`));
+        return;
+    }
+    const bucket = config.remotes[name].bucket;
+    const projectRef = config.branches[config.currentBranch].projectRef;
+    console.log(chalk.blue(`Pulling history from remote '${name}'...`));
+    try {
+        // 1. Download missing objects
+        const remoteObjects = await listObjects(projectRef, bucket, 'objects/');
+        const localObjects = new Set(await fs.readdir(OBJECTS_DIR).catch(() => []));
+        let downloadedCount = 0;
+        for (const obj of remoteObjects) {
+            const hash = obj.name;
+            if (!localObjects.has(hash)) {
+                const content = await downloadObject(projectRef, bucket, `objects/${hash}`);
+                await fs.writeFile(path.join(OBJECTS_DIR, hash), content);
+                downloadedCount++;
+            }
+        }
+        console.log(chalk.green(`Downloaded ${downloadedCount} new objects.`));
+        // 2. Update remote-tracking branches
+        const remoteRefs = await listObjects(projectRef, bucket, 'refs/heads/');
+        await fs.mkdir(path.join(REFS_DIR, 'remotes', name), { recursive: true });
+        for (const ref of remoteRefs) {
+            const branchName = ref.name;
+            const head = await downloadObject(projectRef, bucket, `refs/heads/${branchName}`);
+            await fs.writeFile(path.join(REFS_DIR, 'remotes', name, branchName), head);
+            console.log(chalk.cyan(`  ${name}/${branchName} -> ${head.substring(0, 7)}`));
+        }
+        console.log(chalk.green('\nPull complete. Use `gitb merge` to incorporate changes.'));
+    }
+    catch (e) {
+        console.error(chalk.red(`Pull failed: ${e.message}`));
+    }
+}

package/dist/commands/revert.js

@@ -0,0 +1,233 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import readline from 'readline';
+import { readCommit, readTree, readObject } from '../storage/git.js';
+import { runQuery } from '../api/supabase.js';
+import toposort from 'toposort';
+const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+export async function revert(argv) {
+    // 1. Check Config
+    try {
+        await fs.access(CONFIG_FILE);
+    }
+    catch {
+        console.error(chalk.red('Not initialized.'));
+        return;
+    }
+    const config = JSON.parse(await fs.readFile(CONFIG_FILE, 'utf-8'));
+    const currentBranch = config.currentBranch;
+    const projectRef = config.branches[currentBranch].projectRef;
+    // RBAC: Production Protection
+    if (currentBranch === 'production') {
+        const { isProductionAdmin } = await import('../api/supabase.js');
+        console.log(chalk.blue('Verifying production permissions...'));
+        const isAdmin = await isProductionAdmin(projectRef);
+        if (!isAdmin) {
+            console.error(chalk.red('\n🔥 ACCESS DENIED: Only Owners or Administrators can revert the production branch.'));
+            return;
+        }
+        console.log(chalk.green('Permission verified.'));
+    }
+    // 2. Load Commit
+    let commitHash = argv.commit;
+    if (!commitHash) {
+        try {
+            commitHash = await fs.readFile(path.join(GITBASE_DIR, 'HEAD'), 'utf-8');
+            if (!commitHash)
+                throw new Error();
+        }
+        catch {
+            console.error(chalk.red('No commits found or HEAD is missing.'));
+            return;
+        }
+    }
+    let commit;
+    try {
+        commit = await readCommit(commitHash);
+    }
+    catch {
+        console.error(chalk.red(`Commit ${commitHash} not found.`));
+        return;
+    }
+    console.log(chalk.blue(`Reverting to commit ${commitHash} (${commit.message})...`));
+    // 3. Fetch current live state to make smart decisions
+    console.log(chalk.blue(`Checking current database state...`));
+    const { extractSchema } = await import('../schema/extractor.js');
+    const liveSchema = await extractSchema(projectRef);
+    // 4. Load Tree & Parse
+    const tree = await readTree(commit.tree);
+    const schema = { tables: {}, functions: {}, views: {}, triggers: {}, policies: {}, types: {} };
+    const filterFiles = argv.files || [];
+    for (const [relPath, hash] of Object.entries(tree)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(relPath))
+            continue;
+        const parts = relPath.split('/');
+        // relPath corresponds to file structure, e.g., "tables/users.sql"
+        const type = parts[0];
+        const name = path.basename(relPath, '.sql');
+        const content = await readObject(hash);
+        if (schema[type]) {
+            schema[type][name] = content;
+        }
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+    // 4. Execution Plan
+    const { canonicalize } = await import('../utils/hashing.js');
+    let madeDbChanges = false;
+    // TYPES
+    for (const [name, sql] of Object.entries(schema.types)) {
+        if (liveSchema.types[name] && canonicalize(sql) === canonicalize(liveSchema.types[name])) {
+            continue;
+        }
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Restoring Type: ${name}`));
+        await runQuery(projectRef, `DROP TYPE IF EXISTS public."${name}" CASCADE;`);
+        await runQuery(projectRef, sql);
+    }
+    // TABLES (Topological Sort)
+    const tableEdges = [];
+    const tables = schema.tables;
+    const tableNames = Object.keys(tables);
+    for (const [name, sql] of Object.entries(tables)) {
+        const content = sql;
+        const regex = /REFERENCES\s+(?:public\.)?(\w+)/gi;
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const target = match[1];
+            if (target !== name && tables[target]) {
+                tableEdges.push([target, name]); // target -> name
+            }
+        }
+    }
+    let sortedTables = tableNames;
+    try {
+        sortedTables = toposort.array(tableNames, tableEdges);
+    }
+    catch (e) {
+        console.warn(chalk.yellow('Circular dependency detected in tables. Falling back to alphabetical order.'));
+        sortedTables = tableNames.sort();
+    }
+    for (const name of sortedTables) {
+        const sql = tables[name];
+        if (!sql)
+            continue;
+        if (liveSchema.tables[name] && canonicalize(sql) === canonicalize(liveSchema.tables[name])) {
+            continue;
+        }
+        madeDbChanges = true;
+        console.log(chalk.yellow(`\nRestoring Table: ${name}`));
+        if (liveSchema.tables[name]) {
+            const answer = await ask(chalk.white(`? Keep existing '${name}' table as backup? (Y/n) > `));
+            if (answer.toLowerCase() !== 'n') {
+                const timestamp = Math.floor(Date.now() / 1000);
+                const backupName = `${name}_backup_${timestamp}`;
+                console.log(chalk.gray(`Backing up to ${backupName}...`));
+                try {
+                    await runQuery(projectRef, `ALTER TABLE public."${name}" RENAME TO "${backupName}";`);
+                    console.log(chalk.green('Backup successful.'));
+                }
+                catch (e) {
+                    console.log(chalk.red(`Backup failed: ${e.message}`));
+                }
+            }
+            else {
+                console.log(chalk.red(`Dropping table ${name}...`));
+                await runQuery(projectRef, `DROP TABLE IF EXISTS public."${name}" CASCADE;`);
+            }
+        }
+        else {
+            console.log(chalk.gray(`Table '${name}' does not exist in live database. Skipping backup.`));
+        }
+        console.log(chalk.cyan(`Creating table ${name}...`));
+        try {
+            await runQuery(projectRef, sql);
+        }
+        catch (e) {
+            console.error(chalk.red(`Failed to create table: ${e.message}`));
+        }
+    }
+    // VIEWS
+    for (const [name, sql] of Object.entries(schema.views)) {
+        if (liveSchema.views[name] && canonicalize(sql) === canonicalize(liveSchema.views[name])) {
+            continue;
+        }
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Restoring View: ${name}`));
+        await runQuery(projectRef, `DROP VIEW IF EXISTS public."${name}" CASCADE;`);
+        await runQuery(projectRef, sql);
+    }
+    // FUNCTIONS
+    for (const [name, sql] of Object.entries(schema.functions)) {
+        if (liveSchema.functions[name] && canonicalize(sql) === canonicalize(liveSchema.functions[name])) {
+            continue;
+        }
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Restoring Function: ${name}`));
+        await runQuery(projectRef, sql);
+    }
+    // TRIGGERS
+    for (const [name, sql] of Object.entries(schema.triggers)) {
+        if (liveSchema.triggers[name] && canonicalize(sql) === canonicalize(liveSchema.triggers[name])) {
+            continue;
+        }
+        madeDbChanges = true;
+        console.log(chalk.cyan(`Restoring Trigger: ${name}`));
+        const match = sql.match(/ON\s+(public\.)?("?\w+"?)/i);
+        if (match) {
+            const tableName = match[2].replace(/"/g, '');
+            await runQuery(projectRef, `DROP TRIGGER IF EXISTS "${name}" ON public."${tableName}";`);
+        }
+        await runQuery(projectRef, sql);
+    }
+    // POLICIES
+    for (const [key, sql] of Object.entries(schema.policies)) {
+        if (liveSchema.policies[key] && canonicalize(sql) === canonicalize(liveSchema.policies[key])) {
+            continue;
+        }
+        madeDbChanges = true;
+        const match = sql.match(/CREATE POLICY "([^"]+)"\s+ON\s+(public\.)?("?\w+"?)/i);
+        if (match) {
+            const policyName = match[1];
+            const tableName = match[3].replace(/"/g, '');
+            console.log(chalk.cyan(`Restoring Policy: ${policyName} on ${tableName}`));
+            // Auto-enable RLS just in case the table creation didn't include it (for backwards compatibility with older commits)
+            try {
+                await runQuery(projectRef, `ALTER TABLE public."${tableName}" ENABLE ROW LEVEL SECURITY;`);
+            }
+            catch (e) { }
+            await runQuery(projectRef, `DROP POLICY IF EXISTS "${policyName}" ON public."${tableName}";`);
+            await runQuery(projectRef, sql);
+        }
+    }
+    // 5. Update local working tree
+    // Clear existing supabase directory safely
+    if (filterFiles.length === 0) {
+        try {
+            await fs.rm('supabase', { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+    // Recreate files from tree
+    for (const [relPath, hash] of Object.entries(tree)) {
+        if (filterFiles.length > 0 && !filterFiles.includes(relPath))
+            continue;
+        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');
+    }
+    rl.close();
+    if (!madeDbChanges) {
+        console.log(chalk.green('\nNo database changes were required. The live database already matches this commit.'));
+    }
+    else {
+        console.log(chalk.green('\nDatabase reset complete!'));
+    }
+    console.log(chalk.gray('Local files have been synchronized.'));
+}

package/dist/commands/status.js

@@ -0,0 +1,96 @@
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import { extractSchema } from '../schema/extractor.js';
+import { canonicalize } from '../utils/hashing.js';
+const GITBASE_DIR = '.gitbase';
+const CONFIG_FILE = path.join(GITBASE_DIR, 'config');
+export async function status() {
+    const changes = await getStatus();
+    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}`));
+            }
+        }
+    }
+}
+export async function getStatus() {
+    // Check if initialized
+    try {
+        await fs.access(CONFIG_FILE);
+    }
+    catch {
+        console.error(chalk.red('Not initialized. Run `gitb init` first.'));
+        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?
+    let liveSchema;
+    try {
+        liveSchema = await extractSchema(projectRef);
+    }
+    catch (e) {
+        console.error(chalk.red(`Failed to fetch schema: ${e.message}`));
+        return null;
+    }
+    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);
+    return changes;
+}
+async function checkType(liveObjects, type, changes) {
+    const dir = path.join('supabase', type);
+    // Ensure dir exists
+    try {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    catch { }
+    const localFiles = await fs.readdir(dir).catch(() => []);
+    const localMap = {};
+    for (const file of localFiles) {
+        if (!file.endsWith('.sql'))
+            continue;
+        const name = file.replace('.sql', '');
+        const content = await fs.readFile(path.join(dir, file), 'utf-8');
+        localMap[name] = content;
+    }
+    // Check for 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 });
+            }
+        }
+    }
+    // Check for Deleted
+    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/whoami.js

@@ -0,0 +1,19 @@
+import chalk from 'chalk';
+import { getToken } from '../utils/config.js';
+import { getProjects } from '../api/supabase.js';
+export async function whoami() {
+    const token = await getToken();
+    if (!token) {
+        console.log(chalk.red('Not logged in. Run `gitb login`.'));
+        return;
+    }
+    console.log(chalk.blue(`Token: ${token.substring(0, 4)}...${token.substring(token.length - 4)}`));
+    try {
+        const projects = await getProjects();
+        console.log(chalk.green(`Logged in successfully. You have access to ${projects.length} project(s).`));
+        console.log(chalk.gray('Manage your tokens and account at: https://supabase.com/dashboard/account/tokens'));
+    }
+    catch (e) {
+        console.log(chalk.red(`Invalid or expired token: ${e.message}`));
+    }
+}

package/dist/index.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+yargs(hideBin(process.argv))
+    .scriptName('gitb')
+    .usage('$0 <cmd> [args]')
+    .command('login', 'Authenticate with Supabase', {}, async (argv) => {
+    const { login } = await import('./commands/login.js');
+    await login();
+})
+    .command('whoami', 'Show current authentication status', {}, async (argv) => {
+    const { whoami } = await import('./commands/whoami.js');
+    await whoami();
+})
+    .command('init', 'Initialize gitbase in the current directory', (yargs) => {
+    return yargs.option('force', {
+        alias: 'f',
+        type: 'boolean',
+        description: 'Force re-initialization'
+    });
+}, async (argv) => {
+    const { init } = await import('./commands/init.js');
+    await init(argv);
+})
+    .command('status', 'Show the working tree status', {}, async (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',
+        type: 'string',
+        array: true
+    });
+}, async (argv) => {
+    const { add } = await import('./commands/add.js');
+    await add(argv);
+})
+    .command('commit', 'Record changes to the repository', (yargs) => {
+    return yargs.option('message', {
+        alias: 'm',
+        type: 'string',
+        description: 'Commit message',
+        demandOption: true
+    });
+}, async (argv) => {
+    const { commit } = await import('./commands/commit.js');
+    await commit(argv);
+})
+    .command(['revert [commit]', 'reset [commit]'], 'Revert to a previous state', (yargs) => {
+    return yargs.positional('commit', {
+        describe: 'Commit hash to revert to (defaults to last commit)',
+        type: 'string'
+    }).option('files', {
+        describe: 'Specific files to revert',
+        type: 'string',
+        array: true
+    });
+}, async (argv) => {
+    const { revert } = await import('./commands/revert.js');
+    await revert(argv);
+})
+    .command('log', 'Show commit logs', {}, async (argv) => {
+    const { log } = await import('./commands/log.js');
+    await log();
+})
+    .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)',
+        type: 'string'
+    });
+}, async (argv) => {
+    const { diff } = await import('./commands/diff.js');
+    await diff(argv);
+})
+    .command('push [files..]', 'Push local changes to the live database', (yargs) => {
+    return yargs.positional('files', {
+        describe: 'Specific files to push',
+        type: 'string',
+        array: true
+    });
+}, async (argv) => {
+    const { push } = await import('./commands/push.js');
+    await push(argv);
+})
+    .command('branch [name]', 'List or create branches', (yargs) => {
+    return yargs.positional('name', {
+        describe: 'Name of the branch to create',
+        type: 'string'
+    }).option('delete', {
+        alias: 'd',
+        type: 'boolean',
+        description: 'Delete a branch'
+    });
+}, async (argv) => {
+    const { branch } = await import('./commands/branch.js');
+    await branch(argv);
+})
+    .command('checkout <name>', 'Switch branches', (yargs) => {
+    return yargs.positional('name', {
+        describe: 'Name of the branch to switch to',
+        type: 'string',
+        demandOption: true
+    });
+}, async (argv) => {
+    const { checkout } = await import('./commands/branch.js');
+    await checkout(argv);
+})
+    .command('merge <name>', 'Merge another branch into the current one', (yargs) => {
+    return yargs.positional('name', {
+        describe: 'Name of the branch to merge from',
+        type: 'string',
+        demandOption: true
+    });
+}, async (argv) => {
+    const { merge } = await import('./commands/merge.js');
+    await merge(argv);
+})
+    .command('remote <subcommand> [args]', 'Manage remote history repositories', (yargs) => {
+    return yargs.positional('subcommand', {
+        describe: 'Digital subcommand (add, list, push, pull)',
+        type: 'string',
+        choices: ['add', 'list', 'push', 'pull']
+    });
+}, async (argv) => {
+    const { remote } = await import('./commands/remote.js');
+    await remote(argv);
+})
+    .help()
+    .parse();