gent-cli 14.0.0 → 20.0.0

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);

package/src/index.js

@@ -30,33 +30,34 @@ const { program } = require('commander');
 const chalk = require('chalk');
 const packageJson = require('../package.json');
 const interactive = require('./utils/interactive');
+const { route } = require('./commands/canonical');
 
 // Import core commands
-const autoCommand = require('./commands/auto');
-const initCommand = require('./commands/init');
+const autoCommand = route('auto', require('./commands/auto'));
+const initCommand = route('init', require('./commands/init'));
 const cloneCommand = require('./commands/clone');
-const statusCommand = require('./commands/status');
-const addCommand = require('./commands/add');
-const rmCommand = require('./commands/rm');
-const resetCommand = require('./commands/reset');
-const diffCommand = require('./commands/diff');
-const commitCommand = require('./commands/commit');
-const logCommand = require('./commands/log');
-const showCommand = require('./commands/show');
-const tagCommand = require('./commands/tag');
-const branchCommand = require('./commands/branch');
-const checkoutCommand = require('./commands/checkout');
-const mergeCommand = require('./commands/merge');
-const stashCommand = require('./commands/stash');
-const remoteCommand = require('./commands/remote');
-const pushCommand = require('./commands/push');
-const pullCommand = require('./commands/pull');
+const statusCommand = route('status', require('./commands/status'));
+const addCommand = route('add', require('./commands/add'));
+const rmCommand = route('rm', require('./commands/rm'));
+const resetCommand = route('reset', require('./commands/reset'));
+const diffCommand = route('diff', require('./commands/diff'));
+const commitCommand = route('commit', require('./commands/commit'));
+const logCommand = route('log', require('./commands/log'));
+const showCommand = route('show', require('./commands/show'));
+const tagCommand = route('tag', require('./commands/tag'));
+const branchCommand = route('branch', require('./commands/branch'));
+const checkoutCommand = route('checkout', require('./commands/checkout'));
+const mergeCommand = route('merge', require('./commands/merge'));
+const stashCommand = route('stash', require('./commands/stash'));
+const remoteCommand = route('remote', require('./commands/remote'));
+const pushCommand = route('push', require('./commands/push'));
+const pullCommand = route('pull', require('./commands/pull'));
 const reposCommand = require('./commands/repos');
 const membersCommand = require('./commands/members');
-const undoCommand = require('./commands/undo');
-const resolveCommand = require('./commands/resolve');
-const summaryCommand = require('./commands/summary');
-const explainCommand = require('./commands/explain');
+const undoCommand = route('undo', require('./commands/undo'));
+const resolveCommand = route('resolve', require('./commands/resolve'));
+const summaryCommand = route('summary', require('./commands/summary'));
+const explainCommand = route('explain', require('./commands/explain'));
 
 // Import auth commands
 const registerCommand = require('./commands/register');
@@ -66,16 +67,16 @@ const whoamiCommand = require('./commands/whoami');
 const passwordCommand = require('./commands/password');
 
 // Import new gent-platform commands
-const configCommand = require('./commands/config');
+const configCommand = route('config', require('./commands/config'));
 const doctorCommand = require('./commands/doctor');
 const setupCommand = require('./commands/setup');
 const aiCommand = require('./commands/ai');
-const askCommand = require('./commands/ask');
-const reviewCommand = require('./commands/review');
-const docsCommand = require('./commands/docs');
-const changelogCommand = require('./commands/changelog');
+const askCommand = route('ask', require('./commands/ask'));
+const reviewCommand = route('review', require('./commands/review'));
+const docsCommand = route('docs', require('./commands/docs'));
+const changelogCommand = route('changelog', require('./commands/changelog'));
 const webCommand = require('./commands/web');
-const shareCommand = require('./commands/share');
+const shareCommand = route('share', require('./commands/share'));
 const searchCommand = require('./commands/search');
 const templateCommand = require('./commands/template');
 const petCommand = require('./commands/pet');
@@ -97,9 +98,21 @@ program
     .command('init')
     .description('Initialize a new gent repository')
     .option('-y, --yes', 'Skip prompts and use defaults')
+    .option('--object-format <format>', 'Opt into the canonical SHA-256 engine')
     .option('--remote [name]', 'Create a remote repository on the backend')
     .action(initCommand);
 
+program
+    .command('migrate')
+    .description('Migrate an offline legacy repository with a verified backup')
+    .option('--dry-run', 'Inspect and validate without changing repository state')
+    .option('--continue', 'Complete an interrupted migration')
+    .option('--abort', 'Roll back an interrupted migration if no newer state exists')
+    .action(async options => {
+        try { console.log(JSON.stringify(await require('./utils/migrate').migrate(process.cwd(), options), null, 2)); }
+        catch (error) { console.error(`Error: ${error.message}`); process.exitCode = 1; }
+    });
+
 program
     .command('clone [url] [directory]')
     .description('Clone a remote repository')
@@ -111,6 +124,11 @@ program
             console.error(chalk.red('error: missing url — usage: gent clone <url> [directory]'));
             process.exit(1);
         }
+        if (/^https?:/.test(url) && /\.git\/?$/.test(url)) {
+            try { console.log(`Cloned to ${await require('./utils/smart-http').clone(url, directory)}`); }
+            catch (error) { console.error(`Error: ${error.message}`); process.exitCode = 1; }
+            return;
+        }
         return cloneCommand(url, directory, options);
     });
 
@@ -152,8 +170,8 @@ program
 program
     .command('reset [files...]')
     .description('Unstage files or reset HEAD to a commit')
-    .option('--hard <hash>', 'Reset HEAD and working tree to commit')
-    .option('--soft <hash>', 'Reset HEAD but keep staging')
+    .option('--hard [hash]', 'Reset HEAD and working tree to commit')
+    .option('--soft [hash]', 'Reset HEAD but keep staging')
     .action(resetCommand);
 
 program
@@ -221,13 +239,15 @@ program
     .command('checkout [branch]')
     .description('Switch branches or restore working tree files')
     .option('-b, --create', 'Create a new branch')
+    .option('--abort', 'Recover an interrupted canonical checkout')
+    .option('-f, --force', 'Discard local changes when switching')
     .action(async (branch, options) => {
-        if (!branch && interactive.isInteractive()) {
+        if (!branch && !options.abort && interactive.isInteractive()) {
             const picked = await interactive.promptCheckout();
             branch = picked.branch;
             options.create = picked.create; // picker decides: existing branch ⇒ switch, not create
         }
-        if (!branch) {
+        if (!branch && !options.abort) {
             console.error(chalk.red('error: missing branch — usage: gent checkout <branch>'));
             process.exit(1);
         }
@@ -238,8 +258,10 @@ program
     .command('merge [branch]')
     .description('Merge a branch into the current branch (3-way smart merge)')
     .option('-m, --message <message>', 'Merge commit message')
+    .option('--continue', 'Finish a resolved canonical merge')
+    .option('--abort', 'Abort a canonical merge')
     .action(async (branch, options) => {
-        if (!branch && interactive.isInteractive()) {
+        if (!branch && !options.continue && !options.abort && interactive.isInteractive()) {
             const picked = await interactive.promptMerge();
             if (!picked.branch) {
                 // In a repo with only one branch → nothing to merge; otherwise
@@ -252,7 +274,7 @@ program
                 branch = picked.branch;
             }
         }
-        if (!branch && !interactive.isInteractive()) {
+        if (!branch && !options.continue && !options.abort && !interactive.isInteractive()) {
             console.error(chalk.red('error: missing branch — usage: gent merge <branch>'));
             process.exit(1);
         }
@@ -268,6 +290,9 @@ program
     .command('stash [subcommand]')
     .description('Stash working tree changes (pop|list|drop|apply)')
     .option('-m, --message <message>', 'Stash message')
+    .option('--restore-index', 'Restore canonical stash staged state')
+    .option('--keep-index', 'Keep staged changes when stashing')
+    .option('-u, --include-untracked', 'Include untracked files')
     .option('-i, --index <index>', 'Stash index for pop/apply/drop')
     .action(stashCommand);
 
@@ -311,6 +336,11 @@ program
     .option('-f, --force', 'Force push (overwrite remote)')
     .action(pushCommand);
 
+program
+    .command('fetch [remote]')
+    .description('Fetch canonical remote branches and tags')
+    .action(route('fetch', async () => { throw new Error('fetch requires a canonical repository'); }));
+
 program
     .command('pull [remote] [branch]')
     .description('Pull and merge remote commits')
@@ -373,17 +403,17 @@ program
 
 program
     .command('web')
-    .description('Open the current repo (or a branch/commit) on the gent web app')
-    .option('--branch <name>', 'Open a specific branch')
-    .option('--commit <hash>', 'Open a specific commit')
+    .description('Open the current repo on the gent web app')
+    .option('--branch <name>', 'Branch context (opens the repo page — no branch page yet)')
+    .option('--commit <hash>', 'Commit context (opens the repo page — no commit page yet)')
     .option('--print', 'Print the URL instead of launching a browser')
     .action(webCommand);
 
 program
     .command('share')
-    .description('Print a shareable link to current branch tip (or --branch/--commit)')
-    .option('--branch <name>', 'Link to a specific branch')
-    .option('--commit <hash>', 'Link to a specific commit')
+    .description('Print a shareable link to the current repository')
+    .option('--branch <name>', 'Branch context (link resolves to the repo page)')
+    .option('--commit <hash>', 'Commit context (link resolves to the repo page)')
     .action(shareCommand);
 
 program

package/src/utils/api-client.js

@@ -80,8 +80,13 @@ apiClient.interceptors.response.use(
     async (error) => {
         const originalRequest = error.config;
 
-        // If error is 401 and we haven't tried to refresh yet
+        // A public request made without credentials should keep its original
+        // 401 response. Commands such as `gent clone` use that response to
+        // explain that a private repository needs sign-in.
         if (error.response?.status === 401 && !originalRequest._retry) {
+            const refreshToken = await authStorage.getRefreshToken();
+            if (!refreshToken) return Promise.reject(error);
+
             if (isRefreshing) {
                 // If already refreshing, queue this request
                 return new Promise((resolve, reject) => {
@@ -100,14 +105,6 @@ apiClient.interceptors.response.use(
             isRefreshing = true;
 
             try {
-                const refreshToken = await authStorage.getRefreshToken();
-
-                if (!refreshToken) {
-                    // No refresh token, user needs to login again
-                    await authStorage.clearAuth();
-                    throw new Error('Session expired. Please login again.');
-                }
-
                 // Call refresh endpoint (raw axios — bypasses our interceptor
                 // intentionally so a 401 here doesn't loop back into refresh).
                 const baseUrl = await resolveBaseUrl();