gent-cli 2.1.0 → 5.0.1

package/src/commands/pull.js

@@ -1,123 +1,213 @@
 /**
- * Pull Command - Pull commits from cloud to local repository
- * Downloads commits, trees, and blobs from the cloud
+ * ============================================================================
+ * Pull Command - Fetch and merge remote commits into local branch
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Download new commits from remote and merge into current branch.
+ *   Like `git pull` (fetch + merge in one step).
+ *
+ * USAGE:
+ *   gent pull                          → Pull from origin/current-branch
+ *   gent pull <remote> <branch>        → Pull specific remote/branch
+ *
+ * ALGORITHM:
+ *   1. GET /api/repos/:id/pull/?branch=<branch>&since=<lastKnownHash>
+ *   2. Receive commits + blob objects
+ *   3. Store blobs in local object store
+ *   4. Append commits to local history
+ *   5. If diverged: run 3-way merge (same as gent merge)
+ *   6. If fast-forward: just advance pointer
+ *
+ * BACKEND EXPECTATIONS:
+ *   GET /api/repos/:id/pull/?branch=main&since=abc1234
+ *   Returns:
+ *   {
+ *     branch: "main",
+ *     commits: [...],
+ *     objects: [ { hash, type, data: "<base64>" } ],
+ *     head: "<remoteHeadHash>"
+ *   }
+ *
+ * ============================================================================
  */
 
-const chalk = require('chalk');
+const fs = require('fs').promises;
 const path = require('path');
+const chalk = require('chalk');
 const ora = require('ora');
-const { pathExists, readJSON, writeJSON } = require('../utils/fileSystem');
-const { GENT_DIR, COMMITS_FILE } = require('../utils/constants');
-const { getRemote, syncCommitsFromCloud } = require('../utils/cloud-sync');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
 const authStorage = require('../utils/auth-storage');
-const repoService = require('../services/repo-service');
+const { storeBlob, objectExists } = require('../utils/hash-engine');
+const { findMergeBase, mergeTreeEntries } = require('../utils/merge-engine');
+const { generateCommitHash } = require('../utils/helpers');
 
 /**
- * Pull commits from cloud to local
- * @param {string} remoteName - Remote name (default: origin)
- * @param {string} branchName - Branch name (optional)
- * @param {Object} options - Command options
+ * Pull remote commits
+ * @param {String} remoteName
+ * @param {String} branchName
+ * @param {Object} options
  */
 async function pull(remoteName, branchName, options) {
+    const spinner = ora('Pulling from remote...').start();
+
     try {
-        const cwd = process.cwd();
-        const gentPath = path.join(cwd, GENT_DIR);
-
-        // Check if in a gent repository
-        if (!(await pathExists(gentPath))) {
-            console.error(chalk.red('Error: Not a gent repository'));
-            console.log(chalk.yellow('Run'), chalk.cyan('gent init'), chalk.yellow('to initialize a repository'));
-            process.exit(1);
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            spinner.fail(chalk.red('Not authenticated'));
+            console.log(chalk.yellow('Run "gent login" first'));
+            return;
         }
 
-        // Check authentication
-        const user = await authStorage.getUser();
-        if (!user) {
-            console.error(chalk.red('Error: You must be logged in to pull'));
-            console.log(chalk.yellow('Run'), chalk.cyan('gent login'), chalk.yellow('to authenticate'));
-            process.exit(1);
+        const gentPath = await getGentPath();
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        config.remotes = config.remotes || {};
+
+        const remote = remoteName || 'origin';
+        const remoteConfig = config.remotes[remote];
+        if (!remoteConfig) {
+            spinner.fail(chalk.red(`Remote '${remote}' not found`));
+            return;
         }
 
-        // Default to 'origin' if no remote specified
-        remoteName = remoteName || 'origin';
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const branch = branchName || repository.currentBranch;
+        const localHead = repository.branches[branch] || null;
 
-        // Get remote configuration
-        const remote = await getRemote(remoteName, cwd);
-        if (!remote) {
-            console.error(chalk.red(`Error: Remote '${remoteName}' not found`));
-            console.log(chalk.yellow('Add a remote with:'), chalk.cyan('gent remote add origin <owner_id>/<repo_name>'));
-            console.log(chalk.yellow('Or list remotes with:'), chalk.cyan('gent remote'));
-            process.exit(1);
-        }
+        // Fetch from remote
+        config.remoteRefs = config.remoteRefs || {};
+        const since = config.remoteRefs[`${remote}/${branch}`] || localHead || '';
 
-        // Get current branch if not specified
-        const commitsData = await readJSON(path.join(gentPath, COMMITS_FILE));
-        branchName = branchName || commitsData.currentBranch;
+        spinner.text = `Fetching from ${remote}/${branch}...`;
 
-        if (!branchName) {
-            console.error(chalk.red('Error: No branch specified and no current branch found'));
-            process.exit(1);
-        }
+        const response = await apiClient.get(
+            `${remoteConfig.url}/pull/`,
+            { params: { branch, since } }
+        );
 
-        console.log(chalk.cyan(`Pulling from ${remoteName}/${branchName}...\n`));
+        const remoteCommits = response.commits || [];
+        const remoteObjects = response.objects || [];
+        const remoteHead = response.head;
 
-        // Verify repository exists
-        const spinner = ora('Verifying remote repository...').start();
-        try {
-            await repoService.getRepository(remote.owner_id, remote.repo_name);
-            spinner.succeed('Remote repository verified');
-        } catch (error) {
-            spinner.fail('Remote repository not found or access denied');
-            throw error;
+        if (remoteCommits.length === 0) {
+            spinner.succeed(chalk.green('Already up-to-date'));
+            return;
         }
 
-        // Pull commits
-        const cloudCommits = await syncCommitsFromCloud(remote.owner_id, remote.repo_name, cwd);
-
-        // Update local commits file with cloud commits
-        const localCommits = commitsData.commits || [];
-        const mergedCommits = [...localCommits];
-
-        // Add cloud commits that don't exist locally
-        for (const cloudCommit of cloudCommits) {
-            const exists = localCommits.find(c => c.sha === cloudCommit.sha);
-            if (!exists) {
-                // Convert cloud commit format to local format
-                mergedCommits.push({
-                    sha: cloudCommit.sha,
-                    message: cloudCommit.message,
-                    author: {
-                        name: cloudCommit.author_name,
-                        email: cloudCommit.author_email
-                    },
-                    timestamp: cloudCommit.committed_at,
-                    parent: cloudCommit.parent_shas || [],
-                    files: cloudCommit.files || []
-                });
+        // Store received blob objects
+        spinner.text = `Storing ${remoteObjects.length} object(s)...`;
+        for (const obj of remoteObjects) {
+            if (obj.type === 'blob' && obj.data) {
+                const buf = Buffer.from(obj.data, 'base64');
+                await storeBlob(gentPath, buf);
             }
         }
 
-        // Update branch pointer if we have cloud commits
-        if (cloudCommits.length > 0) {
-            const latestCloudCommit = cloudCommits[cloudCommits.length - 1];
-            commitsData.branches[branchName] = latestCloudCommit.sha;
+        // Check if fast-forward is possible
+        const allCommits = [...(repository.commits || []), ...remoteCommits];
+        const commitSet = new Set((repository.commits || []).map(c => c.hash));
+
+        // Add new commits (dedup)
+        let newCount = 0;
+        for (const commit of remoteCommits) {
+            if (!commitSet.has(commit.hash)) {
+                repository.commits.push(commit);
+                commitSet.add(commit.hash);
+                newCount++;
+            }
         }
 
-        commitsData.commits = mergedCommits;
+        if (!localHead || isAncestor(repository.commits, localHead, remoteHead)) {
+            // Fast-forward
+            repository.branches[branch] = remoteHead;
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
 
-        await writeJSON(path.join(gentPath, COMMITS_FILE), commitsData);
+            config.remoteRefs[`${remote}/${branch}`] = remoteHead;
+            await writeJSON(path.join(gentPath, CONFIG_FILE), config);
 
-        if (cloudCommits.length > 0) {
-            console.log(chalk.green(`\n✓ Successfully pulled ${cloudCommits.length} commit(s) from ${remoteName}/${branchName}`));
+            spinner.succeed(chalk.green(`Fast-forward: ${newCount} new commit(s)`));
+            console.log(chalk.gray(`  ${remote}/${branch} → ${remoteHead.substring(0, 7)}`));
         } else {
-            console.log(chalk.yellow('Already up to date'));
+            // Diverged — need 3-way merge
+            spinner.text = 'Branches diverged, merging...';
+
+            const baseHash = findMergeBase(repository.commits, localHead, remoteHead);
+            const getTree = (hash) => {
+                const c = repository.commits.find(x => x.hash === hash);
+                if (!c) return [];
+                return c.tree || (c.files || []).map(f => ({
+                    mode: '100644', name: f.path || f.name, hash: f.hash, type: 'blob'
+                }));
+            };
+
+            const baseTree = baseHash ? getTree(baseHash) : [];
+            const oursTree = getTree(localHead);
+            const theirsTree = getTree(remoteHead);
+
+            const mergeResult = await mergeTreeEntries(gentPath, baseTree, oursTree, theirsTree);
+
+            // Build merge commit
+            const { storeTree } = require('../utils/hash-engine');
+            const mergedTreeHash = await storeTree(gentPath, mergeResult.mergedEntries);
+
+            const mergeCommit = {
+                hash: generateCommitHash(),
+                message: `Merge remote-tracking branch '${remote}/${branch}'`,
+                author: (repository.commits.find(c => c.hash === localHead) || {}).author || { name: 'Unknown', email: '' },
+                timestamp: new Date().toISOString(),
+                parent: localHead,
+                mergeParent: remoteHead,
+                treeHash: mergedTreeHash,
+                tree: mergeResult.mergedEntries,
+                files: mergeResult.mergedEntries.map(e => ({ path: e.name, hash: e.hash })),
+                stats: { filesChanged: mergeResult.mergedEntries.length, insertions: 0, deletions: 0 }
+            };
+
+            repository.commits.push(mergeCommit);
+            repository.branches[branch] = mergeCommit.hash;
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+            config.remoteRefs[`${remote}/${branch}`] = remoteHead;
+            await writeJSON(path.join(gentPath, CONFIG_FILE), config);
+
+            if (mergeResult.hasConflicts) {
+                spinner.warn(chalk.yellow(`Pulled with ${mergeResult.conflicts.length} conflict(s)`));
+                for (const c of mergeResult.conflicts) {
+                    console.log(chalk.red(`  CONFLICT: ${c.file} (${c.type})`));
+                }
+                console.log(chalk.yellow('\nResolve conflicts, then "gent add" + "gent commit"'));
+            } else {
+                spinner.succeed(chalk.green(`Merged ${newCount} remote commit(s)`));
+                console.log(chalk.gray(`  Merge commit: ${mergeCommit.hash.substring(0, 7)}`));
+            }
         }
-
     } catch (error) {
-        console.error(chalk.red('Failed to pull'));
-        console.error(chalk.red('Error:'), error.message);
+        spinner.fail(chalk.red('Pull failed'));
+        if (error.response?.status === 401) {
+            console.error(chalk.red('Authentication failed — run "gent login"'));
+        } else if (error.response?.data?.message) {
+            console.error(chalk.red(error.response.data.message));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
         process.exit(1);
     }
 }
 
+/**
+ * Check if hashA is ancestor of hashB
+ */
+function isAncestor(commits, hashA, hashB) {
+    const commitMap = new Map(commits.map(c => [c.hash, c]));
+    let cur = hashB;
+    while (cur) {
+        if (cur === hashA) return true;
+        const c = commitMap.get(cur);
+        cur = c ? c.parent : null;
+    }
+    return false;
+}
+
 module.exports = pull;

package/src/commands/push.js

@@ -1,113 +1,206 @@
 /**
- * Push Command - Push local commits to cloud repository
- * Uploads commits, trees, and blobs to the cloud
+ * ============================================================================
+ * Push Command - Upload local commits and objects to remote
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Send local commits, blobs, and tree objects to the backend API server.
+ *   Like `git push`.
+ *
+ * USAGE:
+ *   gent push                          → Push current branch to origin
+ *   gent push <remote> <branch>        → Push specific branch to remote
+ *   gent push --force                  → Force push (overwrite remote)
+ *
+ * ALGORITHM:
+ *   1. Read local commits since last known remote HEAD
+ *   2. Collect all blob objects referenced by those commits
+ *   3. POST packfile (commits + blobs + trees) to remote /push/ endpoint
+ *   4. Remote updates branch pointer
+ *
+ * DATA FORMAT SENT TO BACKEND:
+ *   POST /api/repos/:id/push/
+ *   {
+ *     branch: "main",
+ *     force: false,
+ *     commits: [ { hash, message, author, timestamp, parent, treeHash, tree, files, stats } ],
+ *     objects: [ { hash, type: "blob", data: "<base64>" } ],
+ *     tags: { "v1.0": { hash, message, ... } }
+ *   }
+ *
+ * BACKEND EXPECTATIONS:
+ *   - Validate auth (JWT Bearer token)
+ *   - Verify fast-forward (reject non-ff unless force=true)
+ *   - Store blob objects in backend object store
+ *   - Append commits to branch history
+ *   - Update branch refs
+ *   - Return { success, ref, hash }
+ *
+ * ============================================================================
  */
 
-const chalk = require('chalk');
+const fs = require('fs').promises;
 const path = require('path');
+const chalk = require('chalk');
 const ora = require('ora');
-const { pathExists, readJSON } = require('../utils/fileSystem');
-const { GENT_DIR, COMMITS_FILE } = require('../utils/constants');
-const { getRemote, syncCommitsToCloud } = require('../utils/cloud-sync');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
 const authStorage = require('../utils/auth-storage');
-const repoService = require('../services/repo-service');
+const { readBlob, objectExists } = require('../utils/hash-engine');
 
 /**
- * Push local commits to cloud
- * @param {string} remoteName - Remote name (default: origin)
- * @param {string} branchName - Branch name (optional)
- * @param {Object} options - Command options
+ * Push commits to remote
+ * @param {String} remoteName
+ * @param {String} branchName
+ * @param {Object} options
  */
 async function push(remoteName, branchName, options) {
-    try {
-        const cwd = process.cwd();
-        const gentPath = path.join(cwd, GENT_DIR);
-
-        // Check if in a gent repository
-        if (!(await pathExists(gentPath))) {
-            console.error(chalk.red('Error: Not a gent repository'));
-            console.log(chalk.yellow('Run'), chalk.cyan('gent init'), chalk.yellow('to initialize a repository'));
-            process.exit(1);
-        }
-
-        // Check authentication
-        const user = await authStorage.getUser();
-        if (!user) {
-            console.error(chalk.red('Error: You must be logged in to push'));
-            console.log(chalk.yellow('Run'), chalk.cyan('gent login'), chalk.yellow('to authenticate'));
-            process.exit(1);
-        }
+    const spinner = ora('Preparing push...').start();
 
-        // Default to 'origin' if no remote specified
-        remoteName = remoteName || 'origin';
-
-        // Get remote configuration
-        const remote = await getRemote(remoteName, cwd);
-        if (!remote) {
-            console.error(chalk.red(`Error: Remote '${remoteName}' not found`));
-            console.log(chalk.yellow('Add a remote with:'), chalk.cyan('gent remote add origin <owner_id>/<repo_name>'));
-            console.log(chalk.yellow('Or list remotes with:'), chalk.cyan('gent remote'));
-            process.exit(1);
+    try {
+        // Auth check
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            spinner.fail(chalk.red('Not authenticated'));
+            console.log(chalk.yellow('Run "gent login" first'));
+            return;
         }
 
-        // Get current branch if not specified
-        const commitsData = await readJSON(path.join(gentPath, COMMITS_FILE));
-        branchName = branchName || commitsData.currentBranch;
-
-        if (!branchName) {
-            console.error(chalk.red('Error: No branch specified and no current branch found'));
-            process.exit(1);
+        const gentPath = await getGentPath();
+        const configPath = path.join(gentPath, CONFIG_FILE);
+        const config = await readJSON(configPath);
+        config.remotes = config.remotes || {};
+
+        // Resolve remote
+        const remote = remoteName || 'origin';
+        const remoteConfig = config.remotes[remote];
+        if (!remoteConfig) {
+            spinner.fail(chalk.red(`Remote '${remote}' not found`));
+            console.log(chalk.yellow('Use "gent remote add origin <url>" to configure'));
+            return;
         }
 
-        // Get commits for the branch
-        const commits = commitsData.commits || [];
-        const branchCommitSha = commitsData.branches[branchName];
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const branch = branchName || repository.currentBranch;
+        const localHead = repository.branches[branch];
 
-        if (!branchCommitSha) {
-            console.error(chalk.red(`Error: Branch '${branchName}' not found`));
-            process.exit(1);
+        if (!localHead) {
+            spinner.fail(chalk.red(`Branch '${branch}' has no commits`));
+            return;
         }
 
-        // Get commits to push (find all commits in the branch)
-        const commitsToPush = [];
-        let currentSha = branchCommitSha;
-
-        while (currentSha) {
-            const commit = commits.find(c => (c.sha || c.hash) === currentSha);
-            if (!commit) break;
-
-            commitsToPush.unshift(commit); // Add to beginning to maintain order
-            const parents = Array.isArray(commit.parent) ? commit.parent : (commit.parent ? [commit.parent] : []);
-            currentSha = parents.length > 0 ? parents[0] : null;
-        }
+        // Determine which commits to push (since last pushed ref)
+        config.remoteRefs = config.remoteRefs || {};
+        const lastPushed = config.remoteRefs[`${remote}/${branch}`] || null;
+        const commits = repository.commits || [];
+        const commitsToPush = getCommitsSince(commits, localHead, lastPushed);
 
         if (commitsToPush.length === 0) {
-            console.log(chalk.yellow('Nothing to push'));
+            spinner.succeed(chalk.green('Everything up-to-date'));
             return;
         }
 
-        console.log(chalk.cyan(`Pushing ${commitsToPush.length} commit(s) to ${remoteName}/${branchName}...`));
+        spinner.text = `Pushing ${commitsToPush.length} commit(s) to ${remote}/${branch}...`;
 
-        // Verify repository exists
-        const spinner = ora('Verifying remote repository...').start();
-        try {
-            await repoService.getRepository(remote.owner_id, remote.repo_name);
-            spinner.succeed('Remote repository verified');
-        } catch (error) {
-            spinner.fail('Remote repository not found or access denied');
-            throw error;
+        // Collect all blob hashes from commits to push
+        const blobHashes = new Set();
+        for (const commit of commitsToPush) {
+            const tree = commit.tree || commit.files || [];
+            for (const entry of tree) {
+                const h = entry.hash;
+                if (h) blobHashes.add(h);
+            }
         }
 
-        // Push commits
-        await syncCommitsToCloud(commitsToPush, remote.owner_id, remote.repo_name, branchName, cwd);
+        // Read blob data for transfer
+        const objects = [];
+        for (const hash of blobHashes) {
+            try {
+                if (await objectExists(gentPath, hash)) {
+                    const data = await readBlob(gentPath, hash);
+                    objects.push({
+                        hash,
+                        type: 'blob',
+                        data: data.toString('base64')
+                    });
+                }
+            } catch {
+                // Skip missing blobs
+            }
+        }
 
-        console.log(chalk.green(`\n✓ Successfully pushed to ${remoteName}/${branchName}`));
+        // Build push payload
+        const payload = {
+            branch,
+            force: !!options.force,
+            commits: commitsToPush.map(c => ({
+                hash: c.hash,
+                message: c.message,
+                author: c.author,
+                timestamp: c.timestamp,
+                parent: c.parent,
+                mergeParent: c.mergeParent || null,
+                treeHash: c.treeHash || null,
+                tree: c.tree || null,
+                files: c.files || [],
+                stats: c.stats || {}
+            })),
+            objects,
+            tags: repository.tags || {}
+        };
+
+        // Send to backend
+        const response = await apiClient.post(
+            `${remoteConfig.url}/push/`,
+            payload
+        );
+
+        // Update remote ref
+        config.remoteRefs[`${remote}/${branch}`] = localHead;
+        await writeJSON(configPath, config);
+
+        spinner.succeed(chalk.green(`Pushed ${commitsToPush.length} commit(s) to ${remote}/${branch}`));
+        console.log(chalk.gray(`  ${localHead.substring(0, 7)} → ${remote}/${branch}`));
+        console.log(chalk.gray(`  ${objects.length} object(s) transferred`));
 
     } catch (error) {
-        console.error(chalk.red('Failed to push'));
-        console.error(chalk.red('Error:'), error.message);
+        spinner.fail(chalk.red('Push failed'));
+
+        if (error.response?.status === 409) {
+            console.error(chalk.red('Remote has changes you don\'t have locally'));
+            console.log(chalk.yellow('Run "gent pull" first, or use "gent push --force"'));
+        } else if (error.response?.status === 401) {
+            console.error(chalk.red('Authentication failed — run "gent login"'));
+        } else if (error.response?.data?.message) {
+            console.error(chalk.red(error.response.data.message));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
         process.exit(1);
     }
 }
 
+/**
+ * Get commits from tip back to (but excluding) stopHash.
+ * @param {Array} allCommits
+ * @param {String} tipHash
+ * @param {String|null} stopHash
+ * @returns {Array}
+ */
+function getCommitsSince(allCommits, tipHash, stopHash) {
+    const commitMap = new Map(allCommits.map(c => [c.hash, c]));
+    const result = [];
+    let current = tipHash;
+
+    while (current && current !== stopHash) {
+        const commit = commitMap.get(current);
+        if (!commit) break;
+        result.push(commit);
+        current = commit.parent;
+    }
+
+    return result.reverse(); // oldest first
+}
+
 module.exports = push;