gent-cli 9.1.0 → 11.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gent-cli",
-  "version": "9.1.0",
+  "version": "11.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,8 +8,8 @@
   },
   "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 && 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",
+    "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:e2e": "node tests/offline-e2e.js",
     "test:remote:e2e": "node tests/remote-e2e.js",
     "demo": "bash demo.sh",

package/src/commands/add.js

@@ -76,8 +76,8 @@ async function add(files, options) {
 
             // Check if changed vs last commit
             const prevHash = lastTreeMap.get(relPath);
-            if (prevHash === blobHash && stagedMap.has(relPath)) {
-                continue; // unchanged, already staged
+            if (prevHash === blobHash) {
+                continue; // identical to the last commit — nothing to stage
             }
 
             // Determine change status

package/src/commands/auto.js

@@ -0,0 +1,270 @@
+/**
+ * Auto Command - One-shot interactive flow.
+ *
+ *   gent auto
+ *
+ * Walks a fresh user from nothing to a pushed commit:
+ *   sign in (or register) → init → link a remote → stage → commit → push.
+ * Each step no-ops when it's already done, so `gent auto` is safe to re-run.
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const boxen = require('boxen');
+const inquirer = require('inquirer');
+
+const { pathExists, readJSON, writeJSON } = require('../utils/fileSystem');
+const { GENT_DIR, CONFIG_FILE, API_ENDPOINTS, parseRemoteUrl } = require('../utils/constants');
+const authStorage = require('../utils/auth-storage');
+const authService = require('../services/auth-service');
+const apiClient = require('../utils/api-client');
+const { isInteractive } = require('../utils/interactive');
+
+const initCommand = require('./init');
+const addCommand = require('./add');
+const commitCommand = require('./commit');
+const pushCommand = require('./push');
+
+async function auto() {
+    if (!isInteractive()) {
+        console.error(chalk.red('gent auto needs an interactive terminal.'));
+        console.log(chalk.yellow('In scripts/CI, use the individual commands: gent init / add / commit / push.'));
+        process.exit(1);
+    }
+
+    console.log(boxen(
+        chalk.bold.cyan('gent auto') + chalk.gray('  — guided flow\n') +
+        chalk.white('Sign in → init → link remote → add → commit → push.'),
+        { padding: 1, margin: 1, borderStyle: 'round', borderColor: 'cyan' }
+    ));
+
+    try {
+        await ensureAuth();
+        await ensureRepo();
+        const linked = await ensureRemote();
+        await stageChanges();
+        await commitChanges();
+
+        if (linked) {
+            await pushChanges();
+        } else {
+            console.log(chalk.gray('\nSkipped push — no remote linked. Run `gent push` once you link one.'));
+        }
+
+        console.log(chalk.green('\n✓ All done.'));
+    } catch (err) {
+        // Sub-steps handle their own expected errors; this catches anything
+        // unexpected (e.g. a corrupt .gent/config.json) with a clean message.
+        console.error(chalk.red('\ngent auto stopped:'), err.message);
+        process.exit(1);
+    }
+}
+
+// ─── 1. Account ─────────────────────────────────────────
+async function ensureAuth() {
+    console.log(chalk.bold('\n1) Account'));
+
+    if (await authStorage.isAuthenticated()) {
+        const user = await authStorage.getUser();
+        console.log(chalk.green(`  ✓ Signed in as ${user?.email || 'unknown'}`));
+        return;
+    }
+
+    const { action } = await inquirer.prompt([{
+        type: 'list',
+        name: 'action',
+        message: 'You are not signed in. What would you like to do?',
+        choices: [
+            { name: 'Log in to an existing account', value: 'login' },
+            { name: 'Create a new account', value: 'register' },
+        ],
+    }]);
+
+    const creds = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email:',
+            validate: v => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(v) || 'Please enter a valid email',
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            mask: '*',
+            validate: v => v.length > 0 || 'Password is required',
+        },
+    ]);
+
+    let extra = {};
+    if (action === 'register') {
+        extra = await inquirer.prompt([
+            {
+                type: 'password',
+                name: 'passwordConfirm',
+                message: 'Confirm password:',
+                mask: '*',
+                validate: v => v === creds.password || 'Passwords do not match',
+            },
+            { type: 'input', name: 'firstName', message: 'First name:', default: '' },
+            { type: 'input', name: 'lastName', message: 'Last name:', default: '' },
+        ]);
+    }
+
+    const spinner = ora(action === 'login' ? 'Logging in…' : 'Creating account…').start();
+    try {
+        if (action === 'login') {
+            await authService.login(creds.email, creds.password);
+        } else {
+            await authService.register(
+                creds.email, creds.password, extra.passwordConfirm, extra.firstName, extra.lastName
+            );
+        }
+        spinner.succeed(chalk.green(`Signed in as ${creds.email}`));
+    } catch (err) {
+        spinner.fail(chalk.red(err.message));
+        process.exit(1);
+    }
+}
+
+// ─── 2. Repository ──────────────────────────────────────
+async function ensureRepo() {
+    console.log(chalk.bold('\n2) Repository'));
+    if (await pathExists(path.join(process.cwd(), GENT_DIR))) {
+        console.log(chalk.green('  ✓ Already a gent repository'));
+        return;
+    }
+    await initCommand({}); // prints its own "Initialized …" line
+}
+
+// ─── 3. Remote ──────────────────────────────────────────
+// Returns true when origin is linked (so we know whether to push at the end).
+async function ensureRemote() {
+    console.log(chalk.bold('\n3) Remote'));
+
+    const configPath = path.join(process.cwd(), GENT_DIR, CONFIG_FILE);
+    const config = await readJSON(configPath);
+    config.remotes = config.remotes || {};
+
+    if (config.remotes.origin) {
+        console.log(chalk.green(`  ✓ Linked: origin → ${config.remotes.origin.url}`));
+        return true;
+    }
+
+    const { how } = await inquirer.prompt([{
+        type: 'list',
+        name: 'how',
+        message: 'No remote linked yet. Link one?',
+        choices: [
+            { name: 'Create a new repository on gent', value: 'create' },
+            { name: 'Link an existing remote URL', value: 'existing' },
+            { name: 'Skip for now', value: 'skip' },
+        ],
+    }]);
+
+    if (how === 'skip') {
+        console.log(chalk.gray('  Skipped.'));
+        return false;
+    }
+
+    if (how === 'existing') {
+        const { url } = await inquirer.prompt([{
+            type: 'input',
+            name: 'url',
+            message: 'Remote URL (/api/repos/{owner_id}/{repo}):',
+            validate: v => !!parseRemoteUrl(v) || 'Expected /api/repos/{owner_id}/{repo_name}',
+        }]);
+        config.remotes.origin = { url };
+        await writeJSON(configPath, config);
+        console.log(chalk.green(`  ✓ Linked origin → ${url}`));
+        return true;
+    }
+
+    // create
+    if (!(await authStorage.isAuthenticated())) {
+        console.log(chalk.yellow('  Sign in first to create a remote — skipping.'));
+        return false;
+    }
+
+    const { name, isPrivate } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'name',
+            message: 'Repository name:',
+            default: path.basename(process.cwd()),
+            validate: v => v.trim().length > 0 || 'Please enter a name',
+        },
+        { type: 'confirm', name: 'isPrivate', message: 'Private repository?', default: false },
+    ]);
+
+    const spinner = ora(`Creating '${name}' on gent…`).start();
+    try {
+        const data = await apiClient.post(API_ENDPOINTS.REPOS_CREATE, {
+            name: name.trim(),
+            description: '',
+            is_private: isPrivate,
+        });
+        const repo = data.repository || data;
+        const url = `/api/repos/${repo.owner_id}/${repo.name}`;
+        config.remotes.origin = { url };
+        await writeJSON(configPath, config);
+        spinner.succeed(chalk.green(`Linked origin → ${url}`));
+        return true;
+    } catch (err) {
+        if (err.response?.status === 400) {
+            spinner.warn(chalk.yellow('Could not create — the name may already be taken.'));
+            console.log(chalk.gray('  Tip: `gent repos` to list, then `gent remote add origin <url>`.'));
+        } else {
+            spinner.fail(chalk.red(err.message));
+        }
+        return false;
+    }
+}
+
+// ─── 4. Stage ───────────────────────────────────────────
+async function stageChanges() {
+    console.log(chalk.bold('\n4) Stage changes'));
+
+    const { how } = await inquirer.prompt([{
+        type: 'list',
+        name: 'how',
+        message: 'What should we stage?',
+        choices: [
+            { name: 'All changes', value: 'all' },
+            { name: 'Specific paths', value: 'pick' },
+            { name: 'Nothing (skip)', value: 'skip' },
+        ],
+        default: 'all',
+    }]);
+
+    if (how === 'skip') return;
+
+    if (how === 'all') {
+        await addCommand([], { all: true });
+        return;
+    }
+
+    const { paths } = await inquirer.prompt([{
+        type: 'input',
+        name: 'paths',
+        message: 'Paths to add (space-separated):',
+        validate: v => v.trim().length > 0 || 'Enter at least one path',
+    }]);
+    await addCommand(paths.trim().split(/\s+/), {});
+}
+
+// ─── 5. Commit ──────────────────────────────────────────
+async function commitChanges() {
+    console.log(chalk.bold('\n5) Commit'));
+    // commit() prompts for the message itself and no-ops if nothing is staged.
+    await commitCommand({});
+}
+
+// ─── 6. Push ────────────────────────────────────────────
+async function pushChanges() {
+    console.log(chalk.bold('\n6) Push'));
+    await pushCommand('origin', undefined, {});
+}
+
+module.exports = auto;

package/src/index.js

@@ -29,8 +29,10 @@ require('./utils/env-loader').load();
 const { program } = require('commander');
 const chalk = require('chalk');
 const packageJson = require('../package.json');
+const interactive = require('./utils/interactive');
 
 // Import core commands
+const autoCommand = require('./commands/auto');
 const initCommand = require('./commands/init');
 const cloneCommand = require('./commands/clone');
 const statusCommand = require('./commands/status');
@@ -85,6 +87,11 @@ program
 
 // ─── Repository Setup ───────────────────────────────────
 
+program
+    .command('auto')
+    .description('Guided flow: sign in → init → link remote → add → commit → push')
+    .action(autoCommand);
+
 program
     .command('init')
     .description('Initialize a new gent repository')
@@ -93,9 +100,18 @@ program
     .action(initCommand);
 
 program
-    .command('clone <url> [directory]')
+    .command('clone [url] [directory]')
     .description('Clone a remote repository')
-    .action(cloneCommand);
+    .action(async (url, directory, options) => {
+        if (!url && interactive.isInteractive()) {
+            ({ url, directory } = await interactive.promptClone());
+        }
+        if (!url) {
+            console.error(chalk.red('error: missing url — usage: gent clone <url> [directory]'));
+            process.exit(1);
+        }
+        return cloneCommand(url, directory, options);
+    });
 
 // ─── Staging & Working Tree ─────────────────────────────
 
@@ -118,10 +134,19 @@ program
     });
 
 program
-    .command('rm <files...>')
+    .command('rm [files...]')
     .description('Remove files from working tree and staging')
     .option('--cached', 'Only remove from staging, keep file on disk')
-    .action(rmCommand);
+    .action(async (files, options) => {
+        if ((!files || files.length === 0) && interactive.isInteractive()) {
+            files = await interactive.promptRm();
+        }
+        if (!files || files.length === 0) {
+            console.error('error: specify files to remove');
+            process.exit(1);
+        }
+        return rmCommand(files, options);
+    });
 
 program
     .command('reset [files...]')
@@ -192,16 +217,46 @@ program
     .action(branchCommand);
 
 program
-    .command('checkout <branch>')
+    .command('checkout [branch]')
     .description('Switch branches or restore working tree files')
     .option('-b, --create', 'Create a new branch')
-    .action(checkoutCommand);
+    .action(async (branch, options) => {
+        if (!branch && interactive.isInteractive()) {
+            const picked = await interactive.promptCheckout();
+            branch = picked.branch;
+            options.create = picked.create; // picker decides: existing branch ⇒ switch, not create
+        }
+        if (!branch) {
+            console.error(chalk.red('error: missing branch — usage: gent checkout <branch>'));
+            process.exit(1);
+        }
+        return checkoutCommand(branch, options);
+    });
 
 program
-    .command('merge <branch>')
+    .command('merge [branch]')
     .description('Merge a branch into the current branch (3-way smart merge)')
     .option('-m, --message <message>', 'Merge commit message')
-    .action(mergeCommand);
+    .action(async (branch, options) => {
+        if (!branch && interactive.isInteractive()) {
+            const picked = await interactive.promptMerge();
+            if (!picked.branch) {
+                // In a repo with only one branch → nothing to merge; otherwise
+                // fall through so mergeCommand reports "Not a gent repository".
+                if (picked.current) {
+                    console.log(chalk.yellow('No other branches to merge.'));
+                    return;
+                }
+            } else {
+                branch = picked.branch;
+            }
+        }
+        if (!branch && !interactive.isInteractive()) {
+            console.error(chalk.red('error: missing branch — usage: gent merge <branch>'));
+            process.exit(1);
+        }
+        return mergeCommand(branch, options);
+    });
 
 program
     .command('resolve')
@@ -286,9 +341,14 @@ program
 // ─── Platform-special (AI-powered) ──────────────────────
 
 program
-    .command('ask <question>')
+    .command('ask [question]')
     .description('Ask Claude a question about this repo (needs AI key)')
-    .action(askCommand);
+    .action(async (question, options) => {
+        if (!question && interactive.isInteractive()) {
+            question = await interactive.promptAsk();
+        }
+        return askCommand(question, options);
+    });
 
 program
     .command('review [ref]')
@@ -384,6 +444,54 @@ program
         }
     });
 
+// ─── Grouped help ───────────────────────────────────────
+// Commander's default lists all ~45 commands in one flat block, which reads as
+// noise. Group them by purpose instead, and render our own list after Options.
+const HELP_GROUPS = [
+    ['Start here', ['auto', 'setup', 'init', 'clone']],
+    ['Work on changes', ['status', 'add', 'rm', 'reset', 'diff', 'commit']],
+    ['History', ['log', 'show', 'tag', 'explain', 'summary']],
+    ['Branches & merging', ['branch', 'checkout', 'merge', 'resolve', 'stash', 'undo', 'redo']],
+    ['Remote & sync', ['remote', 'repos', 'members', 'push', 'pull', 'search', 'web', 'share']],
+    ['Account', ['register', 'login', 'logout', 'whoami', 'password']],
+    ['AI', ['ask', 'review', 'docs', 'changelog', 'ai']],
+    ['Config & tools', ['config', 'doctor', 'template', 'help']],
+];
+
+function configureGroupedHelp(program) {
+    // Hide the default flat "Commands:" block…
+    program.configureHelp({ visibleCommands: () => [] });
+
+    // …and print a grouped one in its place.
+    program.addHelpText('after', () => {
+        const byName = new Map(program.commands.map(c => [c.name(), c]));
+        const pad = 13;
+        const listed = new Set();
+        const lines = ['Commands:', ''];
+
+        const row = (name) =>
+            `  ${chalk.cyan(name.padEnd(pad))}${chalk.gray(byName.get(name).description())}`;
+
+        for (const [title, names] of HELP_GROUPS) {
+            const rows = names.filter(n => byName.has(n));
+            if (!rows.length) continue;
+            rows.forEach(n => listed.add(n));
+            lines.push(chalk.bold(title), ...rows.map(row), '');
+        }
+
+        // Anything not placed in a group still shows up, so help stays complete.
+        const leftovers = [...byName.keys()].filter(n => !listed.has(n));
+        if (leftovers.length) {
+            lines.push(chalk.bold('Other'), ...leftovers.map(row), '');
+        }
+
+        lines.push(chalk.gray('Run ') + chalk.cyan('gent help <command>') + chalk.gray(' for details.'));
+        return '\n' + lines.join('\n');
+    });
+}
+
+configureGroupedHelp(program);
+
 // Friendlier global error mapping. Per-command handlers still own their own
 // errors; this catches anything that bubbles up (e.g. unknown command).
 function explainError(err) {
@@ -402,7 +510,8 @@ function showQuickstart() {
     console.log(chalk.bold.cyan('Gent CLI ') + chalk.gray(`v${packageJson.version}`));
     console.log(chalk.gray('A Git-like VCS with cloud sync + AI superpowers.\n'));
     console.log(chalk.bold('First time? Try:'));
-    console.log(`  ${chalk.cyan('gent setup')}              ${chalk.gray('interactive walkthrough (login + AI key + remote)')}`);
+    console.log(`  ${chalk.cyan('gent auto')}               ${chalk.gray('guided init → commit → push (interactive)')}`);
+    console.log(`  ${chalk.cyan('gent setup')}              ${chalk.gray('configure login + AI key + remote')}`);
     console.log(`  ${chalk.cyan('gent doctor')}             ${chalk.gray('check everything is wired up')}`);
     console.log(`  ${chalk.cyan('gent template list')}      ${chalk.gray('scaffold a starter project')}`);
     console.log();

package/src/utils/constants.js

@@ -92,6 +92,8 @@ module.exports = {
         '.gent',
         'node_modules',
         '.git',
+        '.gitignore',
+        '.gentignore',
         '.DS_Store',
         '*.log',
         '.env',

package/src/utils/fileSystem.js

@@ -7,6 +7,8 @@ const fs = require('fs').promises;
 const path = require('path');
 const { GENT_DIR, DEFAULT_IGNORE_PATTERNS, IGNORE_FILE } = require('./constants');
 
+const GIT_IGNORE_FILE = '.gitignore';
+
 /**
  * Check if a path exists
  * @param {String} path - Path to check
@@ -115,21 +117,35 @@ function shouldIgnore(filePath, patterns) {
     const normalizedPath = filePath.replace(/\\/g, '/');
 
     for (const pattern of patterns) {
+        const normalizedPattern = normalizeIgnorePattern(pattern);
+        if (!normalizedPattern) {
+            continue;
+        }
+
         // Exact match
-        if (normalizedPath === pattern || normalizedPath.startsWith(pattern + '/')) {
+        if (normalizedPath === normalizedPattern || normalizedPath.startsWith(normalizedPattern + '/')) {
             return true;
         }
 
+        // Basename match
+        if (!normalizedPattern.includes('/') && !normalizedPattern.includes('*')) {
+            const parts = normalizedPath.split('/');
+            if (parts.includes(normalizedPattern)) {
+                return true;
+            }
+        }
+
         // Wildcard match
-        if (pattern.includes('*')) {
-            const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-            if (regex.test(normalizedPath)) {
+        if (normalizedPattern.includes('*')) {
+            const wildcardRegex = normalizedPattern.split('*').map(escapeRegex).join('.*');
+            const regex = new RegExp('^' + wildcardRegex + '$');
+            if (regex.test(normalizedPath) || regex.test(path.posix.basename(normalizedPath))) {
                 return true;
             }
         }
 
         // Extension match
-        if (pattern.startsWith('*.') && normalizedPath.endsWith(pattern.substring(1))) {
+        if (normalizedPattern.startsWith('*.') && normalizedPath.endsWith(normalizedPattern.substring(1))) {
             return true;
         }
     }
@@ -137,6 +153,56 @@ function shouldIgnore(filePath, patterns) {
     return false;
 }
 
+function normalizeIgnorePattern(pattern) {
+    return pattern
+        .replace(/\\/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/^\/+/, '')
+        .replace(/\/+$/, '');
+}
+
+function escapeRegex(pattern) {
+    return pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function parseIgnoreContent(content, basePath = '') {
+    return content.split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#') && !line.startsWith('!'))
+        .map(line => normalizeIgnorePattern(path.posix.join(basePath, line)))
+        .filter(Boolean);
+}
+
+async function collectGitIgnorePatterns(rootDir, patterns) {
+    async function scan(currentDir) {
+        const entries = await fs.readdir(currentDir, { withFileTypes: true });
+        const relativeDir = path.relative(rootDir, currentDir).replace(/\\/g, '/');
+        const gitIgnore = entries.find(entry => entry.isFile() && entry.name === GIT_IGNORE_FILE);
+
+        if (gitIgnore) {
+            const ignorePath = path.join(currentDir, GIT_IGNORE_FILE);
+            const content = await fs.readFile(ignorePath, 'utf-8');
+            patterns.push(...parseIgnoreContent(content, relativeDir));
+        }
+
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+
+            const fullPath = path.join(currentDir, entry.name);
+            const relativePath = path.relative(rootDir, fullPath);
+            if (shouldIgnore(relativePath, patterns)) {
+                continue;
+            }
+
+            await scan(fullPath);
+        }
+    }
+
+    await scan(rootDir);
+}
+
 /**
  * Get ignore patterns from .gentignore file
  * @param {String} dir - Directory to check
@@ -148,13 +214,11 @@ async function getIgnorePatterns(dir) {
 
     if (await pathExists(ignorePath)) {
         const content = await fs.readFile(ignorePath, 'utf-8');
-        const lines = content.split('\n')
-            .map(line => line.trim())
-            .filter(line => line && !line.startsWith('#'));
-
-        patterns.push(...lines);
+        patterns.push(...parseIgnoreContent(content));
     }
 
+    await collectGitIgnorePatterns(dir, patterns);
+
     return patterns;
 }
 

package/src/utils/interactive.js

@@ -0,0 +1,160 @@
+/**
+ * Interactive helpers — shared prompt resolvers for commands that need an
+ * argument the user didn't pass on the command line.
+ *
+ * The rule everywhere: if we're in a TTY, ask; otherwise leave the value
+ * undefined so the command prints its usual "usage" error (keeps scripts/CI
+ * behaving exactly as before).
+ */
+
+const path = require('path');
+const inquirer = require('inquirer');
+const { getGentPath, readJSON } = require('./fileSystem');
+const { COMMITS_FILE } = require('./constants');
+
+// Sentinel for the "create a new branch" choice — deliberately not a legal
+// branch name, so it can never collide with a real one.
+const CREATE_NEW = '__gent_create_new_branch__';
+
+/** True only when both stdin and stdout are a real terminal. */
+function isInteractive() {
+    return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+
+/** Local branches from commits.json. { current, names } — empty if not a repo. */
+async function loadBranches() {
+    try {
+        const gentPath = await getGentPath();
+        const repo = await readJSON(path.join(gentPath, COMMITS_FILE));
+        return {
+            current: repo.currentBranch || 'main',
+            names: Object.keys(repo.branches || {}),
+        };
+    } catch {
+        return { current: null, names: [] };
+    }
+}
+
+/** File paths tracked in the current branch's HEAD commit. [] if not a repo. */
+async function listTrackedFiles() {
+    try {
+        const gentPath = await getGentPath();
+        const repo = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const head = repo.branches?.[repo.currentBranch];
+        const commit = head ? (repo.commits || []).find(c => c.hash === head) : null;
+        const tree = commit ? (commit.tree || commit.files || []) : [];
+        return tree.map(f => f.name || f.path).filter(Boolean);
+    } catch {
+        return [];
+    }
+}
+
+/** gent clone — ask for the URL and (optionally) a target directory. */
+async function promptClone() {
+    const ans = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'url',
+            message: 'Repository URL to clone (/api/repos/{owner_id}/{repo}):',
+            validate: v => v.trim().length > 0 || 'Please enter a URL',
+        },
+        {
+            type: 'input',
+            name: 'directory',
+            message: 'Target directory (blank = repo name):',
+            default: '',
+        },
+    ]);
+    return { url: ans.url.trim(), directory: ans.directory.trim() || undefined };
+}
+
+/** gent checkout — pick an existing branch or create a new one. */
+async function promptCheckout() {
+    const { current, names } = await loadBranches();
+    const others = names.filter(n => n !== current);
+
+    const choices = [
+        ...others.map(n => ({ name: n, value: n })),
+        ...(others.length ? [new inquirer.Separator()] : []),
+        { name: '＋ Create a new branch…', value: CREATE_NEW },
+    ];
+
+    const { pick } = await inquirer.prompt([{
+        type: 'list',
+        name: 'pick',
+        message: current ? `Switch to which branch? (current: ${current})` : 'Branch:',
+        choices,
+    }]);
+
+    if (pick === CREATE_NEW) {
+        const { name } = await inquirer.prompt([{
+            type: 'input',
+            name: 'name',
+            message: 'New branch name:',
+            validate: v => v.trim().length > 0 || 'Please enter a name',
+        }]);
+        return { branch: name.trim(), create: true };
+    }
+    return { branch: pick, create: false };
+}
+
+/** gent merge — pick a branch (other than the current one) to merge in.
+ *  `current` is null when we're not in a repo, so the caller can tell
+ *  "no other branches" apart from "not a repo". */
+async function promptMerge() {
+    const { current, names } = await loadBranches();
+    const others = names.filter(n => n !== current);
+    if (!others.length) return { branch: null, current };
+
+    const { branch } = await inquirer.prompt([{
+        type: 'list',
+        name: 'branch',
+        message: `Merge which branch into '${current}'?`,
+        choices: others,
+    }]);
+    return { branch, current };
+}
+
+/** gent ask — free-text question. */
+async function promptAsk() {
+    const { question } = await inquirer.prompt([{
+        type: 'input',
+        name: 'question',
+        message: 'What do you want to ask about this repo?',
+        validate: v => v.trim().length > 0 || 'Please enter a question',
+    }]);
+    return question.trim();
+}
+
+/** gent rm — checkbox of tracked files, or free-text if none are tracked. */
+async function promptRm() {
+    const tracked = await listTrackedFiles();
+    if (tracked.length) {
+        const { files } = await inquirer.prompt([{
+            type: 'checkbox',
+            name: 'files',
+            message: 'Select files to remove:',
+            choices: tracked,
+            validate: v => v.length > 0 || 'Select at least one file (space to toggle)',
+        }]);
+        return files;
+    }
+    const { paths } = await inquirer.prompt([{
+        type: 'input',
+        name: 'paths',
+        message: 'Files to remove (space-separated):',
+        validate: v => v.trim().length > 0 || 'Enter at least one path',
+    }]);
+    return paths.trim().split(/\s+/);
+}
+
+module.exports = {
+    isInteractive,
+    loadBranches,
+    listTrackedFiles,
+    promptClone,
+    promptCheckout,
+    promptMerge,
+    promptAsk,
+    promptRm,
+};