gent-cli 7.0.0 → 9.0.0

package/src/commands/config.js

@@ -0,0 +1,147 @@
+/**
+ * Config Command - Manage CLI-wide settings (~/.gent/cli-config.json)
+ *
+ *   gent config list                      → show all settings + source
+ *   gent config get <key>                 → print one setting
+ *   gent config set <key> <value>         → save a setting
+ *   gent config unset <key>               → remove a setting
+ *   gent config path                      → print config file location
+ *
+ *   gent config set ai.api_key <key>      ← stored obfuscated
+ *   gent config set api.base_url http://localhost:8000
+ */
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const userConfig = require('../utils/user-config');
+
+async function config(subcommand, args, options) {
+    try {
+        const sub = (subcommand || 'list').toLowerCase();
+        const positional = args || [];
+
+        switch (sub) {
+            case 'list':
+            case 'ls':
+                return list();
+            case 'get':
+                return get(positional[0]);
+            case 'set':
+                return set(positional[0], positional[1], options);
+            case 'unset':
+            case 'remove':
+            case 'rm':
+                return unset(positional[0]);
+            case 'path':
+                console.log(userConfig.getConfigPath());
+                return;
+            default:
+                console.error(chalk.red(`Unknown subcommand '${sub}'`));
+                console.log(chalk.gray('Usage: gent config <list|get|set|unset|path> [args]'));
+                process.exit(1);
+        }
+    } catch (error) {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    }
+}
+
+async function list() {
+    const rows = await userConfig.listAll();
+    console.log(chalk.bold.cyan('\nGent CLI configuration\n'));
+
+    const sourceColor = {
+        env: chalk.magenta,
+        config: chalk.green,
+        default: chalk.gray,
+        unset: chalk.gray,
+    };
+
+    for (const row of rows) {
+        const value = row.value === undefined
+            ? chalk.gray('(not set)')
+            : chalk.white(row.value);
+        const sourceLabel = row.source === 'env'
+            ? `env: ${row.envName}`
+            : row.source;
+        console.log(
+            `  ${chalk.cyan(row.key.padEnd(16))} ${value}  ` +
+            sourceColor[row.source](`[${sourceLabel}]`)
+        );
+    }
+    console.log(chalk.gray(`\nFile: ${userConfig.getConfigPath()}`));
+    console.log(chalk.gray('Set a value: gent config set <key> <value>\n'));
+}
+
+async function get(key) {
+    if (!key) {
+        console.error(chalk.red('Usage: gent config get <key>'));
+        process.exit(1);
+    }
+    if (!userConfig.isAllowedKey(key)) {
+        console.error(chalk.red(`Unknown key '${key}'`));
+        console.log(chalk.gray(`Allowed: ${userConfig.listAllowedKeys().join(', ')}`));
+        process.exit(1);
+    }
+    const resolved = await userConfig.getResolved(key);
+    if (resolved.value === undefined) {
+        console.log(chalk.gray('(not set)'));
+        return;
+    }
+    console.log(resolved.value);
+}
+
+async function set(key, value, options) {
+    if (!key) {
+        console.error(chalk.red('Usage: gent config set <key> <value>'));
+        process.exit(1);
+    }
+    if (!userConfig.isAllowedKey(key)) {
+        console.error(chalk.red(`Unknown key '${key}'`));
+        console.log(chalk.gray(`Allowed: ${userConfig.listAllowedKeys().join(', ')}`));
+        process.exit(1);
+    }
+
+    // Secret prompt: if no value given for ai.api_key, prompt with masking.
+    if ((value === undefined || value === '') && key === 'ai.api_key') {
+        const answers = await inquirer.prompt([{
+            type: 'password',
+            name: 'value',
+            message: 'Anthropic API key:',
+            mask: '*',
+            validate: (input) => input.length > 0 || 'Key cannot be empty',
+        }]);
+        value = answers.value;
+    }
+
+    if (value === undefined) {
+        console.error(chalk.red('Usage: gent config set <key> <value>'));
+        process.exit(1);
+    }
+
+    await userConfig.set(key, value);
+    const display = key === 'ai.api_key' ? userConfig.maskSecret(value) : value;
+    console.log(chalk.green(`✓ ${key} = ${display}`));
+
+    const envName = userConfig.ENV_OVERRIDES[key];
+    if (envName && process.env[envName]) {
+        console.log(chalk.yellow(
+            `Note: ${envName} is currently set in your environment and will override this value.`
+        ));
+    }
+}
+
+async function unset(key) {
+    if (!key) {
+        console.error(chalk.red('Usage: gent config unset <key>'));
+        process.exit(1);
+    }
+    if (!userConfig.isAllowedKey(key)) {
+        console.error(chalk.red(`Unknown key '${key}'`));
+        process.exit(1);
+    }
+    await userConfig.unset(key);
+    console.log(chalk.green(`✓ Removed ${key}`));
+}
+
+module.exports = config;

package/src/commands/docs.js

@@ -0,0 +1,141 @@
+/**
+ * Docs Command - AI-generate a README for the current repo.
+ *
+ *   gent docs                  → print suggested README to stdout
+ *   gent docs --write          → write to README.md (prompt before overwrite)
+ *   gent docs --section <name> → only regenerate a section (Usage, Install, ...)
+ *
+ * Builds context from: repository name/desc, file tree, key files (package.json,
+ * pyproject.toml, etc.), and a sample of source files.
+ */
+
+const path = require('path');
+const fs = require('fs').promises;
+const chalk = require('chalk');
+const ora = require('ora');
+const inquirer = require('inquirer');
+const { getGentPath, readJSON, pathExists } = require('../utils/fileSystem');
+const { CONFIG_FILE } = require('../utils/constants');
+const ai = require('../utils/ai-service');
+
+const KEY_FILES = [
+    'package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod',
+    'requirements.txt', 'Gemfile', 'composer.json', 'pom.xml',
+];
+
+const MAX_CONTEXT_CHARS = 16000;
+
+async function docs(options = {}) {
+    try {
+        const cwd = process.cwd();
+        const gentPath = await getGentPath();
+
+        if (!ai.isEnabled()) {
+            console.error(chalk.red('AI is required for `gent docs`.'));
+            console.log(chalk.yellow(ai.disabledHint()));
+            process.exit(1);
+        }
+
+        const context = await buildDocsContext(gentPath, cwd);
+        const target = options.section
+            ? `Generate ONLY the "${options.section}" section of a README.md.`
+            : 'Generate a complete, polished README.md.';
+
+        const spinner = ora(`Drafting README with ${ai.getModel()}...`).start();
+        let draft;
+        try {
+            draft = await ai.complete({
+                system:
+                    'You write clear, accurate, well-formatted README.md files. ' +
+                    'Use plain GitHub-flavored Markdown. Do not invent features that are not ' +
+                    'in the provided context. Prefer short paragraphs and concrete examples.',
+                prompt:
+                    `${target}\n\nProject context:\n\n${context}\n\n` +
+                    'Output: ONLY the Markdown. No preamble, no code fences around the whole document.',
+                maxTokens: 2500,
+            });
+        } catch (err) {
+            spinner.fail(chalk.red(err.message));
+            process.exit(1);
+        }
+        spinner.stop();
+
+        if (!options.write) {
+            console.log(draft);
+            console.log(chalk.gray('\n(use --write to save to README.md)\n'));
+            return;
+        }
+
+        const target_path = path.join(cwd, 'README.md');
+        if (await pathExists(target_path)) {
+            const { ok } = await inquirer.prompt([{
+                type: 'confirm',
+                name: 'ok',
+                message: `Overwrite existing README.md?`,
+                default: false,
+            }]);
+            if (!ok) {
+                console.log(chalk.yellow('Aborted — nothing written.'));
+                return;
+            }
+        }
+        await fs.writeFile(target_path, draft + '\n', 'utf-8');
+        console.log(chalk.green(`✓ Wrote ${path.relative(cwd, target_path)}`));
+    } 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);
+    }
+}
+
+async function buildDocsContext(gentPath, cwd) {
+    const parts = [];
+
+    try {
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const r = config.repository || {};
+        parts.push(`# Project metadata\nname: ${r.name || ''}\ndescription: ${r.description || ''}`);
+    } catch { /* fine */ }
+
+    // Top-level layout
+    try {
+        const entries = await fs.readdir(cwd, { withFileTypes: true });
+        const layout = entries
+            .filter(e => !e.name.startsWith('.') && e.name !== 'node_modules')
+            .map(e => e.isDirectory() ? `${e.name}/` : e.name);
+        parts.push(`# Top-level layout\n${layout.join('\n')}`);
+    } catch { /* fine */ }
+
+    // Key manifest files
+    for (const f of KEY_FILES) {
+        const p = path.join(cwd, f);
+        if (await pathExists(p)) {
+            try {
+                const text = await fs.readFile(p, 'utf-8');
+                parts.push(`# ${f}\n${text.slice(0, 2000)}`);
+            } catch { /* fine */ }
+        }
+    }
+
+    // Existing README (so the model can preserve voice if user wants to refresh)
+    for (const c of ['README.md', 'readme.md']) {
+        const p = path.join(cwd, c);
+        if (await pathExists(p)) {
+            try {
+                const text = await fs.readFile(p, 'utf-8');
+                parts.push(`# Existing ${c}\n${text.slice(0, 3000)}`);
+                break;
+            } catch { /* fine */ }
+        }
+    }
+
+    const joined = parts.join('\n\n');
+    return joined.length > MAX_CONTEXT_CHARS
+        ? joined.slice(0, MAX_CONTEXT_CHARS) + '\n... (context truncated)'
+        : joined;
+}
+
+module.exports = docs;

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/log.js

@@ -16,8 +16,7 @@
  *   Reads commits.json, filters by branch HEAD → parent chain, displays
  *   in reverse chronological order.
  *
- * BACKEND EXPECTATIONS:
- *   GET /api/repos/:id/commits/?branch=main&limit=10
+ * BACKEND: none — fully local. Reads commits.json; makes no HTTP request.
  *
  * ============================================================================
  */

package/src/commands/members.js

@@ -0,0 +1,134 @@
+/**
+ * Members Command - Manage repository collaborators (owner-only for add/remove).
+ *
+ * USAGE:
+ *   gent members                     → list owner + members with roles
+ *   gent members add <email>         → add a collaborator (default role: write)
+ *   gent members add <email> --role read
+ *   gent members remove <email>      → remove a collaborator
+ *
+ * BACKEND:
+ *   GET    /api/repos/:owner_id/:repo_name/members/                → [{ user_id, email, role, created_at }]
+ *   POST   /api/repos/:owner_id/:repo_name/members/  { email, role: 'write'|'read' }
+ *   DELETE /api/repos/:owner_id/:repo_name/members/:user_id/
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const path = require('path');
+const { readJSON, getGentPath } = require('../utils/fileSystem');
+const { CONFIG_FILE, API_ENDPOINTS, buildRepoUrl, parseRemoteUrl } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
+
+const VALID_ROLES = ['write', 'read'];
+
+/**
+ * Resolve the origin remote's { owner_id, repo_name } for the current repo.
+ */
+async function resolveRepoInfo() {
+    const gentPath = await getGentPath();
+    const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+    const remoteConfig = config.remotes && config.remotes.origin;
+    if (!remoteConfig) {
+        throw new Error("No 'origin' remote. Use \"gent remote add origin <url>\" first.");
+    }
+    const repoInfo = parseRemoteUrl(remoteConfig.url);
+    if (!repoInfo) {
+        throw new Error('Invalid origin remote URL. Expected /api/repos/{owner_id}/{repo_name}');
+    }
+    return repoInfo;
+}
+
+async function members(action, target, options = {}) {
+    try {
+        if (!(await authStorage.isAuthenticated())) {
+            console.error(chalk.red('Not authenticated'));
+            console.log(chalk.yellow('Run "gent login" first'));
+            return;
+        }
+
+        const repoInfo = await resolveRepoInfo();
+
+        if (!action || action === 'list') {
+            await listMembers(repoInfo);
+        } else if (action === 'add') {
+            await addMember(repoInfo, target, options);
+        } else if (action === 'remove' || action === 'rm') {
+            await removeMember(repoInfo, target);
+        } else {
+            console.error(chalk.red(`Unknown action '${action}'`));
+            console.log(chalk.yellow('Usage: gent members [list | add <email> | remove <email>]'));
+        }
+    } catch (error) {
+        handleError(error);
+    }
+}
+
+async function listMembers(repoInfo) {
+    const spinner = ora('Fetching members...').start();
+    const data = await apiClient.get(buildRepoUrl(API_ENDPOINTS.REPO_MEMBERS, repoInfo));
+    spinner.stop();
+
+    console.log(chalk.bold.cyan('\nRepository members:\n'));
+    for (const m of data || []) {
+        const role = m.role === 'owner'
+            ? chalk.magenta('owner')
+            : m.role === 'write' ? chalk.green('write') : chalk.gray('read');
+        console.log(`  ${chalk.white.bold(m.email)}  [${role}]  ${chalk.gray(`#${m.user_id}`)}`);
+    }
+    console.log();
+}
+
+async function addMember(repoInfo, email, options) {
+    if (!email) {
+        console.error(chalk.red('Usage: gent members add <email> [--role write|read]'));
+        return;
+    }
+    const role = (options.role || 'write').toLowerCase();
+    if (!VALID_ROLES.includes(role)) {
+        console.error(chalk.red(`Invalid role '${role}'. Use one of: ${VALID_ROLES.join(', ')}`));
+        return;
+    }
+
+    const spinner = ora(`Adding ${email} as ${role}...`).start();
+    await apiClient.post(buildRepoUrl(API_ENDPOINTS.REPO_MEMBERS, repoInfo), { email, role });
+    spinner.succeed(chalk.green(`Added ${email} (${role})`));
+}
+
+async function removeMember(repoInfo, email) {
+    if (!email) {
+        console.error(chalk.red('Usage: gent members remove <email>'));
+        return;
+    }
+
+    const spinner = ora(`Removing ${email}...`).start();
+    // The remove endpoint keys on user_id, so resolve it from the member list.
+    const list = await apiClient.get(buildRepoUrl(API_ENDPOINTS.REPO_MEMBERS, repoInfo));
+    const member = (list || []).find(m => m.email === email && m.role !== 'owner');
+    if (!member) {
+        spinner.fail(chalk.red(`${email} is not a member of this repository`));
+        return;
+    }
+
+    await apiClient.delete(
+        buildRepoUrl(API_ENDPOINTS.REPO_MEMBER_DETAIL, { ...repoInfo, user_id: member.user_id })
+    );
+    spinner.succeed(chalk.green(`Removed ${email}`));
+}
+
+function handleError(error) {
+    if (error.response?.status === 401) {
+        console.error(chalk.red('Authentication failed — run "gent login"'));
+    } else if (error.response?.status === 403) {
+        console.error(chalk.red(error.response.data?.error || 'Only the repository owner can manage members'));
+    } else if (error.response?.data) {
+        const d = error.response.data;
+        console.error(chalk.red(d.error || (typeof d === 'object' ? JSON.stringify(d) : d)));
+    } else {
+        console.error(chalk.red('Error:'), error.message);
+    }
+    process.exit(1);
+}
+
+module.exports = members;