gent-cli 5.0.3 → 6.0.0

package/src/commands/repos.js

@@ -0,0 +1,103 @@
+/**
+ * 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);
+    const repo = data.repository || data;
+
+    spinner.succeed(chalk.green(`Created repository '${repo.name}'`));
+    console.log(chalk.gray(`  URL: /api/repos/${repo.owner_id}/${repo.name}`));
+    console.log(chalk.gray(`  Use "gent remote add origin /api/repos/${repo.owner_id}/${repo.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');
@@ -52,7 +53,7 @@ const whoamiCommand = require('./commands/whoami');
 program
     .name('gent')
     .description(chalk.cyan('Gent - A Git-like version control CLI with cloud backend'))
-    .version(packageJson.version, '-v, --version', 'Output the current version');
+    .version(packageJson.version, '-V, --version', 'Output the current version');
 
 // ─── Repository Setup ───────────────────────────────────
 
@@ -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')
@@ -184,6 +195,11 @@ program
 program
     .command('register')
     .description('Create a new user account')
+    .option('-e, --email <email>', 'Email address')
+    .option('-p, --password <password>', 'Password')
+    .option('--password-confirm <password>', 'Password confirmation')
+    .option('--first-name <name>', 'First name')
+    .option('--last-name <name>', 'Last name')
     .action(registerCommand);
 
 program
@@ -226,7 +242,7 @@ try {
         program.outputHelp();
     }
 } catch (err) {
-    if (err.code !== 'commander.help' && err.code !== 'commander.helpDisplayed') {
+    if (err.code !== 'commander.help' && err.code !== 'commander.helpDisplayed' && err.code !== 'commander.version') {
         console.error(chalk.red('Error:'), err.message);
         process.exit(1);
     }

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

package/src/utils/hash-engine.js

@@ -137,6 +137,29 @@ function hashBlob(content) {
     return hashObject('blob', content);
 }
 
+/**
+ * Decode blob content returned by the backend.
+ * Current Django endpoints return raw UTF-8 content, while older/planned pull
+ * responses may return base64. Prefer the representation whose blob hash
+ * matches the expected object SHA.
+ * @param {String} content
+ * @param {String} expectedHash
+ * @returns {Buffer}
+ */
+function decodeRemoteBlobContent(content, expectedHash) {
+    const raw = Buffer.from(content, 'utf-8');
+    if (!expectedHash || hashBlob(raw) === expectedHash) {
+        return raw;
+    }
+
+    const decoded = Buffer.from(content, 'base64');
+    if (hashBlob(decoded) === expectedHash) {
+        return decoded;
+    }
+
+    return raw;
+}
+
 /**
  * Hash a tree structure.
  * @param {Array<{mode: String, name: String, hash: String, type: String}>} entries
@@ -324,6 +347,7 @@ module.exports = {
     hashObject,
     hashBlob,
     hashTree,
+    decodeRemoteBlobContent,
     objectExists,
     storeBlob,
     readBlob,