gent-cli 5.0.3 → 6.0.0

package/src/commands/pull.js

@@ -11,23 +11,13 @@
  *   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>"
- *   }
+ * ALGORITHM (client-side, no /pull/ endpoint):
+ *   1. GET .../branches/{branch}/ → get remote branch head SHA
+ *   2. GET .../commits/ → list all remote commits
+ *   3. Diff local vs remote commits, find new ones
+ *   4. For each new commit, fetch tree + blobs via individual endpoints
+ *   5. Store objects locally
+ *   6. If diverged: run 3-way merge. If fast-forward: advance pointer
  *
  * ============================================================================
  */
@@ -37,10 +27,10 @@ const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
 const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
-const { COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const { COMMITS_FILE, CONFIG_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
 const apiClient = require('../utils/api-client');
 const authStorage = require('../utils/auth-storage');
-const { storeBlob, objectExists } = require('../utils/hash-engine');
+const { storeBlob, objectExists, readBlobAsString, decodeRemoteBlobContent } = require('../utils/hash-engine');
 const { findMergeBase, mergeTreeEntries } = require('../utils/merge-engine');
 const { generateCommitHash } = require('../utils/helpers');
 
@@ -72,57 +62,136 @@ async function pull(remoteName, branchName, options) {
             return;
         }
 
+        const repoInfo = parseRemoteUrl(remoteConfig.url);
+        if (!repoInfo) {
+            spinner.fail(chalk.red('Invalid remote URL format'));
+            console.log(chalk.yellow('Expected: /api/repos/{owner_id}/{repo_name}'));
+            return;
+        }
+
         const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
         const branch = branchName || repository.currentBranch;
         const localHead = repository.branches[branch] || null;
 
-        // Fetch from remote
-        config.remoteRefs = config.remoteRefs || {};
-        const since = config.remoteRefs[`${remote}/${branch}`] || localHead || '';
+        // 1. Get remote branch info to find remote HEAD
+        spinner.text = `Fetching branch info for ${branch}...`;
+        let remoteHead;
+        try {
+            const branchInfo = await apiClient.get(
+                buildRepoUrl(API_ENDPOINTS.REPO_BRANCH_DETAIL, { ...repoInfo, branch_name: branch })
+            );
+            remoteHead = branchInfo.commit_sha;
+        } catch (error) {
+            if (error.response?.status === 404) {
+                spinner.succeed(chalk.green('Remote branch not found — nothing to pull'));
+                return;
+            }
+            throw error;
+        }
 
-        spinner.text = `Fetching from ${remote}/${branch}...`;
+        if (!remoteHead || remoteHead === localHead) {
+            spinner.succeed(chalk.green('Already up-to-date'));
+            return;
+        }
 
-        const response = await apiClient.get(
-            `${remoteConfig.url}/pull/`,
-            { params: { branch, since } }
+        // 2. Fetch all remote commits
+        spinner.text = `Fetching commits...`;
+        const remoteCommits = await apiClient.get(
+            buildRepoUrl(API_ENDPOINTS.REPO_COMMITS, repoInfo)
         );
 
-        const remoteCommits = response.commits || [];
-        const remoteObjects = response.objects || [];
-        const remoteHead = response.head;
+        // 3. Find commits we don't have locally
+        const localCommitSet = new Set((repository.commits || []).map(c => c.hash || c.sha));
+        const newRemoteCommits = remoteCommits.filter(c => !localCommitSet.has(c.sha));
 
-        if (remoteCommits.length === 0) {
+        if (newRemoteCommits.length === 0) {
+            // We have all commits but pointer is different — update ref
+            config.remoteRefs = config.remoteRefs || {};
+            config.remoteRefs[`${remote}/${branch}`] = remoteHead;
+            await writeJSON(path.join(gentPath, CONFIG_FILE), config);
             spinner.succeed(chalk.green('Already up-to-date'));
             return;
         }
 
-        // 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);
+        // 4. For each new commit, fetch tree and blobs
+        spinner.text = `Fetching ${newRemoteCommits.length} new commit(s) + objects...`;
+
+        const fetchedCommits = [];
+        for (const commit of newRemoteCommits) {
+            // Fetch tree for this commit
+            let treeEntries = [];
+            if (commit.tree_sha) {
+                try {
+                    const tree = await apiClient.get(
+                        buildRepoUrl(API_ENDPOINTS.REPO_TREE_DETAIL, { ...repoInfo, sha: commit.tree_sha })
+                    );
+                    treeEntries = tree.entries || [];
+                } catch {
+                    // Tree may not be available
+                }
             }
-        }
 
-        // Check if fast-forward is possible
-        const allCommits = [...(repository.commits || []), ...remoteCommits];
-        const commitSet = new Set((repository.commits || []).map(c => c.hash));
+            // Fetch and store blobs
+            for (const entry of treeEntries) {
+                if (entry.type === 'blob' && entry.sha) {
+                    if (!(await objectExists(gentPath, entry.sha))) {
+                        try {
+                            const blob = await apiClient.get(
+                                buildRepoUrl(API_ENDPOINTS.REPO_BLOB_DETAIL, { ...repoInfo, sha: entry.sha })
+                            );
+                            if (blob.content) {
+                                const buf = decodeRemoteBlobContent(blob.content, entry.sha);
+                                await storeBlob(gentPath, buf);
+                            }
+                        } catch {
+                            // Blob fetch failed, continue
+                        }
+                    }
+                }
+            }
+
+            // Convert remote commit format to local format
+            fetchedCommits.push({
+                hash: commit.sha,
+                message: commit.message,
+                author: { name: commit.author_name, email: commit.author_email },
+                timestamp: commit.committed_at,
+                parent: commit.parent_shas && commit.parent_shas[0] || null,
+                mergeParent: commit.parent_shas && commit.parent_shas[1] || null,
+                treeHash: commit.tree_sha,
+                tree: treeEntries.map(e => ({
+                    mode: e.mode || '100644',
+                    name: e.name,
+                    hash: e.sha,
+                    type: e.type || 'blob'
+                })),
+                files: treeEntries.map(e => ({ path: e.name, hash: e.sha })),
+                stats: {}
+            });
+        }
 
-        // Add new commits (dedup)
+        // 5. Add new commits to local store (dedup)
         let newCount = 0;
-        for (const commit of remoteCommits) {
+        const commitSet = new Set((repository.commits || []).map(c => c.hash));
+        for (const commit of fetchedCommits) {
             if (!commitSet.has(commit.hash)) {
+                repository.commits = repository.commits || [];
                 repository.commits.push(commit);
                 commitSet.add(commit.hash);
                 newCount++;
             }
         }
 
+        // 6. Merge strategy
+        config.remoteRefs = config.remoteRefs || {};
+
         if (!localHead || isAncestor(repository.commits, localHead, remoteHead)) {
             // Fast-forward
+            const previousTree = localHead ? getCommitTree(repository.commits, localHead) : [];
+            const nextTree = getCommitTree(repository.commits, remoteHead);
             repository.branches[branch] = remoteHead;
             await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+            await checkoutTree(gentPath, process.cwd(), previousTree, nextTree);
 
             config.remoteRefs[`${remote}/${branch}`] = remoteHead;
             await writeJSON(path.join(gentPath, CONFIG_FILE), config);
@@ -168,6 +237,9 @@ async function pull(remoteName, branchName, options) {
             repository.commits.push(mergeCommit);
             repository.branches[branch] = mergeCommit.hash;
             await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+            if (!mergeResult.hasConflicts) {
+                await checkoutTree(gentPath, process.cwd(), oursTree, mergeResult.mergedEntries);
+            }
 
             config.remoteRefs[`${remote}/${branch}`] = remoteHead;
             await writeJSON(path.join(gentPath, CONFIG_FILE), config);
@@ -187,8 +259,8 @@ async function pull(remoteName, branchName, options) {
         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 if (error.response?.data) {
+            console.error(chalk.red(JSON.stringify(error.response.data)));
         } else {
             console.error(chalk.red('Error:'), error.message);
         }
@@ -210,4 +282,40 @@ function isAncestor(commits, hashA, hashB) {
     return false;
 }
 
+function getCommitTree(commits, hash) {
+    const commit = commits.find(c => c.hash === hash);
+    if (!commit) return [];
+    return commit.tree || (commit.files || []).map(f => ({
+        mode: '100644',
+        name: f.path || f.name,
+        hash: f.hash,
+        type: 'blob'
+    }));
+}
+
+async function checkoutTree(gentPath, cwd, previousTree, nextTree) {
+    const nextPaths = new Set(nextTree.map(e => e.name || e.path));
+
+    for (const entry of previousTree) {
+        const relPath = entry.name || entry.path;
+        if (!relPath || nextPaths.has(relPath)) continue;
+        try {
+            await fs.unlink(path.join(cwd, relPath));
+        } catch {
+            // File already absent.
+        }
+    }
+
+    for (const entry of nextTree) {
+        if (entry.type && entry.type !== 'blob') continue;
+        const relPath = entry.name || entry.path;
+        if (!relPath || !entry.hash) continue;
+
+        const content = await readBlobAsString(gentPath, entry.hash);
+        const fullPath = path.join(cwd, relPath);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+}
+
 module.exports = pull;

package/src/commands/push.js

@@ -14,28 +14,22 @@
  *
  * 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
+ *   2. Build proper pack: collect tree objects + blob objects
+ *   3. POST packfile to /api/repos/{owner_id}/{repo_name}/push/
+ *   4. Remote updates branch pointer via branch_updates
  *
- * DATA FORMAT SENT TO BACKEND:
- *   POST /api/repos/:id/push/
+ * DATA FORMAT SENT TO BACKEND (PushPackRequest):
+ *   POST /api/repos/{owner_id}/{repo_name}/push/
  *   {
- *     branch: "main",
- *     force: false,
- *     commits: [ { hash, message, author, timestamp, parent, treeHash, tree, files, stats } ],
- *     objects: [ { hash, type: "blob", data: "<base64>" } ],
+ *     pack: {
+ *       commits: [{ sha, message, tree_sha, parent_shas, author_name, author_email, committed_at }],
+ *       trees:   [{ sha, entries: [{ type, mode, name, sha }] }],
+ *       blobs:   [{ sha, size, content, encoding }]
+ *     },
+ *     branch_updates: [{ name, commit_sha }],
  *     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 }
- *
  * ============================================================================
  */
 
@@ -44,10 +38,10 @@ const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
 const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
-const { COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const { COMMITS_FILE, CONFIG_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
 const apiClient = require('../utils/api-client');
 const authStorage = require('../utils/auth-storage');
-const { readBlob, objectExists } = require('../utils/hash-engine');
+const { readBlob, readTree, objectExists, readBlobAsString } = require('../utils/hash-engine');
 
 /**
  * Push commits to remote
@@ -81,6 +75,15 @@ async function push(remoteName, branchName, options) {
             return;
         }
 
+        // Parse remote URL to get owner_id and repo_name
+        const repoInfo = parseRemoteUrl(remoteConfig.url);
+        if (!repoInfo) {
+            spinner.fail(chalk.red('Invalid remote URL format'));
+            console.log(chalk.yellow('Expected: /api/repos/{owner_id}/{repo_name}'));
+            console.log(chalk.yellow('Use "gent remote set-url origin <url>" to fix'));
+            return;
+        }
+
         const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
         const branch = branchName || repository.currentBranch;
         const localHead = repository.branches[branch];
@@ -103,26 +106,71 @@ async function push(remoteName, branchName, options) {
 
         spinner.text = `Pushing ${commitsToPush.length} commit(s) to ${remote}/${branch}...`;
 
-        // Collect all blob hashes from commits to push
-        const blobHashes = new Set();
+        // Collect all tree and blob objects from commits
+        const treeShas = new Set();
+        const blobShas = new Set();
+
         for (const commit of commitsToPush) {
+            // Collect tree SHA
+            if (commit.treeHash) {
+                treeShas.add(commit.treeHash);
+            }
+            // Collect blob hashes from tree entries
             const tree = commit.tree || commit.files || [];
             for (const entry of tree) {
-                const h = entry.hash;
-                if (h) blobHashes.add(h);
+                if (entry.hash) blobShas.add(entry.hash);
             }
         }
 
-        // Read blob data for transfer
-        const objects = [];
-        for (const hash of blobHashes) {
+        // Build tree objects for the pack
+        const packTrees = [];
+        for (const treeSha of treeShas) {
+            try {
+                if (await objectExists(gentPath, treeSha)) {
+                    const entries = await readTree(gentPath, treeSha);
+                    packTrees.push({
+                        sha: treeSha,
+                        entries: entries.map(e => ({
+                            type: e.type || 'blob',
+                            mode: e.mode || '100644',
+                            name: e.name,
+                            sha: e.hash
+                        }))
+                    });
+                }
+            } catch {
+                // If tree can't be read from object store, build from commit data
+            }
+        }
+
+        // If no tree objects from object store, build from commit tree data
+        if (packTrees.length === 0) {
+            for (const commit of commitsToPush) {
+                if (commit.treeHash && commit.tree) {
+                    packTrees.push({
+                        sha: commit.treeHash,
+                        entries: commit.tree.map(e => ({
+                            type: e.type || 'blob',
+                            mode: e.mode || '100644',
+                            name: e.name || e.path,
+                            sha: e.hash
+                        }))
+                    });
+                }
+            }
+        }
+
+        // Build blob objects for the pack
+        const packBlobs = [];
+        for (const hash of blobShas) {
             try {
                 if (await objectExists(gentPath, hash)) {
                     const data = await readBlob(gentPath, hash);
-                    objects.push({
-                        hash,
-                        type: 'blob',
-                        data: data.toString('base64')
+                    packBlobs.push({
+                        sha: hash,
+                        size: data.length,
+                        content: data.toString('base64'),
+                        encoding: 'base64'
                     });
                 }
             } catch {
@@ -130,31 +178,34 @@ async function push(remoteName, branchName, options) {
             }
         }
 
-        // Build push payload
+        // Build commits for the pack
+        const packCommits = commitsToPush.map(c => ({
+            sha: c.hash,
+            message: c.message,
+            tree_sha: c.treeHash || '',
+            parent_shas: [c.parent, c.mergeParent].filter(Boolean),
+            author_name: typeof c.author === 'object' ? (c.author.name || 'Unknown') : (c.author || 'Unknown'),
+            author_email: typeof c.author === 'object' ? (c.author.email || '') : '',
+            committed_at: c.timestamp || new Date().toISOString()
+        }));
+
+        // Build push payload matching PushPackRequest schema
         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,
+            pack: {
+                commits: packCommits,
+                trees: packTrees,
+                blobs: packBlobs
+            },
+            branch_updates: [{
+                name: branch,
+                commit_sha: localHead
+            }],
             tags: repository.tags || {}
         };
 
         // Send to backend
-        const response = await apiClient.post(
-            `${remoteConfig.url}/push/`,
-            payload
-        );
+        const pushUrl = buildRepoUrl(API_ENDPOINTS.REPO_PUSH, repoInfo);
+        const response = await apiClient.post(pushUrl, payload);
 
         // Update remote ref
         config.remoteRefs[`${remote}/${branch}`] = localHead;
@@ -162,7 +213,7 @@ async function push(remoteName, branchName, options) {
 
         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`));
+        console.log(chalk.gray(`  ${packBlobs.length} blob(s), ${packTrees.length} tree(s) transferred`));
 
     } catch (error) {
         spinner.fail(chalk.red('Push failed'));
@@ -172,8 +223,10 @@ async function push(remoteName, branchName, options) {
             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 if (error.response?.status === 403) {
+            console.error(chalk.red('Permission denied — only repo owner can push'));
+        } else if (error.response?.data) {
+            console.error(chalk.red(JSON.stringify(error.response.data, null, 2)));
         } else {
             console.error(chalk.red('Error:'), error.message);
         }

package/src/commands/register.js

@@ -17,12 +17,19 @@ async function register(options) {
     console.log(chalk.cyan('\n🚀 Create your Gent account\n'));
 
     try {
+        let email = options.email;
+        let password = options.password;
+        let passwordConfirm = options.passwordConfirm;
+        let firstName = options.firstName;
+        let lastName = options.lastName;
+
         // Prompt for user information
         const answers = await inquirer.prompt([
             {
                 type: 'input',
                 name: 'email',
                 message: 'Email address:',
+                when: !email,
                 validate: (input) => {
                     const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
                     return emailRegex.test(input) || 'Please enter a valid email address';
@@ -33,6 +40,7 @@ async function register(options) {
                 name: 'password',
                 message: 'Password:',
                 mask: '*',
+                when: !password,
                 validate: (input) => {
                     if (input.length < 8) {
                         return 'Password must be at least 8 characters long';
@@ -45,33 +53,46 @@ async function register(options) {
                 name: 'passwordConfirm',
                 message: 'Confirm password:',
                 mask: '*',
+                when: !passwordConfirm,
                 validate: (input, answers) => {
-                    return input === answers.password || 'Passwords do not match';
+                    return input === (password || answers.password) || 'Passwords do not match';
                 }
             },
             {
                 type: 'input',
                 name: 'firstName',
                 message: 'First name:',
+                when: firstName === undefined,
                 default: ''
             },
             {
                 type: 'input',
                 name: 'lastName',
                 message: 'Last name:',
+                when: lastName === undefined,
                 default: ''
             }
         ]);
 
+        email = email || answers.email;
+        password = password || answers.password;
+        passwordConfirm = passwordConfirm || answers.passwordConfirm;
+        firstName = firstName !== undefined ? firstName : answers.firstName;
+        lastName = lastName !== undefined ? lastName : answers.lastName;
+
+        if (!email || !password || !passwordConfirm) {
+            throw new Error('Email, password, and password confirmation are required');
+        }
+
         const spinner = ora('Creating your account...').start();
 
         // Register user
         const user = await authService.register(
-            answers.email,
-            answers.password,
-            answers.passwordConfirm,
-            answers.firstName,
-            answers.lastName
+            email,
+            password,
+            passwordConfirm,
+            firstName || '',
+            lastName || ''
         );
 
         spinner.succeed(chalk.green('✓ Account created successfully!'));

package/src/commands/remote.js

@@ -29,7 +29,7 @@
 const path = require('path');
 const chalk = require('chalk');
 const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
-const { CONFIG_FILE } = require('../utils/constants');
+const { CONFIG_FILE, parseRemoteUrl } = require('../utils/constants');
 
 /**
  * Manage remotes
@@ -55,6 +55,13 @@ async function remote(subcommand, args, options) {
                     console.error(chalk.red(`Remote '${name}' already exists`));
                     return;
                 }
+                // Validate URL format
+                if (!parseRemoteUrl(url)) {
+                    console.error(chalk.red('Invalid remote URL format'));
+                    console.log(chalk.yellow('Expected: /api/repos/{owner_id}/{repo_name}'));
+                    console.log(chalk.yellow('Example:  /api/repos/1/my-project'));
+                    return;
+                }
                 config.remotes[name] = { url };
                 await writeJSON(configPath, config);
                 console.log(chalk.green(`Added remote '${name}' → ${url}`));
@@ -85,6 +92,12 @@ async function remote(subcommand, args, options) {
                     console.error(chalk.red(`Remote '${name}' not found`));
                     return;
                 }
+                // Validate URL format
+                if (!parseRemoteUrl(url)) {
+                    console.error(chalk.red('Invalid remote URL format'));
+                    console.log(chalk.yellow('Expected: /api/repos/{owner_id}/{repo_name}'));
+                    return;
+                }
                 config.remotes[name].url = url;
                 await writeJSON(configPath, config);
                 console.log(chalk.green(`Updated '${name}' → ${url}`));