gent-cli 2.0.0 → 5.0.0

package/src/commands/merge.js

@@ -0,0 +1,245 @@
+/**
+ * Merge Command - Merge a branch into the current branch
+ * Uses 3-way smart merge with automatic conflict resolution
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { getGentPath, readJSON, writeJSON, pathExists } = require('../utils/fileSystem');
+const { COMMITS_FILE, STAGING_FILE, CONFIG_FILE } = require('../utils/constants');
+const { generateCommitHash } = require('../utils/helpers');
+const authStorage = require('../utils/auth-storage');
+const { findMergeBase, mergeTreeEntries, autoMerge } = require('../utils/merge-engine');
+const { storeTree, readBlobAsString, storeBlob } = require('../utils/hash-engine');
+
+/**
+ * Merge a branch into the current branch
+ * @param {String} sourceBranch - Branch to merge from
+ * @param {Object} options - Command options
+ */
+async function merge(sourceBranch, options) {
+    const spinner = ora(`Merging '${sourceBranch}'...`).start();
+
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const commits = repository.commits || [];
+        const branches = repository.branches || {};
+        const currentBranch = repository.currentBranch;
+
+        // Validate branches
+        if (!branches.hasOwnProperty(sourceBranch)) {
+            spinner.fail(chalk.red(`Branch '${sourceBranch}' not found`));
+            return;
+        }
+
+        if (sourceBranch === currentBranch) {
+            spinner.fail(chalk.red('Cannot merge a branch into itself'));
+            return;
+        }
+
+        const oursHash = branches[currentBranch];
+        const theirsHash = branches[sourceBranch];
+
+        if (!oursHash) {
+            spinner.fail(chalk.red(`Current branch '${currentBranch}' has no commits`));
+            return;
+        }
+
+        if (!theirsHash) {
+            spinner.fail(chalk.red(`Branch '${sourceBranch}' has no commits`));
+            return;
+        }
+
+        // Fast-forward check: if ours is ancestor of theirs
+        if (oursHash === theirsHash) {
+            spinner.succeed(chalk.green('Already up to date'));
+            return;
+        }
+
+        // Find merge base (common ancestor)
+        const baseHash = findMergeBase(commits, oursHash, theirsHash);
+
+        // Fast-forward: current branch is merge base → just move pointer
+        if (baseHash === oursHash) {
+            spinner.text = 'Fast-forward merge...';
+            repository.branches[currentBranch] = theirsHash;
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+            // Restore working tree from theirs commit
+            const theirsCommit = commits.find(c => c.hash === theirsHash);
+            if (theirsCommit) {
+                await restoreWorkingTree(gentPath, cwd, theirsCommit);
+            }
+
+            spinner.succeed(chalk.green(`Fast-forward merge: ${currentBranch} → ${theirsHash.substring(0, 7)}`));
+            return;
+        }
+
+        // 3-way merge
+        spinner.text = 'Computing 3-way merge...';
+
+        const oursCommit = commits.find(c => c.hash === oursHash);
+        const theirsCommit = commits.find(c => c.hash === theirsHash);
+        const baseCommit = baseHash ? commits.find(c => c.hash === baseHash) : null;
+
+        // Extract tree entries from commits
+        const getTree = (commit) => {
+            if (!commit) return [];
+            if (commit.tree && Array.isArray(commit.tree)) return commit.tree;
+            if (commit.files) return commit.files.map(f => ({
+                mode: '100644', name: f.path || f.name, hash: f.hash, type: 'blob'
+            }));
+            return [];
+        };
+
+        const baseTree = getTree(baseCommit);
+        const oursTree = getTree(oursCommit);
+        const theirsTree = getTree(theirsCommit);
+
+        // Perform tree-level merge
+        const mergeResult = await mergeTreeEntries(gentPath, baseTree, oursTree, theirsTree);
+
+        if (mergeResult.hasConflicts) {
+            spinner.warn(chalk.yellow(`Merged with ${mergeResult.conflicts.length} conflict(s)`));
+            console.log('');
+
+            for (const conflict of mergeResult.conflicts) {
+                if (conflict.type === 'content') {
+                    console.log(chalk.red(`  CONFLICT (content): ${conflict.file}`));
+                    console.log(chalk.gray(`    ${conflict.details.length} conflicting region(s) — markers inserted`));
+                } else if (conflict.type === 'modify-delete') {
+                    console.log(chalk.yellow(`  CONFLICT (modify/delete): ${conflict.file}`));
+                    console.log(chalk.gray(`    Deleted by ${conflict.deletedBy}, modified by ${conflict.modifiedBy} — kept modified version`));
+                } else if (conflict.type === 'add-add') {
+                    console.log(chalk.yellow(`  CONFLICT (add/add): ${conflict.file}`));
+                    console.log(chalk.gray(`    Both branches added differently — markers inserted`));
+                }
+            }
+
+            console.log(chalk.yellow('\nConflict markers: <<<<<<< ours / ======= / >>>>>>> theirs'));
+            console.log(chalk.cyan('Resolve conflicts, then run "gent add" and "gent commit"'));
+        }
+
+        // Store merged tree
+        const mergedTreeHash = await storeTree(gentPath, mergeResult.mergedEntries);
+
+        // Write merged files to working directory
+        await writeTreeToWorkDir(gentPath, cwd, mergeResult.mergedEntries);
+
+        // If no conflicts, create merge commit automatically
+        if (!mergeResult.hasConflicts) {
+            // Resolve author
+            const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+            let authorName = config.user.name;
+            let authorEmail = config.user.email;
+
+            if (!authorName || !authorEmail) {
+                const globalUser = await authStorage.getUser();
+                if (globalUser) {
+                    if (!authorName) authorName = [globalUser.first_name, globalUser.last_name].filter(Boolean).join(' ');
+                    if (!authorEmail) authorEmail = globalUser.email;
+                }
+            }
+
+            const mergeCommit = {
+                hash: generateCommitHash(),
+                message: options.message || `Merge branch '${sourceBranch}' into ${currentBranch}`,
+                author: {
+                    name: authorName || 'Unknown',
+                    email: authorEmail || 'unknown@gent'
+                },
+                timestamp: new Date().toISOString(),
+                parent: oursHash,
+                mergeParent: theirsHash,
+                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[currentBranch] = mergeCommit.hash;
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+            // Clear staging
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+            staging.entries = [];
+            staging.files = [];
+            await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+
+            spinner.succeed(chalk.green(`Merged '${sourceBranch}' into '${currentBranch}' — ${mergeCommit.hash.substring(0, 7)}`));
+
+            const autoResolved = mergeResult.mergedEntries.length;
+            console.log(chalk.gray(`\n  Base: ${baseHash ? baseHash.substring(0, 7) : 'none'}`));
+            console.log(chalk.gray(`  Ours: ${oursHash.substring(0, 7)}  Theirs: ${theirsHash.substring(0, 7)}`));
+            console.log(chalk.green(`  ${autoResolved} file(s) merged automatically`));
+        } else {
+            // Stage the merge state for manual resolution
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+            staging.mergeState = {
+                sourceBranch,
+                oursHash,
+                theirsHash,
+                baseHash,
+                mergedTreeHash,
+                mergedEntries: mergeResult.mergedEntries,
+                conflicts: mergeResult.conflicts
+            };
+            await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+        }
+
+    } catch (error) {
+        spinner.fail(chalk.red('Merge failed'));
+        if (error.code === 'ENOENT' && error.message.includes('.gent')) {
+            console.error(chalk.red('\nError: Not a gent repository'));
+            console.log(chalk.yellow('Run "gent init" to initialize a repository'));
+        } else {
+            console.error(chalk.red('\nError:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * Write tree entries to working directory.
+ * @param {String} gentPath
+ * @param {String} cwd
+ * @param {Array} entries
+ */
+async function writeTreeToWorkDir(gentPath, cwd, entries) {
+    for (const entry of entries) {
+        const fullPath = path.join(cwd, entry.name);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+
+        const content = await readBlobAsString(gentPath, entry.hash);
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+}
+
+/**
+ * Restore working tree from a commit's tree entries.
+ * @param {String} gentPath
+ * @param {String} cwd
+ * @param {Object} commit
+ */
+async function restoreWorkingTree(gentPath, cwd, commit) {
+    const tree = commit.tree || (commit.files || []).map(f => ({
+        mode: '100644', name: f.path || f.name, hash: f.hash, type: 'blob'
+    }));
+
+    try {
+        await writeTreeToWorkDir(gentPath, cwd, tree);
+    } catch {
+        // Best-effort restore — blobs may not exist for legacy commits
+    }
+}
+
+module.exports = merge;

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;