gent-cli 5.0.1 → 5.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "5.0.1",
+  "version": "5.0.4",
   "description": "A modern, Git-like version control CLI with built-in cloud authentication and global user identity management.",
   "main": "src/index.js",
   "bin": {

package/src/commands/branch.js

@@ -1,12 +1,15 @@
 /**
  * Branch Command - List, create, or delete branches
- * Manages repository branches
+ * Manages repository branches locally and syncs to remote API
  */
 
 const path = require('path');
 const chalk = require('chalk');
+const ora = require('ora');
 const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
-const { COMMITS_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');
 
 /**
  * Manage branches
@@ -85,6 +88,9 @@ async function createBranch(name, repository, gentPath) {
 
     console.log(chalk.green(`✓ Created branch '${name}'`));
     console.log(chalk.gray(`Based on: ${repository.currentBranch}`));
+
+    // Sync to remote if authenticated and remote configured
+    await syncBranchCreate(name, currentCommit, gentPath);
 }
 
 /**
@@ -110,6 +116,64 @@ async function deleteBranch(name, repository, gentPath) {
     await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
 
     console.log(chalk.green(`✓ Deleted branch '${name}'`));
+
+    // Sync deletion to remote
+    await syncBranchDelete(name, gentPath);
+}
+
+/**
+ * Sync branch creation to remote API
+ */
+async function syncBranchCreate(name, commitSha, gentPath) {
+    try {
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) return;
+
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const remoteConfig = config.remotes && config.remotes.origin;
+        if (!remoteConfig) return;
+
+        const repoInfo = parseRemoteUrl(remoteConfig.url);
+        if (!repoInfo) return;
+
+        if (!commitSha) return; // No commit to point to
+
+        const url = buildRepoUrl(API_ENDPOINTS.REPO_BRANCHES_CREATE, repoInfo);
+        await apiClient.post(url, { name, commit_sha: commitSha });
+        console.log(chalk.gray(`  ↑ Synced to remote`));
+    } catch (error) {
+        // Non-fatal: branch created locally even if remote sync fails
+        if (error.response?.status === 400) {
+            console.log(chalk.gray(`  ⚠ Remote sync skipped (branch may already exist remotely)`));
+        }
+    }
+}
+
+/**
+ * Sync branch deletion to remote API
+ */
+async function syncBranchDelete(name, gentPath) {
+    try {
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) return;
+
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const remoteConfig = config.remotes && config.remotes.origin;
+        if (!remoteConfig) return;
+
+        const repoInfo = parseRemoteUrl(remoteConfig.url);
+        if (!repoInfo) return;
+
+        const url = buildRepoUrl(API_ENDPOINTS.REPO_BRANCH_DETAIL, { ...repoInfo, branch_name: name });
+        await apiClient.delete(url);
+        console.log(chalk.gray(`  ↑ Deleted from remote`));
+    } catch (error) {
+        if (error.response?.status === 400) {
+            console.log(chalk.gray(`  ⚠ Cannot delete default branch on remote`));
+        } else if (error.response?.status === 404) {
+            // Branch didn't exist remotely, that's fine
+        }
+    }
 }
 
 module.exports = branch;

package/src/commands/clone.js

@@ -11,25 +11,15 @@
  *   gent clone <url>                   → Clone into folder named after repo
  *   gent clone <url> <directory>       → Clone into specific directory
  *
- * ALGORITHM:
- *   1. GET <url>/clone/ → receives full repo (commits, objects, config)
- *   2. Create .gent/ directory structure
- *   3. Store all blob objects in local object store
- *   4. Write commits.json with full history
- *   5. Checkout HEAD (restore working tree from latest commit)
- *   6. Configure remote "origin" pointing to <url>
- *
- * BACKEND EXPECTATIONS:
- *   GET /api/repos/:id/clone/
- *   Returns:
- *   {
- *     name: "repo-name",
- *     commits: [...],
- *     objects: [ { hash, type, data: "<base64>" } ],
- *     branches: { "main": "<hash>", ... },
- *     currentBranch: "main",
- *     tags: { ... }
- *   }
+ * ALGORITHM (client-side, no /clone/ endpoint):
+ *   1. Parse URL to get owner_id + repo_name
+ *   2. GET repo details → name, description, default_branch
+ *   3. GET branches list → all branch names + SHAs
+ *   4. GET commits list → all commits
+ *   5. For each commit, fetch tree + blobs
+ *   6. Create .gent/ directory structure
+ *   7. Store all objects locally
+ *   8. Checkout HEAD (restore working tree from latest commit)
  *
  * ============================================================================
  */
@@ -39,13 +29,14 @@ const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
 const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
-const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
 const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
 const { storeBlob, readBlobAsString } = require('../utils/hash-engine');
 
 /**
  * Clone remote repository
- * @param {String} url - Remote repository URL
+ * @param {String} url - Remote repository URL (e.g. /api/repos/1/my-repo)
  * @param {String} directory - Optional target directory
  * @param {Object} options
  */
@@ -58,11 +49,30 @@ async function clone(url, directory, options) {
     const spinner = ora(`Cloning from ${url}...`).start();
 
     try {
-        // Fetch full repo from remote
-        spinner.text = 'Downloading repository data...';
-        const response = await apiClient.get(`${url}/clone/`);
+        // Check auth
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            spinner.fail(chalk.red('Not authenticated'));
+            console.log(chalk.yellow('Run "gent login" first'));
+            return;
+        }
+
+        // Parse URL
+        const repoInfo = parseRemoteUrl(url);
+        if (!repoInfo) {
+            spinner.fail(chalk.red('Invalid repository URL'));
+            console.log(chalk.yellow('Expected format: /api/repos/{owner_id}/{repo_name}'));
+            return;
+        }
 
-        const repoName = response.name || 'gent-repo';
+        // 1. Get repo details
+        spinner.text = 'Fetching repository info...';
+        const repoDetail = await apiClient.get(
+            buildRepoUrl(API_ENDPOINTS.REPO_DETAIL, repoInfo)
+        );
+
+        const repoName = repoDetail.name || repoInfo.repo_name;
+        const defaultBranch = repoDetail.default_branch || 'main';
         const targetDir = directory || repoName;
         const targetPath = path.resolve(process.cwd(), targetDir);
 
@@ -74,6 +84,39 @@ async function clone(url, directory, options) {
             }
         }
 
+        // 2. Get branches
+        spinner.text = 'Fetching branches...';
+        let remoteBranches = [];
+        try {
+            remoteBranches = await apiClient.get(
+                buildRepoUrl(API_ENDPOINTS.REPO_BRANCHES, repoInfo)
+            );
+        } catch {
+            // No branches yet
+        }
+
+        // 3. Get all commits
+        spinner.text = 'Fetching commits...';
+        let remoteCommits = [];
+        try {
+            remoteCommits = await apiClient.get(
+                buildRepoUrl(API_ENDPOINTS.REPO_COMMITS, repoInfo)
+            );
+        } catch {
+            // No commits yet
+        }
+
+        // 4. Get tags
+        spinner.text = 'Fetching tags...';
+        let remoteTags = [];
+        try {
+            remoteTags = await apiClient.get(
+                buildRepoUrl(API_ENDPOINTS.REPO_TAGS, repoInfo)
+            );
+        } catch {
+            // No tags
+        }
+
         // Create directory structure
         spinner.text = 'Setting up repository...';
         const gentPath = path.join(targetPath, GENT_DIR);
@@ -82,23 +125,91 @@ async function clone(url, directory, options) {
         await ensureDir(path.join(gentPath, 'refs', 'heads'));
         await ensureDir(path.join(gentPath, 'refs', 'tags'));
 
-        // Store blob objects
-        const objects = response.objects || [];
-        spinner.text = `Storing ${objects.length} object(s)...`;
+        // 5. For each commit, fetch tree and blobs
+        const localCommits = [];
+        let objectCount = 0;
+
+        for (let i = 0; i < remoteCommits.length; i++) {
+            const commit = remoteCommits[i];
+            spinner.text = `Fetching objects (${i + 1}/${remoteCommits.length})...`;
 
-        for (const obj of objects) {
-            if (obj.type === 'blob' && obj.data) {
-                const buf = Buffer.from(obj.data, 'base64');
-                await storeBlob(gentPath, buf);
+            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 not available
+                }
+            }
+
+            // Fetch and store blobs
+            for (const entry of treeEntries) {
+                if (entry.type === 'blob' && entry.sha) {
+                    try {
+                        const blob = await apiClient.get(
+                            buildRepoUrl(API_ENDPOINTS.REPO_BLOB_DETAIL, { ...repoInfo, sha: entry.sha })
+                        );
+                        if (blob.content) {
+                            const buf = Buffer.from(blob.content, 'base64');
+                            await storeBlob(gentPath, buf);
+                            objectCount++;
+                        }
+                    } catch {
+                        // Blob fetch failed
+                    }
+                }
             }
+
+            // Convert to local commit format
+            localCommits.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: {}
+            });
+        }
+
+        // Build branches map
+        const branches = {};
+        for (const b of remoteBranches) {
+            branches[b.name] = b.commit_sha;
+        }
+        if (!branches[defaultBranch]) {
+            branches[defaultBranch] = null;
+        }
+
+        // Build tags map
+        const tagsMap = {};
+        for (const t of remoteTags) {
+            tagsMap[t.name] = {
+                hash: t.commit_sha,
+                message: t.message || '',
+                annotated: t.annotated || false,
+                tagger: { name: t.tagger_name || '', email: t.tagger_email || '' },
+                timestamp: t.created_at
+            };
         }
 
         // Write commits.json
         const repoData = {
-            commits: response.commits || [],
-            branches: response.branches || { main: null },
-            currentBranch: response.currentBranch || 'main',
-            tags: response.tags || {}
+            commits: localCommits,
+            branches,
+            currentBranch: defaultBranch,
+            tags: tagsMap
         };
         await writeJSON(path.join(gentPath, COMMITS_FILE), repoData);
 
@@ -107,7 +218,7 @@ async function clone(url, directory, options) {
             user: { name: '', email: '' },
             repository: {
                 name: repoName,
-                description: response.description || '',
+                description: repoDetail.description || '',
                 created: new Date().toISOString()
             },
             remotes: {
@@ -116,10 +227,9 @@ async function clone(url, directory, options) {
             remoteRefs: {}
         };
 
-        // Set remote ref to head
-        const headHash = repoData.branches[repoData.currentBranch];
+        const headHash = branches[defaultBranch];
         if (headHash) {
-            config.remoteRefs[`origin/${repoData.currentBranch}`] = headHash;
+            config.remoteRefs[`origin/${defaultBranch}`] = headHash;
         }
 
         await writeJSON(path.join(gentPath, CONFIG_FILE), config);
@@ -130,7 +240,7 @@ async function clone(url, directory, options) {
         // Write HEAD file
         await fs.writeFile(
             path.join(gentPath, 'HEAD'),
-            `ref: refs/heads/${repoData.currentBranch}\n`
+            `ref: refs/heads/${defaultBranch}\n`
         );
 
         // Create .gentignore
@@ -139,11 +249,9 @@ async function clone(url, directory, options) {
 
         // Checkout working tree from HEAD commit
         if (headHash) {
-            const headCommit = repoData.commits.find(c => c.hash === headHash);
+            const headCommit = localCommits.find(c => c.hash === headHash);
             if (headCommit) {
-                const tree = headCommit.tree || (headCommit.files || []).map(f => ({
-                    name: f.path || f.name, hash: f.hash
-                }));
+                const tree = headCommit.tree || [];
 
                 spinner.text = 'Checking out files...';
                 let fileCount = 0;
@@ -160,7 +268,7 @@ async function clone(url, directory, options) {
                 }
 
                 spinner.succeed(chalk.green(`Cloned into '${targetDir}'`));
-                console.log(chalk.gray(`  ${repoData.commits.length} commit(s), ${objects.length} object(s), ${fileCount} file(s)`));
+                console.log(chalk.gray(`  ${localCommits.length} commit(s), ${objectCount} object(s), ${fileCount} file(s)`));
             } else {
                 spinner.succeed(chalk.green(`Cloned into '${targetDir}' (empty)`));
             }
@@ -172,8 +280,10 @@ async function clone(url, directory, options) {
         spinner.fail(chalk.red('Clone failed'));
         if (error.response?.status === 404) {
             console.error(chalk.red('Repository not found'));
-        } else if (error.response?.data?.message) {
-            console.error(chalk.red(error.response.data.message));
+        } else if (error.response?.status === 401) {
+            console.error(chalk.red('Authentication failed — run "gent login"'));
+        } else if (error.response?.data) {
+            console.error(chalk.red(JSON.stringify(error.response.data)));
         } else {
             console.error(chalk.red('Error:'), error.message);
         }

package/src/commands/init.js

@@ -8,7 +8,8 @@ const path = require('path');
 const chalk = require('chalk');
 const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
 const authStorage = require('../utils/auth-storage');
-const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
+const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE, API_ENDPOINTS } = require('../utils/constants');
 
 /**
  * Initialize a new gent repository
@@ -109,6 +110,11 @@ node_modules/
             console.log(chalk.gray(`Initialized empty Gent repository in ${gentPath}`));
         }
 
+        // Create remote repository if --remote flag is set
+        if (options.remote) {
+            await createRemoteRepo(cwd, gentPath, config, options);
+        }
+
     } catch (error) {
         console.error(chalk.red('Failed to initialize repository'));
         console.error(chalk.red('Error:'), error.message);
@@ -116,4 +122,46 @@ node_modules/
     }
 }
 
+/**
+ * Create a remote repository on the backend and link it
+ */
+async function createRemoteRepo(cwd, gentPath, config, options) {
+    try {
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            console.log(chalk.yellow('Not authenticated — skipping remote creation'));
+            console.log(chalk.yellow('Run "gent login" then "gent repos --create <name>"'));
+            return;
+        }
+
+        const repoName = typeof options.remote === 'string' ? options.remote : path.basename(cwd);
+
+        console.log(chalk.gray(`Creating remote repository '${repoName}'...`));
+
+        const payload = {
+            name: repoName,
+            description: config.repository.description || '',
+        };
+
+        const data = await apiClient.post(API_ENDPOINTS.REPOS_CREATE, payload);
+
+        // Update local config with remote
+        const configPath = path.join(gentPath, CONFIG_FILE);
+        const localConfig = await require('../utils/fileSystem').readJSON(configPath);
+        localConfig.remotes = localConfig.remotes || {};
+        localConfig.remotes.origin = { url: `/api/repos/${data.owner_id}/${data.name}` };
+        await writeJSON(configPath, localConfig);
+
+        console.log(chalk.green(`✓ Remote repository created: /api/repos/${data.owner_id}/${data.name}`));
+        console.log(chalk.gray(`  Remote 'origin' configured automatically`));
+
+    } catch (error) {
+        if (error.response?.status === 400) {
+            console.log(chalk.yellow('Remote creation failed — repository name may already exist'));
+        } else {
+            console.log(chalk.yellow(`Remote creation failed: ${error.message}`));
+        }
+    }
+}
+
 module.exports = init;

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,7 +27,7 @@ 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');
@@ -72,53 +62,129 @@ 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 = Buffer.from(blob.content, 'base64');
+                                await storeBlob(gentPath, buf);
+                            }
+                        } catch {
+                            // Blob fetch failed, continue
+                        }
+                    }
+                }
+            }
 
-        // Add new commits (dedup)
+            // 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: {}
+            });
+        }
+
+        // 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
             repository.branches[branch] = remoteHead;
@@ -187,8 +253,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);
         }

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/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}`));

package/src/commands/repos.js

@@ -0,0 +1,102 @@
+/**
+ * Repos Command - List and create remote repositories
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const { API_ENDPOINTS } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
+
+/**
+ * List or create remote repositories
+ * @param {Object} options
+ */
+async function repos(options) {
+    try {
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            console.error(chalk.red('Not authenticated'));
+            console.log(chalk.yellow('Run "gent login" first'));
+            return;
+        }
+
+        if (options.create) {
+            await createRepo(options);
+            return;
+        }
+
+        await listRepos();
+
+    } catch (error) {
+        if (error.response?.status === 401) {
+            console.error(chalk.red('Authentication failed — run "gent login"'));
+        } else if (error.response?.data) {
+            console.error(chalk.red(JSON.stringify(error.response.data)));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * List all user repositories
+ */
+async function listRepos() {
+    const spinner = ora('Fetching repositories...').start();
+
+    const data = await apiClient.get(API_ENDPOINTS.REPOS);
+
+    spinner.stop();
+
+    if (!data || data.length === 0) {
+        console.log(chalk.gray('No repositories found'));
+        console.log(chalk.yellow('Use "gent repos --create <name>" to create one'));
+        return;
+    }
+
+    console.log(chalk.bold.cyan('\nRepositories:\n'));
+
+    for (const repo of data) {
+        const visibility = repo.is_private ? chalk.red('private') : chalk.green('public');
+        const desc = repo.description ? chalk.gray(` — ${repo.description}`) : '';
+        const url = chalk.gray(` /api/repos/${repo.owner_id}/${repo.name}`);
+        console.log(`  ${chalk.white.bold(repo.name)} [${visibility}]${desc}`);
+        console.log(`    ${url}`);
+    }
+
+    console.log();
+}
+
+/**
+ * Create a new remote repository
+ */
+async function createRepo(options) {
+    const name = options.create;
+    if (typeof name !== 'string' || !name) {
+        console.error(chalk.red('Usage: gent repos --create <name>'));
+        return;
+    }
+
+    const spinner = ora(`Creating repository '${name}'...`).start();
+
+    const payload = {
+        name,
+        description: options.description || '',
+        is_private: !!options.private,
+    };
+
+    if (options.defaultBranch) {
+        payload.default_branch = options.defaultBranch;
+    }
+
+    const data = await apiClient.post(API_ENDPOINTS.REPOS_CREATE, payload);
+
+    spinner.succeed(chalk.green(`Created repository '${data.name}'`));
+    console.log(chalk.gray(`  URL: /api/repos/${data.owner_id}/${data.name}`));
+    console.log(chalk.gray(`  Use "gent remote add origin /api/repos/${data.owner_id}/${data.name}" to link`));
+}
+
+module.exports = repos;

package/src/commands/tag.js

@@ -28,7 +28,8 @@
 const path = require('path');
 const chalk = require('chalk');
 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');
 
 /**
@@ -104,10 +105,12 @@ async function createTag(name, repository, gentPath, options) {
     const tagObj = { hash: commitHash };
 
     // Annotated tag
+    let taggerName = '';
+    let taggerEmail = '';
     if (options.message) {
         const config = await readJSON(path.join(gentPath, CONFIG_FILE));
-        let taggerName = config.user.name;
-        let taggerEmail = config.user.email;
+        taggerName = config.user.name;
+        taggerEmail = config.user.email;
 
         if (!taggerName || !taggerEmail) {
             const user = await authStorage.getUser();
@@ -127,6 +130,9 @@ async function createTag(name, repository, gentPath, options) {
     await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
 
     console.log(chalk.green(`Created tag '${name}' → ${commitHash.substring(0, 7)}`));
+
+    // Sync to remote
+    await syncTagCreate(name, tagObj, taggerName, taggerEmail, gentPath);
 }
 
 /**
@@ -141,6 +147,69 @@ async function deleteTag(name, repository, gentPath) {
     delete repository.tags[name];
     await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
     console.log(chalk.green(`Deleted tag '${name}'`));
+
+    // Sync deletion to remote
+    await syncTagDelete(name, gentPath);
+}
+
+/**
+ * Sync tag creation to remote API
+ */
+async function syncTagCreate(name, tagObj, taggerName, taggerEmail, gentPath) {
+    try {
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) return;
+
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const remoteConfig = config.remotes && config.remotes.origin;
+        if (!remoteConfig) return;
+
+        const repoInfo = parseRemoteUrl(remoteConfig.url);
+        if (!repoInfo) return;
+
+        const payload = {
+            name,
+            commit_sha: tagObj.hash,
+            message: tagObj.message || '',
+            annotated: !!tagObj.annotated,
+        };
+
+        if (taggerName) payload.tagger_name = taggerName;
+        if (taggerEmail) payload.tagger_email = taggerEmail;
+
+        const url = buildRepoUrl(API_ENDPOINTS.REPO_TAGS_CREATE, repoInfo);
+        await apiClient.post(url, payload);
+        console.log(chalk.gray(`  ↑ Synced to remote`));
+    } catch (error) {
+        if (error.response?.status === 400) {
+            console.log(chalk.gray(`  ⚠ Remote sync skipped (tag may already exist remotely)`));
+        }
+    }
+}
+
+/**
+ * Sync tag deletion to remote API
+ */
+async function syncTagDelete(name, gentPath) {
+    try {
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) return;
+
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const remoteConfig = config.remotes && config.remotes.origin;
+        if (!remoteConfig) return;
+
+        const repoInfo = parseRemoteUrl(remoteConfig.url);
+        if (!repoInfo) return;
+
+        const url = buildRepoUrl(API_ENDPOINTS.REPO_TAG_DETAIL, { ...repoInfo, tag_name: name });
+        await apiClient.delete(url);
+        console.log(chalk.gray(`  ↑ Deleted from remote`));
+    } catch (error) {
+        if (error.response?.status === 404) {
+            // Tag didn't exist remotely
+        }
+    }
 }
 
 module.exports = tag;

package/src/index.js

@@ -41,6 +41,7 @@ const stashCommand = require('./commands/stash');
 const remoteCommand = require('./commands/remote');
 const pushCommand = require('./commands/push');
 const pullCommand = require('./commands/pull');
+const reposCommand = require('./commands/repos');
 
 // Import auth commands
 const registerCommand = require('./commands/register');
@@ -60,6 +61,7 @@ program
     .command('init')
     .description('Initialize a new gent repository')
     .option('-y, --yes', 'Skip prompts and use defaults')
+    .option('--remote [name]', 'Create a remote repository on the backend')
     .action(initCommand);
 
 program
@@ -168,6 +170,15 @@ program
     .option('-v, --verbose', 'Show remote URLs')
     .action(remoteCommand);
 
+program
+    .command('repos')
+    .description('List or create remote repositories')
+    .option('--create <name>', 'Create a new remote repository')
+    .option('--description <text>', 'Repository description (with --create)')
+    .option('--private', 'Make repository private (with --create)')
+    .option('--default-branch <name>', 'Default branch name (with --create)')
+    .action(reposCommand);
+
 program
     .command('push [remote] [branch]')
     .description('Push local commits to remote')

package/src/utils/api-client.js

@@ -170,10 +170,23 @@ async function del(url, config = {}) {
     return response.data;
 }
 
+/**
+ * Make PATCH request
+ * @param {string} url - Endpoint URL
+ * @param {Object} data - Request payload
+ * @param {Object} config - Axios config
+ * @returns {Promise} Response data
+ */
+async function patch(url, data = {}, config = {}) {
+    const response = await apiClient.patch(url, data, config);
+    return response.data;
+}
+
 module.exports = {
     get,
     post,
     put,
     delete: del,
+    patch,
     apiClient // Export raw client if needed
 };

package/src/utils/constants.js

@@ -15,22 +15,67 @@ module.exports = {
     // API Configuration
     API_BASE_URL: 'https://gent-api.onrender.com',
     API_ENDPOINTS: {
+        // Auth
         LOGIN: '/api/auth/login/',
         REGISTER: '/api/auth/register/',
         LOGOUT: '/api/auth/logout/',
         REFRESH: '/api/auth/token/refresh/',
         PROFILE: '/api/auth/profile/',
 
-        // Repository endpoints (used by push/pull/clone)
-        // Base: /api/repos/:id/
+        // Repository management
         REPOS: '/api/repos/',
-        REPO_PUSH: '/push/',       // POST - upload commits + objects
-        REPO_PULL: '/pull/',       // GET  - download commits + objects since hash
-        REPO_CLONE: '/clone/',     // GET  - full repo download
-        REPO_REFS: '/refs/',       // GET  - list remote branch refs
-        REPO_TAGS: '/tags/',       // GET/POST/DELETE - tag management
-        REPO_MERGE: '/merge/',     // POST - server-side merge request
-        REPO_COMMITS: '/commits/', // GET  - commit history
+        REPOS_CREATE: '/api/repos/create/',
+        // Template: /api/repos/{owner_id}/{repo_name}/
+        REPO_DETAIL: '/api/repos/{owner_id}/{repo_name}/',
+        REPO_DELETE: '/api/repos/{owner_id}/{repo_name}/delete/',
+
+        // Push
+        REPO_PUSH: '/api/repos/{owner_id}/{repo_name}/push/',
+
+        // Branches
+        REPO_BRANCHES: '/api/repos/{owner_id}/{repo_name}/branches/',
+        REPO_BRANCHES_CREATE: '/api/repos/{owner_id}/{repo_name}/branches/create/',
+        REPO_BRANCH_DETAIL: '/api/repos/{owner_id}/{repo_name}/branches/{branch_name}/',
+
+        // Tags
+        REPO_TAGS: '/api/repos/{owner_id}/{repo_name}/tags/',
+        REPO_TAGS_CREATE: '/api/repos/{owner_id}/{repo_name}/tags/create/',
+        REPO_TAG_DETAIL: '/api/repos/{owner_id}/{repo_name}/tags/{tag_name}/',
+
+        // Commits
+        REPO_COMMITS: '/api/repos/{owner_id}/{repo_name}/commits/',
+        REPO_COMMIT_DETAIL: '/api/repos/{owner_id}/{repo_name}/commits/{sha}/',
+
+        // Objects (trees & blobs)
+        REPO_TREE_CREATE: '/api/repos/{owner_id}/{repo_name}/tree/create/',
+        REPO_TREE_DETAIL: '/api/repos/{owner_id}/{repo_name}/tree/{sha}/',
+        REPO_BLOB_CREATE: '/api/repos/{owner_id}/{repo_name}/blob/create/',
+        REPO_BLOB_DETAIL: '/api/repos/{owner_id}/{repo_name}/blob/{sha}/',
+    },
+
+    /**
+     * Build a repo-scoped API path by replacing {owner_id} and {repo_name} tokens.
+     * @param {string} template - Endpoint template from API_ENDPOINTS
+     * @param {object} params - { owner_id, repo_name, branch_name?, tag_name?, sha? }
+     * @returns {string}
+     */
+    buildRepoUrl(template, params) {
+        let url = template;
+        for (const [key, value] of Object.entries(params)) {
+            url = url.replace(`{${key}}`, encodeURIComponent(value));
+        }
+        return url;
+    },
+
+    /**
+     * Parse a remote URL like /api/repos/{owner_id}/{repo_name} into { owner_id, repo_name }.
+     * @param {string} url - Remote URL stored in config
+     * @returns {{ owner_id: string, repo_name: string } | null}
+     */
+    parseRemoteUrl(url) {
+        const match = url.match(/\/api\/repos\/(\d+)\/([^/]+)\/?$/);
+        if (!match) return null;
+        return { owner_id: match[1], repo_name: match[2] };
     },
 
     // Default ignore patterns