gent-cli 7.0.0 → 9.0.0

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;

package/src/commands/show.js

@@ -16,8 +16,9 @@
  *   Retrieves commit from commits.json, reads blob content from object store,
  *   computes diff against parent commit's tree, and displays unified diff.
  *
- * BACKEND EXPECTATIONS:
- *   GET /api/repos/:id/commits/:hash/ — returns commit object with tree
+ * BACKEND: none — fully local. Reads commits.json + the local object store.
+ *   (Remote commit_detail returns { sha, tree_sha, parent_shas[], author_name,
+ *    author_email, committed_at, message } — tree_sha is a bare string, no embedded tree.)
  *
  * ============================================================================
  */

package/src/commands/tag.js

@@ -18,9 +18,9 @@
  *   Annotated tag = includes tagger info, message, timestamp.
  *
  * BACKEND EXPECTATIONS:
- *   POST /api/repos/:id/tags/ { name, hash, message, annotated }
- *   GET  /api/repos/:id/tags/
- *   DELETE /api/repos/:id/tags/:name/
+ *   POST   /api/repos/:owner_id/:repo_name/tags/create/ { name, commit_sha, message, annotated, tagger_name, tagger_email }
+ *   DELETE /api/repos/:owner_id/:repo_name/tags/:name/
+ *   (tag list is local-only — the CLI never GETs /tags/)
  *
  * ============================================================================
  */
@@ -181,8 +181,15 @@ async function syncTagCreate(name, tagObj, taggerName, taggerEmail, gentPath) {
         await apiClient.post(url, payload);
         console.log(chalk.gray(`  ↑ Synced to remote`));
     } catch (error) {
+        // Duplicates now upsert (200) on the backend, so a 400 is a real failure
+        // — most often the tagged commit hasn't been pushed yet.
         if (error.response?.status === 400) {
-            console.log(chalk.gray(`  ⚠ Remote sync skipped (tag may already exist remotely)`));
+            const data = error.response.data;
+            const msg = (data && data.error) || (typeof data === 'object' ? JSON.stringify(data) : data) || 'Bad request';
+            console.log(chalk.yellow(`  ⚠ Remote sync failed: ${msg}`));
+            console.log(chalk.gray(`    (has the tagged commit been pushed to the remote?)`));
+        } else if (error.response?.status === 403) {
+            console.log(chalk.yellow(`  ⚠ Remote sync failed: ${error.response.data?.error || 'no write access to repository'}`));
         }
     }
 }
@@ -208,6 +215,8 @@ async function syncTagDelete(name, gentPath) {
     } catch (error) {
         if (error.response?.status === 404) {
             // Tag didn't exist remotely
+        } else if (error.response?.status === 403) {
+            console.log(chalk.yellow(`  ⚠ Remote delete failed: ${error.response.data?.error || 'no write access to repository'}`));
         }
     }
 }

package/src/commands/template.js

@@ -0,0 +1,135 @@
+/**
+ * Template Command - Quick-start from a baked-in starter.
+ *
+ *   gent template list                       → show available templates
+ *   gent template use <name> [directory]     → scaffold a starter
+ *
+ * Templates are tiny inline definitions — no network needed. Keep them small
+ * so the CLI bundle stays light.
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const { pathExists, ensureDir } = require('../utils/fileSystem');
+const initCommand = require('./init');
+
+const TEMPLATES = {
+    node: {
+        description: 'Minimal Node.js project (package.json + index.js)',
+        files: {
+            'package.json': JSON.stringify({
+                name: '__NAME__',
+                version: '0.1.0',
+                main: 'index.js',
+                scripts: { start: 'node index.js' },
+            }, null, 2) + '\n',
+            'index.js': "console.log('hello from __NAME__');\n",
+            '.gentignore': 'node_modules/\n.env\n',
+            'README.md': '# __NAME__\n\nA Node.js project scaffolded with `gent template use node`.\n',
+        },
+    },
+    python: {
+        description: 'Minimal Python project (main.py + requirements.txt)',
+        files: {
+            'main.py': "def main():\n    print('hello from __NAME__')\n\nif __name__ == '__main__':\n    main()\n",
+            'requirements.txt': '',
+            '.gentignore': '__pycache__/\n.venv/\n*.pyc\n.env\n',
+            'README.md': '# __NAME__\n\nA Python project scaffolded with `gent template use python`.\n',
+        },
+    },
+    react: {
+        description: 'Vite + React skeleton (vite-style index.html + src/main.jsx)',
+        files: {
+            'package.json': JSON.stringify({
+                name: '__NAME__',
+                version: '0.1.0',
+                type: 'module',
+                scripts: { dev: 'vite', build: 'vite build', preview: 'vite preview' },
+                dependencies: { react: '^18.3.1', 'react-dom': '^18.3.1' },
+                devDependencies: { vite: '^5.4.0', '@vitejs/plugin-react': '^4.3.1' },
+            }, null, 2) + '\n',
+            'index.html': '<!doctype html>\n<html><head><title>__NAME__</title></head>\n<body><div id="root"></div><script type="module" src="/src/main.jsx"></script></body></html>\n',
+            'src/main.jsx': "import React from 'react';\nimport { createRoot } from 'react-dom/client';\ncreateRoot(document.getElementById('root')).render(<h1>__NAME__</h1>);\n",
+            '.gentignore': 'node_modules/\ndist/\n.env\n',
+            'README.md': '# __NAME__\n\nRun `npm install && npm run dev` to start.\n',
+        },
+    },
+    'django-api': {
+        description: 'Minimal Django project shell (manage.py + settings stub)',
+        files: {
+            'manage.py': "#!/usr/bin/env python\nimport os, sys\nif __name__ == '__main__':\n    os.environ.setdefault('DJANGO_SETTINGS_MODULE', '__NAME__.settings')\n    from django.core.management import execute_from_command_line\n    execute_from_command_line(sys.argv)\n",
+            'requirements.txt': 'Django>=5.0\n',
+            '.gentignore': '__pycache__/\n*.pyc\n.venv/\ndb.sqlite3\n.env\n',
+            'README.md': '# __NAME__\n\nRun `python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt`.\n',
+        },
+    },
+};
+
+async function template(subcommand, args = [], options = {}) {
+    const sub = (subcommand || 'list').toLowerCase();
+    switch (sub) {
+        case 'list': return list();
+        case 'use': return use(args[0], args[1], options);
+        default:
+            console.error(chalk.red(`Unknown subcommand '${sub}'`));
+            console.log(chalk.gray('Usage: gent template <list|use>'));
+            process.exit(1);
+    }
+}
+
+function list() {
+    console.log(chalk.bold.cyan('\nAvailable templates\n'));
+    for (const [name, t] of Object.entries(TEMPLATES)) {
+        console.log(`  ${chalk.cyan(name.padEnd(14))} ${chalk.gray(t.description)}`);
+    }
+    console.log(chalk.gray('\n  Usage: gent template use <name> [directory]\n'));
+}
+
+async function use(name, directory) {
+    if (!name) {
+        console.error(chalk.red('Usage: gent template use <name> [directory]'));
+        process.exit(1);
+    }
+    const tpl = TEMPLATES[name];
+    if (!tpl) {
+        console.error(chalk.red(`Unknown template '${name}'`));
+        console.log(chalk.gray(`Available: ${Object.keys(TEMPLATES).join(', ')}`));
+        process.exit(1);
+    }
+
+    const targetDir = directory || name;
+    const targetPath = path.resolve(process.cwd(), targetDir);
+    const projectName = path.basename(targetPath).replace(/[^A-Za-z0-9_-]/g, '-');
+
+    if (await pathExists(targetPath)) {
+        const entries = await fs.readdir(targetPath);
+        if (entries.length > 0) {
+            console.error(chalk.red(`Directory '${targetDir}' is not empty.`));
+            process.exit(1);
+        }
+    } else {
+        await ensureDir(targetPath);
+    }
+
+    for (const [rel, content] of Object.entries(tpl.files)) {
+        const filePath = path.join(targetPath, rel);
+        await ensureDir(path.dirname(filePath));
+        const body = content.replace(/__NAME__/g, projectName);
+        await fs.writeFile(filePath, body, 'utf-8');
+    }
+
+    console.log(chalk.green(`✓ Scaffolded '${name}' into ${targetDir}/`));
+
+    // Auto-init a gent repo so the next steps work
+    const originalCwd = process.cwd();
+    try {
+        process.chdir(targetPath);
+        await initCommand({});
+    } finally {
+        process.chdir(originalCwd);
+    }
+    console.log(chalk.gray('  Next: cd ' + targetDir + ' && gent add -A && gent commit -m "init"'));
+}
+
+module.exports = template;

package/src/commands/web.js

@@ -0,0 +1,72 @@
+/**
+ * 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 --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.
+ */
+
+const path = require('path');
+const { exec } = 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');
+
+async function web(options = {}) {
+    try {
+        const gentPath = await getGentPath();
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const remote = (config.remotes || {}).origin;
+        if (!remote) {
+            console.error(chalk.red('No origin remote configured.'));
+            console.log(chalk.yellow('Run `gent remote add origin <url>` or `gent init --remote`.'));
+            process.exit(1);
+        }
+        const info = parseRemoteUrl(remote.url);
+        if (!info) {
+            console.error(chalk.red(`Origin URL '${remote.url}' isn't a recognized gent URL.`));
+            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(/\/$/, '');
+
+        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 (options.print) {
+            console.log(url);
+            return;
+        }
+
+        console.log(chalk.gray(`Opening ${url}`));
+        openInBrowser(url);
+    } 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 openInBrowser(url) {
+    const cmd = process.platform === 'darwin' ? 'open'
+        : process.platform === 'win32' ? 'start ""'
+        : 'xdg-open';
+    exec(`${cmd} "${url}"`, (err) => {
+        if (err) {
+            console.error(chalk.yellow('Could not auto-open. URL:'));
+            console.log(url);
+        }
+    });
+}
+
+module.exports = web;