gent-cli 7.0.0 → 8.0.0

package/src/commands/doctor.js

@@ -0,0 +1,169 @@
+/**
+ * Doctor Command - Health check for the gent CLI.
+ *
+ *   gent doctor              → run all checks
+ *   gent doctor --ai         → also ping Anthropic with a 1-token request
+ *
+ * Each row prints PASS / WARN / FAIL plus a hint on how to fix the issue.
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const chalk = require('chalk');
+const axios = require('axios');
+const packageJson = require('../../package.json');
+const { GENT_DIR } = require('../utils/constants');
+const userConfig = require('../utils/user-config');
+const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
+const ai = require('../utils/ai-service');
+
+const MIN_NODE_MAJOR = 18;
+
+async function doctor(options = {}) {
+    console.log(chalk.bold.cyan('\nGent CLI health check\n'));
+
+    const checks = [];
+
+    checks.push(await checkNodeVersion());
+    checks.push(await checkCliVersion());
+    checks.push(await checkRepo());
+    checks.push(await checkAuth());
+    checks.push(await checkApi());
+    checks.push(await checkAiKey(!!options.ai));
+
+    for (const c of checks) {
+        printCheck(c);
+    }
+
+    const failed = checks.filter(c => c.status === 'fail').length;
+    const warned = checks.filter(c => c.status === 'warn').length;
+    const passed = checks.filter(c => c.status === 'pass').length;
+
+    console.log();
+    console.log(
+        chalk.green(`  ${passed} pass`) + '  ' +
+        chalk.yellow(`${warned} warn`) + '  ' +
+        chalk.red(`${failed} fail`)
+    );
+
+    if (failed > 0) process.exit(1);
+}
+
+function printCheck(c) {
+    const badge = c.status === 'pass' ? chalk.green('✓ PASS')
+        : c.status === 'warn' ? chalk.yellow('! WARN')
+        : chalk.red('✗ FAIL');
+    console.log(`  ${badge}  ${chalk.bold(c.name)} ${chalk.gray(`— ${c.detail}`)}`);
+    if (c.hint) console.log(chalk.gray(`           hint: ${c.hint}`));
+}
+
+async function checkNodeVersion() {
+    const v = process.versions.node;
+    const major = parseInt(v.split('.')[0], 10);
+    if (major >= MIN_NODE_MAJOR) {
+        return { name: 'Node version', status: 'pass', detail: `v${v}` };
+    }
+    return {
+        name: 'Node version',
+        status: 'fail',
+        detail: `v${v} (need ≥${MIN_NODE_MAJOR})`,
+        hint: `Install Node ${MIN_NODE_MAJOR}+ — e.g. via nvm.`,
+    };
+}
+
+async function checkCliVersion() {
+    return {
+        name: 'Gent CLI',
+        status: 'pass',
+        detail: `v${packageJson.version}`,
+    };
+}
+
+async function checkRepo() {
+    const gentPath = path.join(process.cwd(), GENT_DIR);
+    try {
+        const stat = await fs.stat(gentPath);
+        if (!stat.isDirectory()) throw new Error('not a directory');
+        return { name: 'Repository (.gent)', status: 'pass', detail: gentPath };
+    } catch {
+        return {
+            name: 'Repository (.gent)',
+            status: 'warn',
+            detail: 'not a gent repo (this directory)',
+            hint: 'Run `gent init` to start a repo here, or cd into one.',
+        };
+    }
+}
+
+async function checkAuth() {
+    const isAuth = await authStorage.isAuthenticated();
+    if (!isAuth) {
+        return {
+            name: 'Authentication',
+            status: 'warn',
+            detail: 'not logged in',
+            hint: 'Run `gent login` or `gent register`.',
+        };
+    }
+    const user = await authStorage.getUser();
+    const who = user ? `${user.email}` : 'unknown user';
+    return { name: 'Authentication', status: 'pass', detail: who };
+}
+
+async function checkApi() {
+    const { value: baseUrl, source } = await userConfig.getResolved('api.base_url');
+    try {
+        await axios.get(baseUrl, { timeout: 8000, validateStatus: () => true });
+        return {
+            name: 'Backend reachable',
+            status: 'pass',
+            detail: `${baseUrl}  [${source}]`,
+        };
+    } catch (err) {
+        return {
+            name: 'Backend reachable',
+            status: 'fail',
+            detail: `${baseUrl} → ${err.code || err.message}`,
+            hint: 'If running a local server: `gent config set api.base_url http://localhost:8000`.',
+        };
+    }
+}
+
+async function checkAiKey(probe) {
+    const { value: key, source } = await ai.resolveKey();
+    if (!key) {
+        return {
+            name: 'AI key',
+            status: 'warn',
+            detail: 'not configured (AI features will be skipped, not failed)',
+            hint: 'Run `gent config set ai.api_key <key>` or set ANTHROPIC_API_KEY.',
+        };
+    }
+
+    if (!probe) {
+        return {
+            name: 'AI key',
+            status: 'pass',
+            detail: `present [${source}], model: ${await ai.resolveModel()} (use --ai to live-test)`,
+        };
+    }
+
+    try {
+        await ai.complete({ prompt: 'ping', maxTokens: 4 });
+        return {
+            name: 'AI key',
+            status: 'pass',
+            detail: `verified — model ${await ai.resolveModel()} responded`,
+        };
+    } catch (err) {
+        return {
+            name: 'AI key',
+            status: 'fail',
+            detail: err.message,
+            hint: 'Re-check the key (`gent config set ai.api_key`) or model (`gent config set ai.model`).',
+        };
+    }
+}
+
+module.exports = doctor;

package/src/commands/pull.js

@@ -30,7 +30,7 @@ const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
 const { COMMITS_FILE, CONFIG_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
 const apiClient = require('../utils/api-client');
 const authStorage = require('../utils/auth-storage');
-const { storeBlob, objectExists, readBlobAsString, decodeRemoteBlobContent } = require('../utils/hash-engine');
+const { storeBlob, objectExists, readBlob, readBlobAsString, decodeRemoteBlobContent } = require('../utils/hash-engine');
 const { findMergeBase, mergeTreeEntries } = require('../utils/merge-engine');
 const { generateCommitHash } = require('../utils/helpers');
 
@@ -311,10 +311,11 @@ async function checkoutTree(gentPath, cwd, previousTree, nextTree) {
         const relPath = entry.name || entry.path;
         if (!relPath || !entry.hash) continue;
 
-        const content = await readBlobAsString(gentPath, entry.hash);
+        // Write the raw Buffer so binary blobs round-trip byte-exact.
+        const buf = await readBlob(gentPath, entry.hash);
         const fullPath = path.join(cwd, relPath);
         await fs.mkdir(path.dirname(fullPath), { recursive: true });
-        await fs.writeFile(fullPath, content, 'utf-8');
+        await fs.writeFile(fullPath, buf);
     }
 }
 

package/src/commands/review.js

@@ -0,0 +1,157 @@
+/**
+ * Review Command - AI code review on staged or HEAD changes.
+ *
+ *   gent review                → review staged changes (or HEAD if no staging)
+ *   gent review --staged       → force staged
+ *   gent review --head         → force HEAD commit diff
+ *   gent review <ref>          → review diff for that commit
+ *
+ * Output: prioritized bug/risk list followed by smaller polish suggestions.
+ * Without an AI key, prints the raw diff so the command still has value.
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { getGentPath, readJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE, STAGING_FILE } = require('../utils/constants');
+const { readBlobAsString, treeToMap } = require('../utils/hash-engine');
+const { formatUnifiedDiff } = require('../utils/diff-engine');
+const ai = require('../utils/ai-service');
+
+const MAX_DIFF_CHARS = 16000;
+
+async function review(refArg, options = {}) {
+    try {
+        const gentPath = await getGentPath();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const commits = repository.commits || [];
+        const commitMap = new Map(commits.map(c => [c.hash, c]));
+
+        let title;
+        let diffText;
+
+        const explicitStaged = options.staged === true;
+        const explicitHead = options.head === true;
+        let useStaged = explicitStaged;
+
+        if (!explicitStaged && !explicitHead && !refArg) {
+            // Default: staged if anything is staged, else HEAD
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE)).catch(() => ({}));
+            const entries = staging.entries || [];
+            useStaged = entries.length > 0;
+        }
+
+        if (useStaged) {
+            const result = await stagedDiff(gentPath, repository, commitMap);
+            if (!result) {
+                console.log(chalk.yellow('Nothing staged to review.'));
+                return;
+            }
+            title = 'Staged changes';
+            diffText = result;
+        } else {
+            const ref = refArg || repository.branches[repository.currentBranch];
+            const commit = ref ? (commitMap.get(ref) || commits.find(c => c.hash.startsWith(ref))) : null;
+            if (!commit) {
+                console.log(chalk.yellow(ref ? `Commit '${ref}' not found` : 'No commits yet'));
+                return;
+            }
+            const parent = commit.parent ? commitMap.get(commit.parent) : null;
+            title = `Commit ${commit.hash.slice(0, 7)} — ${commit.message.split('\n')[0]}`;
+            diffText = await diffTrees(gentPath, treeEntriesOf(parent), treeEntriesOf(commit));
+        }
+
+        if (!diffText) {
+            console.log(chalk.gray('No textual changes to review.'));
+            return;
+        }
+
+        const trimmed = diffText.length > MAX_DIFF_CHARS
+            ? diffText.slice(0, MAX_DIFF_CHARS) + '\n... (diff truncated)'
+            : diffText;
+
+        console.log(chalk.bold.cyan(`\n${title}\n`));
+
+        if (!ai.isEnabled()) {
+            console.log(trimmed);
+            console.log(chalk.gray(`\n${ai.disabledHint()}`));
+            return;
+        }
+
+        const spinner = ora(`Reviewing with ${ai.getModel()}...`).start();
+        try {
+            const out = await ai.complete({
+                system:
+                    'You are a senior code reviewer. Given a unified diff, list concrete ' +
+                    'issues you would block on, then smaller suggestions. Format:\n' +
+                    '🔴 Bugs / risks\n  - file:line — short description\n' +
+                    '🟡 Suggestions\n  - file — short description\n' +
+                    '🟢 Looks good\n  - one-line positive note\n' +
+                    'Be specific. If nothing is wrong, say so plainly.',
+                prompt: `Review this diff:\n\n${trimmed}`,
+                maxTokens: 1500,
+                thinking: true,
+            });
+            spinner.stop();
+            console.log(out + '\n');
+        } catch (err) {
+            spinner.fail(chalk.yellow('AI review failed — showing the raw diff instead'));
+            console.log(chalk.gray(`(${err.message})\n`));
+            console.log(trimmed);
+        }
+    } catch (error) {
+        if (error.code === 'ENOENT' && error.message.includes('.gent')) {
+            console.error(chalk.red('Error: Not a gent repository'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+function treeEntriesOf(commit) {
+    if (!commit) return [];
+    if (Array.isArray(commit.tree)) return commit.tree;
+    return (commit.files || []).map(f => ({ name: f.path || f.name, hash: f.hash }));
+}
+
+async function diffTrees(gentPath, oldEntries, newEntries) {
+    const oldMap = treeToMap(oldEntries);
+    const newMap = treeToMap(newEntries);
+    const files = new Set([...oldMap.keys(), ...newMap.keys()]);
+    const parts = [];
+    for (const file of files) {
+        const oh = oldMap.get(file);
+        const nh = newMap.get(file);
+        if (oh === nh) continue;
+        let oldText = '', newText = '';
+        try { if (oh) oldText = await readBlobAsString(gentPath, oh); } catch { /* binary */ }
+        try { if (nh) newText = await readBlobAsString(gentPath, nh); } catch { /* binary */ }
+        const d = formatUnifiedDiff(file, oldText, newText);
+        if (d) parts.push(d);
+    }
+    return parts.join('\n\n');
+}
+
+async function stagedDiff(gentPath, repository, commitMap) {
+    const staging = await readJSON(path.join(gentPath, STAGING_FILE)).catch(() => ({}));
+    const entries = staging.entries || [];
+    if (entries.length === 0) return null;
+
+    const headHash = repository.branches[repository.currentBranch];
+    const head = headHash ? commitMap.get(headHash) : null;
+    const headTree = treeEntriesOf(head);
+    const overlay = new Map(headTree.map(e => [e.name, e.hash]));
+    for (const e of entries) {
+        if (e.status === 'deleted') overlay.delete(e.path);
+        else overlay.set(e.path, e.hash);
+    }
+    return diffTrees(
+        gentPath,
+        headTree,
+        [...overlay].map(([name, hash]) => ({ name, hash }))
+    );
+}
+
+module.exports = review;

package/src/commands/search.js

@@ -0,0 +1,77 @@
+/**
+ * Search Command - Fuzzy-search your repositories on the gent backend.
+ *
+ *   gent search <query>
+ *   gent search --mine                   → only repos you own
+ *   gent search --json                   → machine-readable output
+ *
+ * The current backend's /api/repos/ endpoint returns the user's repos; we
+ * filter client-side. If the backend grows a search endpoint, switch the URL.
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const { API_ENDPOINTS } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
+
+async function search(query, options = {}) {
+    try {
+        if (!query && !options.mine) {
+            console.error(chalk.red('Usage: gent search <query>'));
+            process.exit(1);
+        }
+
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            console.error(chalk.red('Not authenticated.'));
+            console.log(chalk.yellow('Run `gent login` first.'));
+            process.exit(1);
+        }
+
+        const spinner = ora('Searching...').start();
+        const data = await apiClient.get(API_ENDPOINTS.REPOS);
+        const repos = Array.isArray(data) ? data : (data.results || []);
+        spinner.stop();
+
+        const me = await authStorage.getUser();
+        const myId = me?.id;
+
+        const q = (query || '').toLowerCase();
+        const filtered = repos.filter(r => {
+            if (options.mine && myId && r.owner_id !== myId) return false;
+            if (!q) return true;
+            const haystack = [r.name, r.description, r.owner_name, r.owner_email]
+                .filter(Boolean).join(' ').toLowerCase();
+            return haystack.includes(q);
+        });
+
+        if (options.json) {
+            console.log(JSON.stringify(filtered, null, 2));
+            return;
+        }
+
+        if (filtered.length === 0) {
+            console.log(chalk.gray('No matches.'));
+            return;
+        }
+
+        console.log(chalk.bold.cyan(`\nFound ${filtered.length} repo(s):\n`));
+        for (const r of filtered) {
+            const visibility = r.is_private ? chalk.red('private') : chalk.green('public');
+            const desc = r.description ? chalk.gray(` — ${r.description}`) : '';
+            console.log(`  ${chalk.white.bold(r.name)} [${visibility}]${desc}`);
+            console.log(`    ${chalk.gray(`/api/repos/${r.owner_id}/${r.name}`)}`);
+        }
+        console.log();
+    } catch (error) {
+        if (error.response?.status === 401) {
+            console.error(chalk.red('Authentication failed — run `gent login`.'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = search;

package/src/commands/setup.js

@@ -0,0 +1,201 @@
+/**
+ * Setup Command - First-run interactive wizard.
+ *
+ *   gent setup
+ *
+ * Walks the user through: backend URL → login/register → AI key → identity.
+ * Each step is skippable; nothing is required.
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const boxen = require('boxen');
+const ora = require('ora');
+const axios = require('axios');
+const userConfig = require('../utils/user-config');
+const authStorage = require('../utils/auth-storage');
+const authService = require('../services/auth-service');
+const ai = require('../utils/ai-service');
+
+async function setup() {
+    console.log(boxen(
+        chalk.bold.cyan('Welcome to Gent\n') +
+        chalk.white('Let\'s get you set up. Every step is optional — press Enter to skip.'),
+        { padding: 1, margin: 1, borderStyle: 'round', borderColor: 'cyan' }
+    ));
+
+    await stepBackend();
+    await stepAuth();
+    await stepAiKey();
+    await stepIdentity();
+
+    console.log(chalk.green('\n✓ Setup complete!'));
+    console.log(chalk.gray('  Run `gent doctor` any time to verify your setup.\n'));
+}
+
+async function stepBackend() {
+    console.log(chalk.bold('\n1. Backend server'));
+    const current = await userConfig.getResolved('api.base_url');
+    console.log(chalk.gray(`   Current: ${current.value} [${current.source}]`));
+
+    const { change } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'change',
+        message: 'Change backend URL?',
+        default: false,
+    }]);
+    if (!change) return;
+
+    const { url } = await inquirer.prompt([{
+        type: 'input',
+        name: 'url',
+        message: 'Backend URL:',
+        default: current.value,
+        validate: (v) => /^https?:\/\//.test(v) || 'Must start with http:// or https://',
+    }]);
+
+    const spinner = ora('Probing backend...').start();
+    try {
+        await axios.get(url, { timeout: 8000, validateStatus: () => true });
+        spinner.succeed(chalk.green('Backend reachable'));
+    } catch (err) {
+        spinner.warn(chalk.yellow(`Could not reach ${url} (${err.code || err.message}) — saving anyway`));
+    }
+    await userConfig.set('api.base_url', url);
+}
+
+async function stepAuth() {
+    console.log(chalk.bold('\n2. Account'));
+    const isAuth = await authStorage.isAuthenticated();
+    if (isAuth) {
+        const user = await authStorage.getUser();
+        console.log(chalk.gray(`   Already logged in as ${user?.email || 'unknown'} — skipping.`));
+        return;
+    }
+
+    const { action } = await inquirer.prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+            { name: 'Log in to an existing account', value: 'login' },
+            { name: 'Create a new account', value: 'register' },
+            { name: 'Skip for now', value: 'skip' },
+        ],
+        default: 'login',
+    }]);
+    if (action === 'skip') return;
+
+    const credentials = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email:',
+            validate: (v) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) || 'Invalid email',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            mask: '*',
+        },
+    ]);
+
+    const spinner = ora(action === 'login' ? 'Logging in...' : 'Creating account...').start();
+    try {
+        if (action === 'login') {
+            await authService.login(credentials.email, credentials.password);
+        } else {
+            const more = await inquirer.prompt([
+                { type: 'password', name: 'passwordConfirm', message: 'Confirm password:', mask: '*' },
+                { type: 'input', name: 'firstName', message: 'First name:', default: '' },
+                { type: 'input', name: 'lastName', message: 'Last name:', default: '' },
+            ]);
+            await authService.register(
+                credentials.email,
+                credentials.password,
+                more.passwordConfirm,
+                more.firstName,
+                more.lastName
+            );
+        }
+        spinner.succeed(chalk.green('Signed in'));
+    } catch (err) {
+        spinner.fail(chalk.red(err.message));
+    }
+}
+
+async function stepAiKey() {
+    console.log(chalk.bold('\n3. AI features (optional)'));
+    const existing = await ai.resolveKey();
+    if (existing.value) {
+        console.log(chalk.gray(`   Key already configured [${existing.source}] — skipping.`));
+        return;
+    }
+
+    console.log(chalk.gray('   Gent uses Anthropic Claude for commit-message suggestions,'));
+    console.log(chalk.gray('   diff explanations, AI conflict resolution, code review, and more.'));
+    console.log(chalk.gray('   Get a key at: https://console.anthropic.com/settings/keys'));
+
+    const { provide } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'provide',
+        message: 'Add an Anthropic API key now?',
+        default: true,
+    }]);
+    if (!provide) return;
+
+    const { key } = await inquirer.prompt([{
+        type: 'password',
+        name: 'key',
+        message: 'Anthropic API key:',
+        mask: '*',
+        validate: (v) => v.length > 0 || 'Cannot be empty',
+    }]);
+
+    await userConfig.set('ai.api_key', key);
+
+    const { testNow } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'testNow',
+        message: 'Test the key now (1 small request)?',
+        default: true,
+    }]);
+    if (testNow) {
+        const spinner = ora('Asking Claude to say hi...').start();
+        try {
+            await ai.complete({ prompt: 'Reply with the single word: ok', maxTokens: 4 });
+            spinner.succeed(chalk.green('AI key works'));
+        } catch (err) {
+            spinner.fail(chalk.red(err.message));
+            console.log(chalk.yellow('   You can fix this with `gent config set ai.api_key <key>`.'));
+        }
+    }
+}
+
+async function stepIdentity() {
+    console.log(chalk.bold('\n4. Default identity'));
+    const currentName = await userConfig.getResolved('user.name');
+    const currentEmail = await userConfig.getResolved('user.email');
+
+    if (currentName.value && currentEmail.value) {
+        console.log(chalk.gray(`   ${currentName.value} <${currentEmail.value}> — skipping.`));
+        return;
+    }
+
+    // Prefill from logged-in user if available
+    const u = await authStorage.getUser();
+    const defaultName = currentName.value ||
+        (u ? [u.first_name, u.last_name].filter(Boolean).join(' ') : '');
+    const defaultEmail = currentEmail.value || (u ? u.email : '');
+
+    const answers = await inquirer.prompt([
+        { type: 'input', name: 'name', message: 'Default name on commits:', default: defaultName },
+        { type: 'input', name: 'email', message: 'Default email on commits:', default: defaultEmail },
+    ]);
+
+    if (answers.name) await userConfig.set('user.name', answers.name);
+    if (answers.email) await userConfig.set('user.email', answers.email);
+}
+
+module.exports = setup;

package/src/commands/share.js

@@ -0,0 +1,63 @@
+/**
+ * Share Command - Print a shareable link to current branch/commit.
+ *
+ *   gent share                    → link to current HEAD on current branch
+ *   gent share --branch <name>    → link to a branch's tip
+ *   gent share --commit <hash>    → link to a specific commit
+ *
+ * Like `gent web --print` but always commit-scoped by default — handy for
+ * Slack/PR descriptions.
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const { getGentPath, readJSON } = require('../utils/fileSystem');
+const { CONFIG_FILE, COMMITS_FILE, parseRemoteUrl } = require('../utils/constants');
+const userConfig = require('../utils/user-config');
+
+async function share(options = {}) {
+    try {
+        const gentPath = await getGentPath();
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+
+        const remote = (config.remotes || {}).origin;
+        if (!remote) {
+            console.error(chalk.red('No origin remote configured.'));
+            console.log(chalk.yellow('Set one with `gent remote add origin <url>`.'));
+            process.exit(1);
+        }
+        const info = parseRemoteUrl(remote.url);
+        if (!info) {
+            console.error(chalk.red('Origin URL is not in a recognized gent format.'));
+            process.exit(1);
+        }
+
+        const { value: baseUrl } = await userConfig.getResolved('api.base_url');
+        const webHost = baseUrl.replace(/\/api\/?$/, '').replace(/\/$/, '');
+        const repoBase = `${webHost}/${info.owner_id}/${info.repo_name}`;
+
+        if (options.commit) {
+            console.log(`${repoBase}/commit/${options.commit}`);
+            return;
+        }
+        const branch = options.branch || repository.currentBranch;
+        const tip = repository.branches[branch];
+        if (tip) {
+            console.log(`${repoBase}/commit/${tip}`);
+            console.log(chalk.gray(`(${branch} @ ${tip.slice(0, 7)})`));
+        } else {
+            console.log(`${repoBase}/tree/${encodeURIComponent(branch)}`);
+            console.log(chalk.gray(`(${branch} has no commits yet)`));
+        }
+    } catch (error) {
+        if (error.code === 'ENOENT' && error.message.includes('.gent')) {
+            console.error(chalk.red('Error: Not a gent repository'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = share;