gent-cli 15.0.0 → 21.0.0

package/README.md

@@ -25,7 +25,7 @@ Beyond a faithful git-like workflow, Gent adds:
 - **`gent resolve`** — an interactive conflict resolver (ours / theirs / both / edit / AI).
 - **`gent summary`** — a repository health dashboard, plus **`gent log --graph`**.
 - **Optional AI** (`gent commit --ai`, `gent explain`, `gent summary --ai`, AI option in `gent resolve`) — off by default, enabled with `ANTHROPIC_API_KEY`.
-- **Genti, your terminal mascot** — a chunky pixel bot that *acts out* your workflow: it carries a file crate to the cloud on `gent push`, walks one home on `gent pull`, and reconciles two branches on `gent merge`. It plays once (in place, no scrollback spam) after a successful command. Meet it directly with `gent pet` (add `--loop` to keep it running; try `gent pet push|pull|merge|auth`). Set `GENT_NO_PET=1` (or run in CI / a non-interactive shell) to turn the celebrations off.
+- **Genti, your terminal mascot** — a mint one-eyed sky-jelly that *acts out* your workflow: it floats a file crate to the cloud on `gent push`, carries one home on `gent pull`, and reconciles two branches on `gent merge`. It plays once (in place, no scrollback spam) after a successful command. Meet it directly with `gent pet` (add `--loop` to keep it running; try `gent pet push|pull|merge|auth`). Set `GENT_NO_PET=1` (or run in CI / a non-interactive shell) to turn the celebrations off.
 
 See [docs/COMMANDS.md](docs/COMMANDS.md) for the full reference and
 [docs/ALGORITHMS.md](docs/ALGORITHMS.md) for how the engines work.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "15.0.0",
+  "version": "21.0.0",
   "description": "A modern, Git-like version control CLI with cloud sync, AI-powered superpowers (ask/review/docs/changelog), and zero-friction setup (gent setup/doctor/config).",
   "main": "src/index.js",
   "bin": {
@@ -8,14 +8,17 @@
   },
   "scripts": {
     "start": "node src/index.js",
-    "test": "node --check src/index.js && node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js && node tests/offline-e2e.js",
-    "test:unit": "node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js",
+    "test": "node --check src/index.js && node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js tests/web-urls.test.js && node tests/offline-e2e.js && node --test tests/git-compat/engine.test.js tests/git-compat/cli.test.js tests/git-compat/transport.test.js tests/git-compat/migrate.test.js",
+    "test:unit": "node --test tests/diff.test.js tests/merge.test.js tests/hash.test.js tests/merge-base.test.js tests/file-system.test.js tests/web-urls.test.js",
     "test:e2e": "node tests/offline-e2e.js",
     "test:remote:e2e": "node tests/remote-e2e.js",
     "demo": "bash demo.sh",
     "link": "npm link",
     "unlink": "npm unlink",
-    "prepublishOnly": "echo 'Ready to publish gent-cli!'"
+    "prepublishOnly": "echo 'Ready to publish gent-cli!'",
+    "test:canonical": "node --test tests/git-compat/engine.test.js tests/git-compat/cli.test.js tests/git-compat/transport.test.js tests/git-compat/migrate.test.js",
+    "test:independence": "node tests/git-compat/independence.js",
+    "test:interop": "node --test tests/interop/canonical.test.js"
   },
   "keywords": [
     "cli",

package/src/commands/canonical.js

@@ -0,0 +1,246 @@
+/** Canonical command adapters. Legacy repositories retain their v12 handlers
+ * until migration ships; no canonical command falls back to a legacy writer.
+ */
+const fs = require('fs').promises;
+const path = require('path');
+const repository = require('../utils/repository');
+const ops = require('../utils/gent-ops');
+const merge = require('../utils/merge-ops');
+const stash = require('../utils/stash-ops');
+const journal = require('../utils/canonical-journal');
+const worktree = require('../utils/worktree');
+const { GitIndex } = require('../utils/git-index');
+const { Lock } = require('../utils/lockfile');
+const { AttributesMatcher, looksBinary } = require('../utils/attributes');
+const { formatUnifiedDiff } = require('../utils/diff-engine');
+
+async function locatedCanonical() {
+    let found;
+    try { found = await repository.findGitdir(); } catch (error) {
+        if (error.code === 'GENT_NOT_A_REPOSITORY') return null;
+        throw error;
+    }
+    if (await repository.isLegacyRepository(found.commondir)) return null;
+    return repository.open();
+}
+
+function route(name, legacy) {
+    const handler = async (...args) => {
+        try {
+            for (let dir = process.cwd(); ; dir = path.dirname(dir)) {
+                if (await fs.access(path.join(dir, '.gent-migration.json')).then(() => true, () => false)) throw new Error('interrupted migration; use gent migrate --continue or --abort');
+                if (path.dirname(dir) === dir) break;
+            }
+            if (name === 'init') {
+                const options = args[0] || {};
+                if (!options.objectFormat) {
+                    const existing = await locatedCanonical();
+                    if (!existing) return legacy(...args);
+                    console.log(`Repository already initialized: ${existing.gitdir}`);
+                    return;
+                }
+                if (options.objectFormat !== 'sha256') throw new Error('only --object-format=sha256 is supported');
+                if (options.remote) throw new Error('canonical remote creation is not implemented yet');
+                const result = await repository.init(process.cwd());
+                console.log(`Initialized SHA-256 repository: ${result.gitdir}`);
+                return;
+            }
+            // CLI-global settings remain available inside canonical repositories.
+            if (name === 'config' && args[1]?.[0] && !/^(user\.|core\.|remote\.|branch\.)/i.test(args[1][0])) {
+                return legacy(...args);
+            }
+            const repo = await locatedCanonical();
+            if (!repo) return legacy(...args);
+            if (!handlers[name]) throw new Error(`gent ${name} is not implemented for canonical repositories yet`);
+            const readOnly = ['status', 'log', 'show', 'diff', 'summary'].includes(name);
+            let lock;
+            try {
+                if (!readOnly) {
+                    lock = await Lock.acquire(path.join(repo.gentWorktreeMetaDir, 'operation'));
+                    await repo.assertNoExternalOperation(`gent ${name}`);
+                    if (!(name === 'checkout' && args[1]?.abort)) await worktree.assertNoPendingCheckout(repo, `gent ${name}`);
+                }
+                const checkpointed = ['commit', 'checkout', 'reset', 'merge'].includes(name) && !args[1]?.abort && !args[0]?.abort;
+                const checkpoint = checkpointed ? await journal.begin(repo, name) : null;
+                const result = await handlers[name](repo, ...args);
+                if (checkpoint) await journal.finish(repo, checkpoint);
+                return result;
+            } finally { if (lock) await lock.release(); }
+        } catch (error) {
+            console.error(`Error: ${error.message}`);
+            process.exitCode = 1;
+        }
+    };
+    if (legacy.redo) handler.redo = route('redo', legacy.redo);
+    return handler;
+}
+
+const transport = require('../utils/smart-http');
+const handlers = {
+    async remote(repo, sub, args = []) {
+        const [name = 'origin', url] = args;
+        transport.nameCheck(name);
+        if (sub === 'add' || sub === 'set-url') {
+            if (!url) throw new Error('provide a remote URL');
+            if (sub === 'add' && repo.config.get(`remote.${name}.url`)) throw new Error('remote already exists');
+            repo.localConfig.set(`remote.${name}.url`, transport.remoteUrl(url));
+            repo.localConfig.set(`remote.${name}.fetch`, `+refs/heads/*:refs/remotes/${name}/*`);
+            await repo.localConfig.save();
+        } else if (sub === 'remove') {
+            repo.localConfig.unset(`remote.${name}.url`);
+            repo.localConfig.unset(`remote.${name}.fetch`);
+            await repo.localConfig.save();
+        } else if (!sub) console.log(transport.configured(repo, name));
+        else throw new Error('use remote add|set-url|remove');
+    },
+    async fetch(repo, remote = 'origin') { await transport.fetch(repo, remote); console.log(`Fetched ${remote}`); },
+    async push(repo, remote = 'origin', branch, options = {}) {
+        await transport.push(repo, remote, branch, options); console.log('Push complete');
+    },
+    async pull(repo, remote = 'origin', branch) {
+        branch ||= (await repo.refs.head()).branch;
+        if (!branch) throw new Error('specify a branch from detached HEAD');
+        await transport.fetch(repo, remote);
+        const result = await merge.merge(repo, `refs/remotes/${remote}/${branch}`);
+        console.log(result.status);
+        if (result.status === 'conflicts') process.exitCode = 1;
+    },
+    async undo(repo, options = {}) {
+        if (options.list) { for (const item of (await journal.read(repo)).undo.slice().reverse()) console.log(item.name); }
+        else console.log(`Undid ${await journal.restore(repo)}`);
+    },
+    async redo(repo) { console.log(`Redid ${await journal.restore(repo, true)}`); },
+    async status(repo) {
+        const state = await ops.status(repo);
+        console.log(`On ${state.head.branch || 'detached HEAD'}`);
+        for (const item of state.staged) console.log(`staged ${item.status}: ${item.path}`);
+        for (const item of state.unstaged) console.log(`unstaged ${item.status}: ${item.path}`);
+        for (const name of state.conflicted) console.log(`conflict: ${name}`);
+        for (const name of state.untracked) console.log(`untracked: ${name}`);
+        if (!state.staged.length && !state.unstaged.length && !state.conflicted.length && !state.untracked.length) console.log('Working tree clean');
+    },
+    async add(repo, files, options) {
+        const result = await ops.addPaths(repo, files, options);
+        console.log(`Staged ${result.staged.length} change(s), ${result.removed.length} deletion(s)`);
+    },
+    async rm(repo, files, options) { await ops.removePaths(repo, files, options); },
+    async commit(repo, options) {
+        if (options.ai) throw new Error('AI commit messages are not connected to canonical repositories yet');
+        if (!options.message) throw new Error('provide a commit message with -m');
+        if (options.all) {
+            const index = await GitIndex.read(repo.indexPath);
+            const files = [...new Set(index.entries.map(e => path.join(repo.worktree, e.path)))];
+            if (files.length) await ops.addPaths(repo, files);
+        }
+        const result = await ops.createCommit(repo, options);
+        console.log(`[${result.branch || 'detached'} ${result.oid.slice(0, 12)}] ${options.message}`);
+    },
+    async branch(repo, name, options) {
+        if (options.delete) await ops.deleteBranch(repo, options.delete);
+        else if (name) await ops.createBranch(repo, name);
+        else for (const branch of await ops.listBranches(repo)) console.log(`${branch.current ? '*' : ' '} ${branch.name} ${branch.oid.slice(0, 12)}`);
+    },
+    async checkout(repo, target, options) {
+        if (options.abort) { await worktree.abortCheckout(repo); console.log('Checkout restored'); return; }
+        const result = await ops.checkout(repo, target, options);
+        console.log(`Switched to ${result.branch || result.oid}`);
+    },
+    async reset(repo, files, options) {
+        if (options.hard) await ops.reset(repo, 'hard', options.hard === true ? 'HEAD' : options.hard);
+        else if (options.soft) await ops.reset(repo, 'soft', options.soft === true ? 'HEAD' : options.soft);
+        else if (files.length) await ops.unstagePaths(repo, files);
+        else await ops.reset(repo, 'mixed', 'HEAD');
+    },
+    async merge(repo, branch, options) {
+        if (options.abort) return merge.abortMerge(repo);
+        if (options.continue) return merge.concludeMerge(repo, options.message);
+        const result = await merge.merge(repo, branch, options);
+        if (result.status === 'conflicts') {
+            for (const conflict of result.conflicts) {
+                if (conflict.kind === 'content') console.log(`Auto-merging ${conflict.path}`);
+                console.log(`CONFLICT (${conflict.kind}): Merge conflict in ${conflict.path}`);
+            }
+            console.log('Automatic merge failed; fix conflicts and then commit the result.');
+            console.log('Resolve files, stage with gent add, then gent merge --continue or gent commit -m <message>.');
+            process.exitCode = 1;
+        } else console.log(result.status);
+    },
+    async resolve(repo) {
+        const index = await GitIndex.read(repo.indexPath);
+        for (const name of index.conflicts().keys()) console.log(name);
+        console.log('Edit conflicted files, then gent add <path> and gent merge --continue.');
+    },
+    async stash(repo, sub = 'push', options = {}) {
+        const position = Number(options.index || 0);
+        if (!Number.isInteger(position) || position < 0) throw new Error('stash index must be a nonnegative integer');
+        if (sub === 'list') { for (const item of await stash.list(repo)) console.log(`stash@{${item.index}}: ${item.message}`); }
+        else if (sub === 'push' || sub === 'save') console.log((await stash.push(repo, options)).message);
+        else if (['apply', 'pop', 'drop'].includes(sub)) await stash[sub](repo, position, options);
+        else throw new Error(`unknown stash operation '${sub}'`);
+    },
+    async tag(repo, name, options) {
+        if (options.delete) await ops.deleteTag(repo, options.delete);
+        else if (name) await ops.createTag(repo, name, options);
+        else for (const item of await ops.listTags(repo)) console.log(item.name);
+    },
+    async log(repo, options) {
+        if (options.graph || options.stat) throw new Error('canonical log --graph/--stat formatting is not implemented yet; use log --oneline');
+        for (const commit of await ops.walkHistory(repo, { max: Number(options.number) })) {
+            console.log(`${commit.oid.slice(0, 12)} ${commit.message.toString().split('\n')[0]}`);
+        }
+    },
+    async show(repo, ref = 'HEAD', options = {}) {
+        const oid = await ops.peelToCommit(repo, ref);
+        const commit = await repo.objects.readCommit(oid);
+        console.log(`commit ${oid}\nParents: ${commit.parents.join(' ')}\n${commit.message.toString()}`);
+        if (options.patch !== false) {
+            const before = commit.parents.length ? await worktree.readTreeRecursive(repo, (await repo.objects.readCommit(commit.parents[0])).tree) : new Map();
+            await printTreeDiff(repo, before, await worktree.readTreeRecursive(repo, commit.tree));
+        }
+    },
+    async diff(repo, files, options) {
+        const index = await GitIndex.read(repo.indexPath);
+        if (index.hasConflicts()) throw new Error('resolve conflicts before requesting a canonical diff');
+        const staged = new Map(index.staged().map(e => [e.path, e]));
+        const head = await repo.refs.head();
+        const before = options.staged ? await worktree.readTreeRecursive(repo, head.oid ? (await repo.objects.readCommit(head.oid)).tree : null) : staged;
+        const after = options.staged ? staged : new Map();
+        if (!options.staged) {
+            const attrs = new AttributesMatcher(repo);
+            for (const [name, entry] of staged) {
+                const snapshot = await worktree.snapshotPath(repo, name);
+                if (snapshot) after.set(name, { ...entry, mode: snapshot.mode, bytes: snapshot.mode === 0o120000 ? Buffer.from(snapshot.content, 'base64') : await attrs.toIndex(name, Buffer.from(snapshot.content, 'base64')) });
+            }
+        }
+        await printTreeDiff(repo, before, after, files, options.stat);
+    },
+    async summary(repo, options = {}) {
+        if (options.ai) throw new Error('AI summary is not connected to canonical repositories yet');
+        console.log(`${(await ops.walkHistory(repo)).length} commits, ${(await ops.listBranches(repo)).length} branches`);
+        await handlers.status(repo);
+    },
+    async config(repo, sub = 'list', args = []) {
+        const [key, value] = args;
+        if (sub === 'get') console.log(repo.config.get(key, ''));
+        else if (sub === 'set') {
+            if (!key || value === undefined) throw new Error('usage: gent config set <key> <value>');
+            if (!/^user\.(name|email)$/i.test(key)) throw new Error('canonical config writes currently support user.name and user.email only');
+            repo.localConfig.set(key, value); await repo.localConfig.save();
+        } else throw new Error('use gent config get <key> or gent config set user.name/user.email <value>');
+    }
+};
+
+async function printTreeDiff(repo, before, after, files = [], stat = false) {
+    const wanted = files.map(name => repo.relativePath(path.resolve(name)));
+    for (const name of new Set([...before.keys(), ...after.keys()])) {
+        if (wanted.length && !wanted.some(p => name === p || name.startsWith(p + '/'))) continue;
+        const a = before.get(name), b = after.get(name);
+        const read = item => item ? (item.bytes || repo.objects.readBlob(item.oid)) : Buffer.alloc(0);
+        const oldBytes = await read(a), newBytes = await read(b);
+        if (oldBytes.equals(newBytes) && a?.mode === b?.mode) continue;
+        if (stat || looksBinary(oldBytes) || looksBinary(newBytes)) console.log(`${name}: ${oldBytes.length} -> ${newBytes.length} bytes`);
+        else console.log(formatUnifiedDiff(name, oldBytes.toString(), newBytes.toString()));
+    }
+}
+
+module.exports = { route };

package/src/commands/clone.js

@@ -28,7 +28,6 @@ const ora = require('ora');
 const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
 const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
 const apiClient = require('../utils/api-client');
-const authStorage = require('../utils/auth-storage');
 const { storeBlob, readBlob } = require('../utils/hash-engine');
 
 /**
@@ -46,14 +45,6 @@ async function clone(url, directory, options) {
     const spinner = ora(`Cloning from ${url}...`).start();
 
     try {
-        // Check auth
-        const isAuth = await authStorage.isAuthenticated();
-        if (!isAuth) {
-            spinner.fail(chalk.red('Not authenticated'));
-            console.log(chalk.yellow('Run "gent login" first'));
-            return;
-        }
-
         // Parse URL
         const repoInfo = parseRemoteUrl(url);
         if (!repoInfo) {
@@ -183,10 +174,8 @@ async function clone(url, directory, options) {
         spinner.fail(chalk.red('Clone failed'));
         if (error.response?.status === 404) {
             console.error(chalk.red('Repository not found'));
-        } else if (error.response?.status === 401) {
-            console.error(chalk.red('Authentication failed — run "gent login"'));
-        } else if (error.response?.status === 403) {
-            console.error(chalk.red('Access denied — you do not have permission to clone this repository'));
+        } else if (error.response?.status === 401 || error.response?.status === 403) {
+            console.error(chalk.red('This repository is private or you do not have access to it. Run "gent login" to clone private repositories you can access.'));
         } else if (error.response?.data) {
             console.error(chalk.red(JSON.stringify(error.response.data)));
         } else {

package/src/commands/pet.js

@@ -1,11 +1,11 @@
 /**
  * Pet Command — "Genti", the gent mascot.
  *
- * A chunky pixel-block creature that lives in your terminal and *acts out*
+ * A mint one-eyed sky-jelly that lives in your terminal and *acts out*
  * gent workflows:
  *
  *   gent pet            → idle: Genti breathes, blinks, waves, drops a tip
- *   gent pet push       → walks a file crate to the cloud, over and over
+ *   gent pet push       → floats a file crate to the cloud, over and over
  *   gent pet pull       → carries a crate back from the cloud
  *   gent pet merge      → stands between two branches and "thinks" them together
  *   gent pet auth       → little sign-in scene
@@ -25,10 +25,10 @@ const FRAME_MS = 90;
 
 // ── Palette ──────────────────────────────────────────────────────────────
 const C = {
-    body:   chalk.hex('#c97b5a'),   // Genti's orange skin
-    shade:  chalk.hex('#9c5a3f'),   // bottom shading
-    eye:    chalk.hex('#15110f'),   // dark eye holes
-    mouth:  chalk.hex('#5a2f22'),
+    body:   chalk.hex('#55e6c1'),   // Genti's mint glow
+    shade:  chalk.hex('#168f86'),   // lower-body depth
+    eye:    chalk.hex('#7c3aed'),   // single violet eye
+    mouth:  chalk.hex('#34205f'),
     crate:  chalk.hex('#e0b64d'),   // file crate edges
     crateIn:chalk.hex('#b98a1f'),   // crate fill
     cloud:  chalk.hex('#d6def0'),   // remote / cloud
@@ -115,49 +115,27 @@ class Canvas {
 }
 
 // ── Mascot sprite ────────────────────────────────────────────────────────
-// Body is a 12-wide block with a 1-col margin (transparent) each side.
+// Wide fins, one eye, and ribbon tentacles give Genti a sky-jelly silhouette.
 function mascot({ blink = false, mouth = '_', armUp = false } = {}) {
-    const W = 12;
-    const rows = [];
-    rows[0] = ' ' + '#'.repeat(W) + ' ';
-    rows[1] = ' ' + '#'.repeat(W) + ' ';
-    rows[2] = ' ' + '#'.repeat(W) + ' ';   // eyes row
-    rows[3] = ' ' + '#'.repeat(W) + ' ';
-    rows[4] = ' ' + '#'.repeat(W) + ' ';   // mouth row
-    rows[5] = ' ' + '@'.repeat(W) + ' ';   // shaded chin
-
-    const grid = rows.map(r => r.split(''));
-    const eye = blink ? '#' : 'O';
-    // eyes at body cols 3-4 and 8-9 → +1 for margin
-    [3, 4].forEach(c => grid[2][c + 1] = eye);
-    [8, 9].forEach(c => grid[2][c + 1] = eye);
-    // mouth at cols 5-8 (row4)
-    for (let c = 5; c <= 8; c++) grid[4][c + 1] = mouth;
-    // ears (stick out at row2)
-    grid[2][0] = '#';
-    grid[2][W + 1] = '#';
-
-    let body = grid.map(r => r.join(''));
-
-    // arm (raised wave) sits to the right of the head on row1
-    if (armUp) {
-        const r1 = body[1].split('');
-        r1[W + 1] = '#';
-        body[1] = r1.join('');
-        body.unshift('             #'); // tiny raised hand
-    } else {
-        body.unshift('              ');
-    }
-    return body; // 7 rows (incl. leading arm/space row), 14 wide
+    const eye = blink ? '##' : 'OO';
+    const smile = mouth.repeat(4);
+    return [
+        armUp ? '#    ####     ' : '     ####     ',
+        armUp ? ' ## ########  ' : '  ##########  ',
+        ' ############ ',
+        '##############',
+        `  ####${eye}####  `,
+        `   ##${smile}##   `,
+        '    @@@@@@    ',
+    ];
 }
 
-// Legs are separate so they can shuffle while the body glides.
+// Ribbon tentacles trail independently so the sky-jelly appears to float.
 function legs(step) {
-    // step: 'stand' | 'a' | 'b'
     const map = {
-        stand: '   ##      ##  ',
-        a:     '   ##       #  ',
-        b:     '   #       ##  ',
+        stand: '    @ @ @     ',
+        a:     '     @ @ @    ',
+        b:     '   @ @ @      ',
     };
     return [map[step] || map.stand];
 }
@@ -419,7 +397,7 @@ function runLoop(sceneName, {
 
     const footerLine = () => footer
         ? chalk.gray('  ') +
-          (loop ? chalk.gray('Ctrl+C to cancel') : C.body('Genti')) +
+          (loop ? chalk.gray('Ctrl+C to cancel') : C.body('Genti the sky-jelly')) +
           chalk.gray('   ·   more scenes: ') + C.say('gent pet push|pull|merge')
         : '';
 

package/src/commands/push.js

@@ -235,7 +235,7 @@ async function push(remoteName, branchName, options) {
         // Send to backend — Genti carries the crate to the cloud while we wait.
         const pushUrl = buildRepoUrl(API_ENDPOINTS.REPO_PUSH, repoInfo);
         spinner.stop();
-        const response = await pet.during('push', () => apiClient.post(pushUrl, payload));
+        const response = await pet.during('push', () => apiClient.post(pushUrl, payload, { timeout: 120000 }));
 
         // Update remote ref
         config.remoteRefs[`${remote}/${branch}`] = localHead;

package/src/commands/share.js

@@ -1,19 +1,24 @@
 /**
  * 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
+ *   gent share                    → link to the repository
+ *   gent share --branch <name>    → same link, branch reported as context
+ *   gent share --commit <hash>    → same link, commit validated and reported
  *
- * Like `gent web --print` but always commit-scoped by default — handy for
- * Slack/PR descriptions.
+ * Like `gent web --print` — handy for Slack/PR descriptions. stdout carries
+ * only the URL so `gent share | pbcopy` gives a clean link; all context goes
+ * to stderr.
+ *
+ * NOTE: the web app has no branch or commit page today, so every link resolves
+ * to the repository page; the branch/commit is reported as context only.
+ * See utils/web-urls.js.
  */
 
 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');
+const { getWebBaseUrl, buildRepoLink, BRANCH_COMMIT_UNSUPPORTED } = require('../utils/web-urls');
 
 async function share(options = {}) {
     try {
@@ -33,22 +38,42 @@ async function share(options = {}) {
             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}`;
+        const baseUrl = await getWebBaseUrl();
+        const { url, unsupported } = buildRepoLink(baseUrl, info, {
+            branch: options.branch,
+            commit: options.commit,
+        });
+
+        // A --commit the repo doesn't know about is a typo, not a link: refuse
+        // rather than echo a fabricated reference into a PR description.
+        if (options.commit) {
+            const known = (repository.commits || [])
+                .some((c) => c && typeof c.hash === 'string' && c.hash.startsWith(options.commit));
+            if (!known) {
+                console.error(chalk.red(`Unknown commit '${options.commit}' in this repository.`));
+                process.exit(1);
+            }
+        }
+
+        // Only warn when the user actually asked for a link we can't build.
+        if (unsupported) {
+            console.error(chalk.gray(BRANCH_COMMIT_UNSUPPORTED));
+        }
+
+        // stdout carries the URL and nothing else, so `gent share | pbcopy`
+        // yields a clean link. All human context goes to stderr.
+        console.log(url);
 
         if (options.commit) {
-            console.log(`${repoBase}/commit/${options.commit}`);
+            console.error(chalk.gray(`(commit ${String(options.commit).slice(0, 7)})`));
             return;
         }
         const branch = options.branch || repository.currentBranch;
-        const tip = repository.branches[branch];
+        const tip = (repository.branches || {})[branch];
         if (tip) {
-            console.log(`${repoBase}/commit/${tip}`);
-            console.log(chalk.gray(`(${branch} @ ${tip.slice(0, 7)})`));
+            console.error(chalk.gray(`(${branch} @ ${tip.slice(0, 7)})`));
         } else {
-            console.log(`${repoBase}/tree/${encodeURIComponent(branch)}`);
-            console.log(chalk.gray(`(${branch} has no commits yet)`));
+            console.error(chalk.gray(`(${branch} has no commits yet)`));
         }
     } catch (error) {
         if (error.code === 'ENOENT' && error.message.includes('.gent')) {

package/src/commands/web.js

@@ -2,19 +2,23 @@
  * Web Command - Open the current repo (or a specific commit/branch) in browser.
  *
  *   gent web                       → open repo page
- *   gent web --branch <name>       → open a specific branch
- *   gent web --commit <hash>       → open a specific commit
+ *   gent web --branch <name>       → repo page (branch context only — see NOTE)
+ *   gent web --commit <hash>       → repo page (commit context only — see NOTE)
  *   gent web --print               → don't launch, just print the URL
  *
- * Builds the URL from the configured api.base_url and the remote's owner_id/repo_name.
+ * Builds the URL from the configured web.base_url (NOT api.base_url — the web
+ * app is a separate deployment) and the remote's owner_id/repo_name.
+ *
+ * NOTE: the web app has no branch or commit page today, so --branch/--commit
+ * warn and fall back to the repository page. See utils/web-urls.js.
  */
 
 const path = require('path');
-const { exec } = require('child_process');
+const { execFile } = require('child_process');
 const chalk = require('chalk');
 const { getGentPath, readJSON } = require('../utils/fileSystem');
 const { CONFIG_FILE, parseRemoteUrl } = require('../utils/constants');
-const userConfig = require('../utils/user-config');
+const { getWebBaseUrl, buildRepoLink, BRANCH_COMMIT_UNSUPPORTED } = require('../utils/web-urls');
 
 async function web(options = {}) {
     try {
@@ -32,13 +36,16 @@ async function web(options = {}) {
             process.exit(1);
         }
 
-        const { value: baseUrl } = await userConfig.getResolved('api.base_url');
-        // Strip /api suffix if present so we get the web host
-        const webHost = baseUrl.replace(/\/api\/?$/, '').replace(/\/$/, '');
+        const baseUrl = await getWebBaseUrl();
+        const { url, unsupported } = buildRepoLink(baseUrl, info, {
+            branch: options.branch,
+            commit: options.commit,
+        });
 
-        let url = `${webHost}/${info.owner_id}/${info.repo_name}`;
-        if (options.branch) url += `/tree/${encodeURIComponent(options.branch)}`;
-        if (options.commit) url += `/commit/${encodeURIComponent(options.commit)}`;
+        if (unsupported) {
+            console.error(chalk.yellow(`Note: --${unsupported} is not supported yet.`));
+            console.error(chalk.gray(BRANCH_COMMIT_UNSUPPORTED));
+        }
 
         if (options.print) {
             console.log(url);
@@ -57,11 +64,19 @@ async function web(options = {}) {
     }
 }
 
+/**
+ * Hand the URL to the platform's browser launcher.
+ *
+ * Uses execFile, NOT exec: the URL is passed as its own argv entry so no shell
+ * ever parses it. Interpolating it into a shell string made a `"` in
+ * web.base_url a command-injection sink, and broke any legitimate URL
+ * containing & or $.
+ */
 function openInBrowser(url) {
-    const cmd = process.platform === 'darwin' ? 'open'
-        : process.platform === 'win32' ? 'start ""'
-        : 'xdg-open';
-    exec(`${cmd} "${url}"`, (err) => {
+    const [cmd, args] = process.platform === 'darwin' ? ['open', [url]]
+        : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+        : ['xdg-open', [url]];
+    execFile(cmd, args, (err) => {
         if (err) {
             console.error(chalk.yellow('Could not auto-open. URL:'));
             console.log(url);