gent-cli 1.6.0 → 1.8.0

package/README.md

@@ -2,13 +2,14 @@
 
 > 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).
-- **Zero Configuration**: gent init is silent and auto-detects your authenticated user profile.
+- **Cloud Synchronization**: Push and pull repositories to/from the cloud.
+- **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.
 
@@ -48,12 +49,10 @@ gent whoami
 gent logout
 ```
 
-## Usage
+## Local 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
@@ -61,16 +60,12 @@ 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
@@ -79,55 +74,74 @@ 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>
 ```
 
-### 5. View History
+## 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
+```
 
-See your commit history.
+### 2. List Your Repositories
 
 ```bash
-gent log
-# or compact view
-gent log --oneline
+gent list
+# or
+gent ls
 ```
 
-## Branching
+### 3. Clone a Repository
 
-Manage branches just like you're used to.
+```bash
+gent clone <owner_id>/<repo_name>
+# Example: gent clone 1/my-repo
+```
+
+### 4. Push Changes
 
 ```bash
-# Create and switch to a new branch
-gent checkout -b feature-login
+gent push
+# or commit and push in one go
+gent commit -m "Update README" --push
+```
 
-# List branches
-gent branch
+### 5. Pull Changes
 
-# Switch back to main
-gent checkout main
+```bash
+gent pull
+```
 
-# Delete a branch
-gent branch -d feature-login
+### 6. Manage Remotes
+
+```bash
+gent remote add origin <owner_id>/<repo_name>
+gent remote -v
 ```
 
 ## 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": "1.6.0",
+  "version": "1.8.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/clone.js

@@ -0,0 +1,133 @@
+/**
+ * Clone Command - Clone a cloud repository to local
+ * Downloads repository data and sets up local working copy
+ */
+
+const fs = require('fs').promises;
+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');
+
+/**
+ * Clone a cloud repository
+ * @param {string} repoUrl - Repository URL (owner_id/repo_name)
+ * @param {string} directory - Target directory (optional)
+ * @param {Object} options - Command 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);
+        }
+
+        const ownerId = parseInt(parts[0]);
+        const repoName = parts[1];
+
+        if (isNaN(ownerId)) {
+            console.error(chalk.red('Error: Owner ID must be a number'));
+            process.exit(1);
+        }
+
+        // Determine target directory
+        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);
+        }
+
+        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);
+        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
+        const config = {
+            user: {
+                name: user.first_name && user.last_name ? `${user.first_name} ${user.last_name}` : '',
+                email: user.email
+            },
+            repository: {
+                name: repository.name,
+                description: repository.description,
+                created: new Date().toISOString()
+            }
+        };
+        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
+        });
+
+        // Create HEAD file
+        await fs.writeFile(
+            path.join(gentPath, 'HEAD'),
+            `ref: refs/heads/${repository.default_branch}\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;
+            }
+            console.log(chalk.yellow('Note: Repository has no commits yet'));
+        }
+
+        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);
+        process.exit(1);
+    }
+}
+
+module.exports = clone;

package/src/commands/commit.js

@@ -4,13 +4,15 @@
  */
 
 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 } = require('../utils/fileSystem');
+const { getGentPath, readJSON, writeJSON, saveBlob, getBlob } = 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');
 
 /**
  * Create a new commit
@@ -80,31 +82,66 @@ async function commit(options) {
 
         // Create commit object
         const commit = {
-            hash: generateCommitHash(),
+            sha: generateCommitHash(),
             message: message,
             author: {
                 name: authorName,
                 email: authorEmail
             },
             timestamp: new Date().toISOString(),
-            parent: repository.branches[repository.currentBranch] || null,
+            parent: repository.branches[repository.currentBranch] ? [repository.branches[repository.currentBranch]] : [],
             files: []
         };
 
-        // Hash staged files
+        // 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));
+            }
+        }
+
+        // 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 = '';
+            }
+
             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);
+            }
+
+            // Compute Myers diff
+            const changes = computeDiff(oldContent, content);
+
             commit.files.push({
                 path: file,
-                hash: hash
+                hash: hash,
+                diff: changes
             });
         }
 
         // Add commit to repository
         repository.commits = repository.commits || [];
         repository.commits.push(commit);
-        repository.branches[repository.currentBranch] = commit.hash;
+        repository.branches[repository.currentBranch] = commit.sha;
 
         // Save repository and clear staging
         await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
@@ -114,11 +151,17 @@ async function commit(options) {
         spinner.succeed(chalk.green('✓ Changes committed successfully!'));
 
         // Display commit info
-        console.log(chalk.cyan(`\n[${repository.currentBranch} ${commit.hash.substring(0, 7)}] ${message}`));
+        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`));
 
+        // Handle --push option
+        if (options.push) {
+            const push = require('./push');
+            await push('origin', repository.currentBranch, {});
+        }
+
     } catch (error) {
         if (error.code === 'ENOENT' && error.message.includes('.gent')) {
             console.error(chalk.red('Error: Not a gent repository'));

package/src/commands/create.js

@@ -0,0 +1,118 @@
+/**
+ * Create Command - Create a new cloud repository
+ * Creates a repository on the cloud and optionally initializes locally
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const path = require('path');
+const repoService = require('../services/repo-service');
+const authStorage = require('../utils/auth-storage');
+const { ensureDir, writeJSON } = require('../utils/fileSystem');
+const { GENT_DIR } = require('../utils/constants');
+const { addRemote } = require('../utils/cloud-sync');
+
+/**
+ * Create a new repository on the cloud
+ * @param {string} repoName - Repository name
+ * @param {Object} options - Command options
+ */
+async function create(repoName, options) {
+    try {
+        // Check authentication
+        const user = await authStorage.getUser();
+        if (!user) {
+            console.error(chalk.red('Error: You must be logged in to create a repository'));
+            console.log(chalk.yellow('Run'), chalk.cyan('gent login'), chalk.yellow('to authenticate'));
+            process.exit(1);
+        }
+
+        // Validate repository name
+        if (!repoName) {
+            console.error(chalk.red('Error: Repository name is required'));
+            console.log(chalk.yellow('Usage:'), chalk.cyan('gent create <repo-name>'));
+            process.exit(1);
+        }
+
+        // Prompt for additional details if not provided
+        let description = options.description || '';
+        let isPrivate = options.private || false;
+
+        if (!options.yes) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'description',
+                    message: 'Repository description (optional):',
+                    default: description
+                },
+                {
+                    type: 'confirm',
+                    name: 'isPrivate',
+                    message: 'Make repository private?',
+                    default: isPrivate
+                },
+                {
+                    type: 'confirm',
+                    name: 'initLocal',
+                    message: 'Initialize local repository and link remote?',
+                    default: true
+                }
+            ]);
+
+            description = answers.description;
+            isPrivate = answers.isPrivate;
+            options.initLocal = answers.initLocal;
+        }
+
+        // Create repository
+        const spinner = ora('Creating repository...').start();
+
+        const repository = await repoService.createRepository(
+            repoName,
+            description,
+            isPrivate,
+            'main'
+        );
+
+        spinner.succeed(chalk.green(`Repository created: ${repository.name}`));
+
+        console.log(chalk.cyan('\nRepository Details:'));
+        console.log(chalk.gray('  Name:'), repository.name);
+        console.log(chalk.gray('  Owner:'), repository.owner_email);
+        console.log(chalk.gray('  Private:'), repository.is_private ? 'Yes' : 'No');
+        console.log(chalk.gray('  Description:'), repository.description || '(none)');
+        console.log(chalk.gray('  Created:'), new Date(repository.created_at).toLocaleString());
+
+        // Initialize local repository if requested
+        if (options.initLocal) {
+            const cwd = process.cwd();
+            const gentPath = path.join(cwd, GENT_DIR);
+
+            // Create .gent directory
+            await ensureDir(gentPath);
+            await ensureDir(path.join(gentPath, 'objects'));
+            await ensureDir(path.join(gentPath, 'refs', 'heads'));
+
+            // Add remote
+            await addRemote('origin', repository.owner_id, repository.name, cwd);
+
+            console.log(chalk.green('\n✓ Local repository initialized and remote added'));
+            console.log(chalk.yellow('\nNext steps:'));
+            console.log(chalk.cyan('  gent add <files>'), chalk.gray('- Add files to staging'));
+            console.log(chalk.cyan('  gent commit -m "message"'), chalk.gray('- Commit changes'));
+            console.log(chalk.cyan('  gent push'), chalk.gray('- Push to cloud'));
+        } else {
+            console.log(chalk.yellow('\nTo clone this repository:'));
+            console.log(chalk.cyan(`  gent clone ${repository.owner_id}/${repository.name}`));
+        }
+
+    } catch (error) {
+        console.error(chalk.red('Failed to create repository'));
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+}
+
+module.exports = create;

package/src/commands/init.js

@@ -28,9 +28,10 @@ async function init(options) {
         // Get authenticated user profile if available
         let defaultName = '';
         let defaultEmail = '';
+        let user = null;
 
         try {
-            const user = await authStorage.getUser();
+            user = await authStorage.getUser();
             if (user) {
                 if (user.first_name || user.last_name) {
                     defaultName = [user.first_name, user.last_name].filter(Boolean).join(' ');
@@ -62,12 +63,8 @@ async function init(options) {
         await ensureDir(path.join(gentPath, 'refs', 'tags'));
 
         // Create/Update configuration
-        // Only write config if it doesn't exist OR if we have valid user info to update
         const configPath = path.join(gentPath, CONFIG_FILE);
         if (!(await pathExists(configPath)) || (defaultName && defaultEmail)) {
-            // If re-init, we might want to preserve existing config unless we have better info?
-            // Git re-init doesn't overwrite config usually.
-            // But for now, let's write ensuring we have a config file.
             if (!isReinit || !(await pathExists(configPath))) {
                 await writeJSON(configPath, config);
             }
@@ -109,6 +106,37 @@ node_modules/
             console.log(chalk.gray(`Initialized empty Gent repository in ${gentPath}`));
         }
 
+        // Handle --cloud option
+        if (options.cloud) {
+            if (!user) {
+                console.log(chalk.yellow('\nWarning: Skipping cloud repository creation (not logged in)'));
+                console.log(chalk.gray('Run "gent login" then "gent create <name> --init-local"'));
+            } else {
+                try {
+                    const repoService = require('../services/repo-service');
+                    const { addRemote } = require('../utils/cloud-sync');
+                    const ora = require('ora');
+
+                    const spinner = ora('Creating cloud repository...').start();
+                    const repoName = path.basename(cwd);
+
+                    const repository = await repoService.createRepository(
+                        repoName,
+                        options.description || 'A gent repository',
+                        options.private || false,
+                        'main'
+                    );
+
+                    await addRemote('origin', repository.owner_id, repository.name, cwd);
+                    spinner.succeed(chalk.green(`Created cloud repository: ${repository.owner_id}/${repository.name}`));
+                    console.log(chalk.gray(`Remote 'origin' added`));
+                } catch (error) {
+                    console.log(chalk.red(`\nFailed to create cloud repository: ${error.message}`));
+                    console.log(chalk.gray('You can create it later with "gent create <name>"'));
+                }
+            }
+        }
+
     } catch (error) {
         console.error(chalk.red('Failed to initialize repository'));
         console.error(chalk.red('Error:'), error.message);

package/src/commands/list.js

@@ -0,0 +1,67 @@
+/**
+ * List Command - List all cloud repositories
+ * Displays all repositories owned by the authenticated user
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const repoService = require('../services/repo-service');
+const authStorage = require('../utils/auth-storage');
+
+/**
+ * Format date for display
+ * @param {string} dateString - ISO date string
+ * @returns {string} Formatted date
+ */
+function formatDate(dateString) {
+    const date = new Date(dateString);
+    return date.toLocaleDateString();
+}
+
+/**
+ * List all repositories owned by the authenticated user
+ * @param {Object} options - Command options
+ */
+async function list(options) {
+    try {
+        // Check authentication
+        const user = await authStorage.getUser();
+        if (!user) {
+            console.error(chalk.red('Error: You must be logged in to list repositories'));
+            console.log(chalk.yellow('Run'), chalk.cyan('gent login'), chalk.yellow('to authenticate'));
+            process.exit(1);
+        }
+
+        // Fetch repositories
+        const spinner = ora('Fetching repositories...').start();
+        const repositories = await repoService.listRepositories();
+        spinner.stop();
+
+        if (repositories.length === 0) {
+            console.log(chalk.yellow('No repositories found'));
+            console.log(chalk.gray('Create a new repository with:'), chalk.cyan('gent create <repo-name>'));
+            return;
+        }
+
+        console.log(chalk.cyan(`\nYour Repositories (${repositories.length}):\n`));
+
+        repositories.forEach(repo => {
+            const privacy = repo.is_private ? chalk.red('🔒 Private') : chalk.green('🌐 Public');
+            console.log(chalk.bold(repo.name), privacy);
+            if (repo.description) {
+                console.log(chalk.gray(`  ${repo.description}`));
+            }
+            console.log(chalk.gray(`  Owner: ${repo.owner_email}`));
+            console.log(chalk.gray(`  Created: ${formatDate(repo.created_at)}`));
+            console.log(chalk.gray(`  Default branch: ${repo.default_branch}`));
+            console.log(chalk.gray(`  Clone: gent clone ${repo.owner_id}/${repo.name}\n`));
+        });
+
+    } catch (error) {
+        console.error(chalk.red('Failed to list repositories'));
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+}
+
+module.exports = list;

package/src/commands/log.js

@@ -55,10 +55,10 @@ function displayDetailedLog(commits, currentCommitHash, currentBranch) {
     console.log(chalk.bold.cyan(`\nCommit History (${currentBranch} branch):\n`));
 
     commits.forEach((commit, index) => {
-        const isHead = commit.hash === currentCommitHash;
+        const isHead = commit.sha === currentCommitHash;
         const headLabel = isHead ? chalk.yellow.bold(' (HEAD)') : '';
 
-        console.log(chalk.yellow(`commit ${commit.hash}`) + headLabel);
+        console.log(chalk.yellow(`commit ${commit.sha}`) + headLabel);
         console.log(chalk.white(`Author: ${commit.author.name} <${commit.author.email}>`));
         console.log(chalk.white(`Date:   ${new Date(commit.timestamp).toLocaleString()}`));
         console.log(chalk.gray(`        (${formatDistanceToNow(new Date(commit.timestamp), { addSuffix: true })})`));
@@ -79,9 +79,9 @@ function displayDetailedLog(commits, currentCommitHash, currentBranch) {
  */
 function displayOnelineLog(commits, currentCommitHash) {
     commits.forEach(commit => {
-        const isHead = commit.hash === currentCommitHash;
+        const isHead = commit.sha === currentCommitHash;
         const headLabel = isHead ? chalk.yellow(' (HEAD)') : '';
-        const shortHash = chalk.yellow(commit.hash.substring(0, 7));
+        const shortHash = chalk.yellow(commit.sha.substring(0, 7));
         const message = chalk.white(commit.message);
         const timeAgo = chalk.gray(`(${formatDistanceToNow(new Date(commit.timestamp), { addSuffix: true })})`);