gent-cli 2.1.0 → 5.0.0

package/README.md

@@ -2,14 +2,13 @@
 
 > A modern, Git-like version control CLI with built-in cloud authentication and global user identity management.
 
-Gent is a lightweight version control system that feels exactly like Git but handles user identity automatically through the cloud. No more configuring `user.name` and `user.email` for every repository!
+Gent is a lightweight version control system that feels exactly like Git but handles user identity automatically through the cloud. No more configuring user.name and user.email for every repository!
 
 ## Features
 
 - **Cloud Authentication**: Login once, work everywhere. Your identity follows you across projects.
 - **Git-like Experience**: Familiar commands (init, add, commit, status, log, branch, checkout).
-- **Cloud Synchronization**: Push and pull repositories to/from the cloud.
-- **Zero Configuration**: `gent init` is silent and auto-detects your authenticated user profile.
+- **Zero Configuration**: gent init is silent and auto-detects your authenticated user profile.
 - **Global Identity**: Commits are automatically authored with your cloud profile.
 - **Secure**: Tokens stored securely in your home directory.
 
@@ -49,10 +48,12 @@ gent whoami
 gent logout
 ```
 
-## Local Usage
+## Usage
 
 ### 1. Initialize a Repository
 
+Just like Git, gent init is silent and sets up a new repository in your current directory. It automatically uses your logged-in identity for configuration.
+
 ```bash
 gent init
 # Output: Initialized empty Gent repository in /path/to/project
@@ -60,12 +61,16 @@ gent init
 
 ### 2. Check Status
 
+See which files are modified or untracked.
+
 ```bash
 gent status
 ```
 
 ### 3. Stage Files
 
+Add files to the staging area.
+
 ```bash
 gent add filename.js
 # or add all files
@@ -74,74 +79,55 @@ gent add .
 
 ### 4. Commit Changes
 
+Create a commit. Gent automatically fetches your name and email from your global login session.
+
 ```bash
 gent commit -m "Initial commit"
 # Output: [main a1b2c3d] Initial commit
 # Author: Your Name <your.email@example.com>
 ```
 
-## Cloud Features
-
-### 1. Create a Cloud Repository
-
-```bash
-# Create and link a local repo
-gent create my-repo --init-local
-
-# Or initialize with cloud directly
-gent init --cloud
-```
+### 5. View History
 
-### 2. List Your Repositories
+See your commit history.
 
 ```bash
-gent list
-# or
-gent ls
+gent log
+# or compact view
+gent log --oneline
 ```
 
-### 3. Clone a Repository
+## Branching
 
-```bash
-gent clone <owner_id>/<repo_name>
-# Example: gent clone 1/my-repo
-```
-
-### 4. Push Changes
+Manage branches just like you're used to.
 
 ```bash
-gent push
-# or commit and push in one go
-gent commit -m "Update README" --push
-```
+# Create and switch to a new branch
+gent checkout -b feature-login
 
-### 5. Pull Changes
+# List branches
+gent branch
 
-```bash
-gent pull
-```
+# Switch back to main
+gent checkout main
 
-### 6. Manage Remotes
-
-```bash
-gent remote add origin <owner_id>/<repo_name>
-gent remote -v
+# Delete a branch
+gent branch -d feature-login
 ```
 
 ## Repository Structure
 
-Gent creates a `.gent` directory in your project root:
+Gent creates a .gent directory in your project root:
 
 ```
 .gent/
 ├── config.json       # Project configuration
 ├── objects/          # Stored file contents
 ├── refs/             # Branch pointers
-├── remote.json       # Remote configuration
 └── HEAD             # Current branch reference
 ```
 
-Your authentication tokens are stored globally in `~/.gent/auth.json`.
+Your authentication tokens are stored globally in ~/.gent/auth.json.
 
 ## Contributing
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "2.1.0",
+  "version": "5.0.0",
   "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/add.js

@@ -1,13 +1,16 @@
 /**
  * Add Command - Add file contents to the staging area
- * Stages files for the next commit
+ * Stages files with content snapshots (blobs) and diff stats
  */
 
+const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
 const { getGentPath, readJSON, writeJSON, pathExists, getAllFiles, getIgnorePatterns } = require('../utils/fileSystem');
-const { STAGING_FILE } = require('../utils/constants');
+const { STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+const { storeBlob, hashBlob, isBinaryBuffer, snapshotFile } = require('../utils/hash-engine');
+const { diffText, formatUnifiedDiff } = require('../utils/diff-engine');
 
 /**
  * Add files to staging area
@@ -24,7 +27,19 @@ async function add(files, options) {
 
         // Read current staging area
         const staging = await readJSON(stagingPath);
-        const stagedFiles = new Set(staging.files || []);
+        const stagedEntries = staging.entries || [];
+        const stagedMap = new Map(stagedEntries.map(e => [e.path, e]));
+
+        // Get last commit tree for diff comparison
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const lastCommitHash = repository.branches[repository.currentBranch] || null;
+        const lastCommit = lastCommitHash
+            ? (repository.commits || []).find(c => c.hash === lastCommitHash)
+            : null;
+        const lastTreeMap = new Map(
+            (lastCommit && lastCommit.tree ? lastCommit.tree : (lastCommit ? lastCommit.files : []))
+                .map(f => [f.path || f.name, f.hash])
+        );
 
         let filesToAdd = [];
 
@@ -35,49 +50,113 @@ async function add(files, options) {
             const allFiles = await getAllFiles(cwd, ignorePatterns);
             filesToAdd = allFiles.map(f => path.relative(cwd, f));
         } else {
-            // Add specified files
             for (const file of files) {
                 const filePath = path.resolve(cwd, file);
-
                 if (!await pathExists(filePath)) {
                     spinner.warn(chalk.yellow(`Warning: File not found: ${file}`));
                     continue;
                 }
-
-                const relativePath = path.relative(cwd, filePath);
-                filesToAdd.push(relativePath);
+                filesToAdd.push(path.relative(cwd, filePath));
             }
         }
 
-        // Add files to staging
+        // Snapshot each file → store blob, compute diff
         let addedCount = 0;
-        for (const file of filesToAdd) {
-            if (!stagedFiles.has(file)) {
-                stagedFiles.add(file);
+        let totalInsertions = 0;
+        let totalDeletions = 0;
+        const diffSummaries = [];
+
+        for (const relPath of filesToAdd) {
+            const fullPath = path.join(cwd, relPath);
+            const content = await fs.readFile(fullPath);
+
+            // Skip binary files for diff (still store blob)
+            const binary = isBinaryBuffer(content);
+            const blobHash = await storeBlob(gentPath, content);
+
+            // Check if changed vs last commit
+            const prevHash = lastTreeMap.get(relPath);
+            if (prevHash === blobHash && stagedMap.has(relPath)) {
+                continue; // unchanged, already staged
+            }
+
+            // Determine change status
+            let status = 'added';
+            let stats = { insertions: 0, deletions: 0 };
+
+            if (prevHash && prevHash !== blobHash && !binary) {
+                status = 'modified';
+                try {
+                    const { readBlobAsString } = require('../utils/hash-engine');
+                    const oldContent = await readBlobAsString(gentPath, prevHash);
+                    const diff = diffText(oldContent, content.toString('utf-8'));
+                    stats = { insertions: diff.stats.insertions, deletions: diff.stats.deletions };
+                } catch {
+                    // Old blob may not exist yet (first time adding objects)
+                }
+            } else if (!prevHash) {
+                status = 'added';
+                stats.insertions = content.toString('utf-8').split('\n').length;
+            }
+
+            totalInsertions += stats.insertions;
+            totalDeletions += stats.deletions;
+
+            // Update staging entry
+            stagedMap.set(relPath, {
+                path: relPath,
+                hash: blobHash,
+                status,
+                binary,
+                stats
+            });
+
+            diffSummaries.push({ path: relPath, status, stats, binary });
+            addedCount++;
+        }
+
+        // Detect deleted files (tracked in last commit but gone from disk)
+        for (const [trackedPath, trackedHash] of lastTreeMap) {
+            const fullPath = path.join(cwd, trackedPath);
+            if (!await pathExists(fullPath) && !stagedMap.has(trackedPath)) {
+                stagedMap.set(trackedPath, {
+                    path: trackedPath,
+                    hash: null,
+                    status: 'deleted',
+                    binary: false,
+                    stats: { insertions: 0, deletions: 0 }
+                });
+                diffSummaries.push({ path: trackedPath, status: 'deleted', stats: { insertions: 0, deletions: 0 }, binary: false });
                 addedCount++;
             }
         }
 
-        // Save staging area
-        staging.files = Array.from(stagedFiles);
+        // Save staging area (new format with entries)
+        staging.entries = Array.from(stagedMap.values());
+        staging.files = staging.entries.map(e => e.path); // backward compat
         await writeJSON(stagingPath, staging);
 
-        spinner.succeed(chalk.green(`✓ Added ${addedCount} file(s) to staging area`));
+        spinner.succeed(chalk.green(`Added ${addedCount} file(s) to staging area`));
 
-        if (addedCount > 0) {
-            console.log(chalk.gray('\nStaged files:'));
-            staging.files.forEach(file => {
-                console.log(chalk.green(`  ${file}`));
-            });
-            console.log(chalk.cyan('\nℹ Use "gent commit" to record your changes'));
+        if (diffSummaries.length > 0) {
+            console.log('');
+            for (const d of diffSummaries) {
+                const statusIcon = d.status === 'added' ? chalk.green('+ new')
+                    : d.status === 'deleted' ? chalk.red('- del')
+                        : chalk.yellow('~ mod');
+                const statsStr = d.binary ? chalk.gray('(binary)')
+                    : chalk.green(`+${d.stats.insertions}`) + ' ' + chalk.red(`-${d.stats.deletions}`);
+                console.log(`  ${statusIcon}  ${d.path}  ${statsStr}`);
+            }
+            console.log(chalk.gray(`\n  Total: `) + chalk.green(`+${totalInsertions}`) + ' ' + chalk.red(`-${totalDeletions}`));
+            console.log(chalk.cyan('\nUse "gent commit" to record your changes'));
         }
 
     } catch (error) {
         spinner.fail(chalk.red('Failed to add files'));
-
         if (error.code === 'ENOENT' && error.message.includes('.gent')) {
             console.error(chalk.red('\nError: Not a gent repository'));
-            console.log(chalk.yellow('ℹ Run "gent init" to initialize a repository'));
+            console.log(chalk.yellow('Run "gent init" to initialize a repository'));
         } else {
             console.error(chalk.red('\nError:'), error.message);
         }

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