gent-cli 2.1.0 → 5.0.1

package/src/commands/clone.js

@@ -1,131 +1,182 @@
 /**
- * Clone Command - Clone a cloud repository to local
- * Downloads repository data and sets up local working copy
+ * ============================================================================
+ * Clone Command - Clone a remote repository to local filesystem
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Download an entire repository (commits + objects) from a remote server
+ *   and set up a local working copy. Like `git clone`.
+ *
+ * USAGE:
+ *   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: { ... }
+ *   }
+ *
+ * ============================================================================
  */
 
 const fs = require('fs').promises;
+const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
-const path = require('path');
-const repoService = require('../services/repo-service');
-const authStorage = require('../utils/auth-storage');
 const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
 const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
-const { addRemote, syncCommitsFromCloud } = require('../utils/cloud-sync');
+const apiClient = require('../utils/api-client');
+const { storeBlob, readBlobAsString } = require('../utils/hash-engine');
 
 /**
- * Clone a cloud repository
- * @param {string} repoUrl - Repository URL (owner_id/repo_name)
- * @param {string} directory - Target directory (optional)
- * @param {Object} options - Command options
+ * Clone remote repository
+ * @param {String} url - Remote repository URL
+ * @param {String} directory - Optional target directory
+ * @param {Object} options
  */
-async function clone(repoUrl, directory, options) {
-    try {
-        // Check authentication
-        const user = await authStorage.getUser();
-        if (!user) {
-            console.error(chalk.red('Error: You must be logged in to clone a repository'));
-            console.log(chalk.yellow('Run'), chalk.cyan('gent login'), chalk.yellow('to authenticate'));
-            process.exit(1);
-        }
-
-        // Parse repository URL
-        if (!repoUrl) {
-            console.error(chalk.red('Error: Repository URL is required'));
-            console.log(chalk.yellow('Usage:'), chalk.cyan('gent clone <owner_id>/<repo_name> [directory]'));
-            process.exit(1);
-        }
-
-        const parts = repoUrl.split('/');
-        if (parts.length !== 2) {
-            console.error(chalk.red('Error: Invalid repository URL format'));
-            console.log(chalk.yellow('Expected:'), chalk.cyan('<owner_id>/<repo_name>'));
-            process.exit(1);
-        }
+async function clone(url, directory, options) {
+    if (!url) {
+        console.error(chalk.red('Usage: gent clone <url> [directory]'));
+        return;
+    }
 
-        const ownerId = parseInt(parts[0]);
-        const repoName = parts[1];
+    const spinner = ora(`Cloning from ${url}...`).start();
 
-        if (isNaN(ownerId)) {
-            console.error(chalk.red('Error: Owner ID must be a number'));
-            process.exit(1);
-        }
+    try {
+        // Fetch full repo from remote
+        spinner.text = 'Downloading repository data...';
+        const response = await apiClient.get(`${url}/clone/`);
 
-        // Determine target directory
+        const repoName = response.name || 'gent-repo';
         const targetDir = directory || repoName;
         const targetPath = path.resolve(process.cwd(), targetDir);
 
-        // Check if directory already exists
         if (await pathExists(targetPath)) {
-            console.error(chalk.red(`Error: Directory '${targetDir}' already exists`));
-            process.exit(1);
+            const items = await fs.readdir(targetPath);
+            if (items.length > 0) {
+                spinner.fail(chalk.red(`Directory '${targetDir}' is not empty`));
+                return;
+            }
         }
 
-        console.log(chalk.cyan(`Cloning ${ownerId}/${repoName} into '${targetDir}'...\n`));
-
-        // Fetch repository metadata
-        const spinner = ora('Fetching repository...').start();
-        const repository = await repoService.getRepository(ownerId, repoName);
-        spinner.succeed('Repository fetched');
-
         // Create directory structure
-        await ensureDir(targetPath);
+        spinner.text = 'Setting up repository...';
         const gentPath = path.join(targetPath, GENT_DIR);
         await ensureDir(gentPath);
         await ensureDir(path.join(gentPath, 'objects'));
         await ensureDir(path.join(gentPath, 'refs', 'heads'));
         await ensureDir(path.join(gentPath, 'refs', 'tags'));
 
-        // Create configuration
+        // Store blob objects
+        const objects = response.objects || [];
+        spinner.text = `Storing ${objects.length} object(s)...`;
+
+        for (const obj of objects) {
+            if (obj.type === 'blob' && obj.data) {
+                const buf = Buffer.from(obj.data, 'base64');
+                await storeBlob(gentPath, buf);
+            }
+        }
+
+        // Write commits.json
+        const repoData = {
+            commits: response.commits || [],
+            branches: response.branches || { main: null },
+            currentBranch: response.currentBranch || 'main',
+            tags: response.tags || {}
+        };
+        await writeJSON(path.join(gentPath, COMMITS_FILE), repoData);
+
+        // Write config with remote
         const config = {
-            user: {
-                name: user.first_name && user.last_name ? `${user.first_name} ${user.last_name}` : '',
-                email: user.email
-            },
+            user: { name: '', email: '' },
             repository: {
-                name: repository.name,
-                description: repository.description,
+                name: repoName,
+                description: response.description || '',
                 created: new Date().toISOString()
-            }
+            },
+            remotes: {
+                origin: { url }
+            },
+            remoteRefs: {}
         };
+
+        // Set remote ref to head
+        const headHash = repoData.branches[repoData.currentBranch];
+        if (headHash) {
+            config.remoteRefs[`origin/${repoData.currentBranch}`] = headHash;
+        }
+
         await writeJSON(path.join(gentPath, CONFIG_FILE), config);
 
-        // Create initial files
-        await writeJSON(path.join(gentPath, STAGING_FILE), { files: [] });
-        await writeJSON(path.join(gentPath, COMMITS_FILE), {
-            commits: [],
-            branches: { [repository.default_branch]: null },
-            currentBranch: repository.default_branch
-        });
+        // Write staging.json
+        await writeJSON(path.join(gentPath, STAGING_FILE), { entries: [], files: [] });
 
-        // Create HEAD file
+        // Write HEAD file
         await fs.writeFile(
             path.join(gentPath, 'HEAD'),
-            `ref: refs/heads/${repository.default_branch}\n`
+            `ref: refs/heads/${repoData.currentBranch}\n`
         );
 
-        // Add remote
-        await addRemote('origin', ownerId, repoName, targetPath);
-
-        // Fetch commits, branches, and files
-        try {
-            await syncCommitsFromCloud(ownerId, repoName, targetPath);
-        } catch (error) {
-            // Ignore if repository has no commits yet
-            if (!error.message.includes('404')) {
-                throw error;
+        // Create .gentignore
+        const ignorePath = path.join(targetPath, '.gentignore');
+        await fs.writeFile(ignorePath, `# Gent ignore\nnode_modules/\n.DS_Store\n*.log\n.env\n.gent/\n`);
+
+        // Checkout working tree from HEAD commit
+        if (headHash) {
+            const headCommit = repoData.commits.find(c => c.hash === headHash);
+            if (headCommit) {
+                const tree = headCommit.tree || (headCommit.files || []).map(f => ({
+                    name: f.path || f.name, hash: f.hash
+                }));
+
+                spinner.text = 'Checking out files...';
+                let fileCount = 0;
+                for (const entry of tree) {
+                    try {
+                        const content = await readBlobAsString(gentPath, entry.hash);
+                        const fullPath = path.join(targetPath, entry.name || entry.path);
+                        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+                        await fs.writeFile(fullPath, content, 'utf-8');
+                        fileCount++;
+                    } catch {
+                        // Blob missing
+                    }
+                }
+
+                spinner.succeed(chalk.green(`Cloned into '${targetDir}'`));
+                console.log(chalk.gray(`  ${repoData.commits.length} commit(s), ${objects.length} object(s), ${fileCount} file(s)`));
+            } else {
+                spinner.succeed(chalk.green(`Cloned into '${targetDir}' (empty)`));
             }
-            console.log(chalk.yellow('Note: Repository has no commits yet'));
+        } else {
+            spinner.succeed(chalk.green(`Cloned into '${targetDir}' (no commits)`));
         }
 
-        console.log(chalk.green(`\n✓ Successfully cloned into '${targetDir}'`));
-        console.log(chalk.yellow('\nNext steps:'));
-        console.log(chalk.cyan(`  cd ${targetDir}`));
-        console.log(chalk.cyan('  gent status'), chalk.gray('- Check repository status'));
-
     } catch (error) {
-        console.error(chalk.red('Failed to clone repository'));
-        console.error(chalk.red('Error:'), error.message);
+        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 {
+            console.error(chalk.red('Error:'), error.message);
+        }
         process.exit(1);
     }
 }

package/src/commands/commit.js

@@ -1,18 +1,17 @@
 /**
  * Commit Command - Record changes to the repository
- * Creates a new commit with staged files
+ * Creates a new commit with tree object referencing staged blobs
  */
 
 const path = require('path');
-const fs = require('fs').promises;
 const chalk = require('chalk');
 const inquirer = require('inquirer');
 const ora = require('ora');
-const { getGentPath, readJSON, writeJSON, saveBlob, getBlob } = require('../utils/fileSystem');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
 const authStorage = require('../utils/auth-storage');
 const { STAGING_FILE, COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
-const { generateCommitHash, getFileHash } = require('../utils/helpers');
-const { computeDiff } = require('../utils/diff');
+const { generateCommitHash } = require('../utils/helpers');
+const { storeTree, snapshotFile } = require('../utils/hash-engine');
 
 /**
  * Create a new commit
@@ -25,9 +24,10 @@ async function commit(options) {
 
         // Read staging area
         const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+        const stagedEntries = staging.entries || [];
         const stagedFiles = staging.files || [];
 
-        if (stagedFiles.length === 0) {
+        if (stagedEntries.length === 0 && stagedFiles.length === 0) {
             console.log(chalk.yellow('No changes added to commit'));
             console.log(chalk.gray('Use "gent add <file>..." to stage files'));
             return;
@@ -59,20 +59,14 @@ async function commit(options) {
         let authorName = config.user.name;
         let authorEmail = config.user.email;
 
-        // Fallback to global auth if local config is empty
         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;
-                }
+                if (!authorName) authorName = [globalUser.first_name, globalUser.last_name].filter(Boolean).join(' ');
+                if (!authorEmail) authorEmail = globalUser.email;
             }
         }
 
-        // Fail if still no identity
         if (!authorName || !authorEmail) {
             spinner.stop();
             console.error(chalk.red('Author identity unknown'));
@@ -80,92 +74,106 @@ async function commit(options) {
             return;
         }
 
-        // Create commit object
-        const commit = {
-            sha: generateCommitHash(),
-            message: message,
-            author: {
-                name: authorName,
-                email: authorEmail
-            },
-            timestamp: new Date().toISOString(),
-            parent: repository.branches[repository.currentBranch] ? [repository.branches[repository.currentBranch]] : [],
-            files: []
-        };
+        // Build tree entries from staged data
+        let treeEntries = [];
+
+        if (stagedEntries.length > 0) {
+            // New format: entries already have blob hashes from gent add
+            // Carry forward unchanged files from parent commit
+            const parentHash = repository.branches[repository.currentBranch] || null;
+            const parentCommit = parentHash
+                ? (repository.commits || []).find(c => c.hash === parentHash)
+                : null;
+            const parentTree = parentCommit && parentCommit.tree
+                ? parentCommit.tree
+                : (parentCommit ? parentCommit.files.map(f => ({ mode: '100644', name: f.path, hash: f.hash, type: 'blob' })) : []);
+
+            // Start from parent tree, overlay staged changes
+            const treeMap = new Map(parentTree.map(e => [e.name, e]));
+
+            for (const entry of stagedEntries) {
+                if (entry.status === 'deleted') {
+                    treeMap.delete(entry.path);
+                } else {
+                    treeMap.set(entry.path, {
+                        mode: '100644',
+                        name: entry.path,
+                        hash: entry.hash,
+                        type: 'blob'
+                    });
+                }
+            }
 
-        // Create a map of parent files for quick lookup
-        const parentFilesMap = new Map();
-        if (commit.parent && commit.parent.length > 0) {
-            const parentSha = commit.parent[0];
-            const parentCommit = repository.commits.find(c => c.sha === parentSha);
-            if (parentCommit) {
-                parentCommit.files.forEach(f => parentFilesMap.set(f.path, f.hash));
+            treeEntries = Array.from(treeMap.values());
+        } else {
+            // Legacy fallback: files array without blob hashes
+            for (const file of stagedFiles) {
+                const entry = await snapshotFile(gentPath, cwd, file);
+                treeEntries.push(entry);
             }
         }
 
-        // Hash staged files and compute diffs
-        for (const file of stagedFiles) {
-            const filePath = path.join(cwd, file);
-            let content;
-
-            try {
-                content = await fs.readFile(filePath, 'utf-8');
-            } catch (err) {
-                // If file is deleted or unreadable, we handle it as empty content or handle deletion if we supported it
-                // For now assuming staged files exist
-                content = '';
+        // Store tree object
+        const treeHash = await storeTree(gentPath, treeEntries);
+
+        // Compute diff stats
+        let totalInsertions = 0;
+        let totalDeletions = 0;
+        if (stagedEntries.length > 0) {
+            for (const e of stagedEntries) {
+                if (e.stats) {
+                    totalInsertions += e.stats.insertions || 0;
+                    totalDeletions += e.stats.deletions || 0;
+                }
             }
+        }
 
-            const hash = await getFileHash(filePath);
-
-            // Save the blob for future diffs
-            await saveBlob(content, hash);
-
-            // Get previous content
-            let oldContent = '';
-            if (parentFilesMap.has(file)) {
-                const oldHash = parentFilesMap.get(file);
-                oldContent = await getBlob(oldHash);
+        // Create commit object
+        const commitObj = {
+            hash: generateCommitHash(),
+            message,
+            author: {
+                name: authorName,
+                email: authorEmail
+            },
+            timestamp: new Date().toISOString(),
+            parent: repository.branches[repository.currentBranch] || null,
+            treeHash,
+            tree: treeEntries,
+            files: treeEntries.map(e => ({ path: e.name, hash: e.hash })), // backward compat
+            stats: {
+                filesChanged: stagedEntries.length || stagedFiles.length,
+                insertions: totalInsertions,
+                deletions: totalDeletions
             }
+        };
 
-            // Compute Myers diff
-            const changes = computeDiff(oldContent, content);
-
-            commit.files.push({
-                path: file,
-                hash: hash,
-                diff: changes
-            });
-        }
-
-        // Add commit to repository
+        // Save commit
         repository.commits = repository.commits || [];
-        repository.commits.push(commit);
-        repository.branches[repository.currentBranch] = commit.sha;
+        repository.commits.push(commitObj);
+        repository.branches[repository.currentBranch] = commitObj.hash;
 
-        // Save repository and clear staging
         await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+        // Clear staging
+        staging.entries = [];
         staging.files = [];
         await writeJSON(path.join(gentPath, STAGING_FILE), staging);
 
-        spinner.succeed(chalk.green('✓ Changes committed successfully!'));
-
-        // Display commit info
-        console.log(chalk.cyan(`\n[${repository.currentBranch} ${commit.sha.substring(0, 7)}] ${message}`));
-        console.log(chalk.gray(`Author: ${commit.author.name} <${commit.author.email}>`));
-        console.log(chalk.gray(`Date: ${new Date(commit.timestamp).toLocaleString()}`));
-        console.log(chalk.gray(`\n${commit.files.length} file(s) changed`));
+        spinner.succeed(chalk.green('Changes committed successfully!'));
 
-        // Handle --push option
-        if (options.push) {
-            const push = require('./push');
-            await push('origin', repository.currentBranch, {});
-        }
+        console.log(chalk.cyan(`\n[${repository.currentBranch} ${commitObj.hash.substring(0, 7)}] ${message}`));
+        console.log(chalk.gray(`Author: ${commitObj.author.name} <${commitObj.author.email}>`));
+        console.log(chalk.gray(`Date: ${new Date(commitObj.timestamp).toLocaleString()}`));
+        console.log(chalk.gray(`Tree: ${treeHash.substring(0, 7)}`));
+        console.log(chalk.gray(`\n${commitObj.stats.filesChanged} file(s) changed, `) +
+            chalk.green(`+${totalInsertions} insertions`) + ', ' +
+            chalk.red(`-${totalDeletions} deletions`));
 
     } catch (error) {
         if (error.code === 'ENOENT' && error.message.includes('.gent')) {
             console.error(chalk.red('Error: Not a gent repository'));
-            console.log(chalk.yellow('\nℹ Run "gent init" to initialize a repository'));
+            console.log(chalk.yellow('\nRun "gent init" to initialize a repository'));
         } else {
             console.error(chalk.red('Error:'), error.message);
         }