gent-cli 1.5.0 → 1.7.0

package/README.md

@@ -2,23 +2,24 @@
 
 > 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
+## 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`).
+- **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.
 - **Global Identity**: Commits are automatically authored with your cloud profile.
 - **Secure**: Tokens stored securely in your home directory.
 
-## 📦 Installation
+## Installation
 
 ```bash
 npm install -g gent-cli
 ```
 
-## 🔐 Authentication (The Magic mmss)
+## Authentication
 
 Gent uses a global authentication system. You only need to login once.
 
@@ -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,43 +74,61 @@ 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
+## Repository Structure
 
 Gent creates a `.gent` directory in your project root:
 
@@ -124,19 +137,20 @@ Gent creates a `.gent` directory in your project root:
 ├── 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`.
 
-## 🤝 Contributing
+## Contributing
 
 We welcome contributions! Please fork the repository and submit a Pull Request.
 
-## 📄 License
+## License
 
 ISC
 
 ---
 
-Built with ❤️ by [Abdalrahman Kanawati](https://github.com/SaadShaya7)
+Built with love by [Abdalrahman Kanawati](https://github.com/abdo-ka)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "1.5.0",
+  "version": "1.7.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
@@ -91,13 +93,47 @@ async function commit(options) {
             files: []
         };
 
-        // Hash staged files
+        // Create a map of parent files for quick lookup
+        const parentFilesMap = new Map();
+        if (commit.parent) {
+            const parentCommit = repository.commits.find(c => c.hash === commit.parent);
+            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
             });
         }
 
@@ -119,6 +155,12 @@ async function commit(options) {
         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;