gent-cli 6.0.1 → 8.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/summary.js

@@ -0,0 +1,176 @@
+/**
+ * ============================================================================
+ * Summary Command - Repository health & statistics dashboard
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   A one-glance overview of the repository — commits, branches, tags,
+ *   contributors, tracked files, object-store size, most-changed files, last
+ *   activity, and how far ahead of the remote the current branch is. Something
+ *   plain git doesn't offer in a single command.
+ *
+ * USAGE:
+ *   gent summary           → print the dashboard
+ *   gent summary --ai      → also include a short AI-written health narrative
+ *
+ * ============================================================================
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const boxen = require('boxen');
+const { formatDistanceToNow } = require('date-fns');
+const { getGentPath, readJSON, pathExists } = require('../utils/fileSystem');
+const { COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const { readBlobAsString } = require('../utils/hash-engine');
+const { formatBytes } = require('../utils/helpers');
+const ai = require('../utils/ai-service');
+
+function treeEntriesOf(commit) {
+    if (!commit) return [];
+    if (Array.isArray(commit.tree)) return commit.tree;
+    return (commit.files || []).map(f => ({ name: f.path || f.name, hash: f.hash }));
+}
+
+/** Recursively sum the byte size of the object store. */
+async function objectStoreSize(gentPath) {
+    const root = path.join(gentPath, 'objects');
+    let total = 0;
+    async function walk(dir) {
+        let entries;
+        try { entries = await fs.readdir(dir, { withFileTypes: true }); } catch { return; }
+        for (const e of entries) {
+            const full = path.join(dir, e.name);
+            if (e.isDirectory()) await walk(full);
+            else { try { total += (await fs.stat(full)).size; } catch { /* ignore */ } }
+        }
+    }
+    await walk(root);
+    return total;
+}
+
+/** Count change frequency per file across history (hash-only tree diff). */
+function mostChangedFiles(commits, commitMap, limit = 5) {
+    const counts = new Map();
+    for (const c of commits) {
+        const cur = new Map(treeEntriesOf(c).map(e => [e.name, e.hash]));
+        const parent = c.parent ? commitMap.get(c.parent) : null;
+        const prev = new Map(treeEntriesOf(parent).map(e => [e.name, e.hash]));
+        const names = new Set([...cur.keys(), ...prev.keys()]);
+        for (const name of names) {
+            if (cur.get(name) !== prev.get(name)) counts.set(name, (counts.get(name) || 0) + 1);
+        }
+    }
+    return [...counts.entries()].sort((a, b) => b[1] - a[1]).slice(0, limit);
+}
+
+/** Count commits reachable from `head` not yet known to the remote ref. */
+function aheadCount(commitMap, head, remoteRef) {
+    if (!head) return 0;
+    let cur = head, n = 0;
+    const guard = new Set();
+    while (cur && cur !== remoteRef && !guard.has(cur)) {
+        guard.add(cur);
+        const c = commitMap.get(cur);
+        if (!c) break;
+        n++;
+        cur = c.parent;
+    }
+    return n;
+}
+
+async function summary(options = {}) {
+    try {
+        const gentPath = await getGentPath();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const configPath = path.join(gentPath, CONFIG_FILE);
+        const config = (await pathExists(configPath)) ? await readJSON(configPath) : {};
+
+        const commits = repository.commits || [];
+        const commitMap = new Map(commits.map(c => [c.hash, c]));
+        const branches = repository.branches || {};
+        const currentBranch = repository.currentBranch || 'main';
+        const tags = repository.tags || {};
+
+        // Contributors
+        const authors = new Map();
+        for (const c of commits) {
+            const key = `${c.author?.name || 'Unknown'} <${c.author?.email || 'unknown'}>`;
+            authors.set(key, (authors.get(key) || 0) + 1);
+        }
+        const topAuthors = [...authors.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+
+        // Tracked files + lines of code (text blobs only)
+        const headHash = branches[currentBranch];
+        const headTree = treeEntriesOf(commitMap.get(headHash));
+        let loc = 0;
+        for (const e of headTree) {
+            try { loc += (await readBlobAsString(gentPath, e.hash)).split('\n').length; } catch { /* binary */ }
+        }
+
+        const storeSize = await objectStoreSize(gentPath);
+        const topChanged = mostChangedFiles(commits, commitMap);
+
+        // Last activity
+        const last = commits.reduce((acc, c) =>
+            (!acc || new Date(c.timestamp) > new Date(acc.timestamp)) ? c : acc, null);
+
+        // Ahead of remote (if known)
+        const remoteRef = (config.remoteRefs || {})[`origin/${currentBranch}`];
+        const ahead = remoteRef ? aheadCount(commitMap, headHash, remoteRef) : null;
+
+        // ── Render ──
+        const lines = [];
+        lines.push(chalk.bold.cyan(config.repository?.name || path.basename(process.cwd())));
+        if (config.repository?.description) lines.push(chalk.gray(config.repository.description));
+        lines.push('');
+        lines.push(`${chalk.bold('Branch:')}      ${chalk.green(currentBranch)}  ${chalk.gray(`(${Object.keys(branches).length} total)`)}`);
+        lines.push(`${chalk.bold('Commits:')}     ${commits.length}`);
+        lines.push(`${chalk.bold('Tags:')}        ${Object.keys(tags).length}`);
+        lines.push(`${chalk.bold('Tracked:')}     ${headTree.length} file(s), ~${loc} lines`);
+        lines.push(`${chalk.bold('Objects:')}     ${formatBytes(storeSize)}`);
+        if (ahead !== null) lines.push(`${chalk.bold('Remote:')}      ${ahead === 0 ? chalk.green('up to date') : chalk.yellow(`${ahead} commit(s) ahead of origin/${currentBranch}`)}`);
+        if (last) lines.push(`${chalk.bold('Last commit:')} ${formatDistanceToNow(new Date(last.timestamp), { addSuffix: true })}`);
+
+        if (topAuthors.length) {
+            lines.push('');
+            lines.push(chalk.bold('Top contributors:'));
+            for (const [name, n] of topAuthors) lines.push(`  ${chalk.green(String(n).padStart(4))}  ${name}`);
+        }
+
+        if (topChanged.length) {
+            lines.push('');
+            lines.push(chalk.bold('Most-changed files:'));
+            for (const [name, n] of topChanged) lines.push(`  ${chalk.yellow(String(n).padStart(4))}  ${name}`);
+        }
+
+        console.log(boxen(lines.join('\n'), {
+            padding: 1, margin: 1, borderStyle: 'round', borderColor: 'cyan', title: 'gent summary', titleAlignment: 'center'
+        }));
+
+        if (options.ai) {
+            if (!ai.isEnabled()) {
+                console.log(chalk.gray(ai.disabledHint()));
+            } else {
+                try {
+                    const facts = lines.join('\n').replace(/\[[0-9;]*m/g, ''); // strip colors
+                    const narrative = await ai.explainChanges(`Repository stats:\n${facts}\n\nGive a 2-3 sentence health assessment.`);
+                    console.log(chalk.cyan(narrative));
+                } catch (err) {
+                    console.log(chalk.yellow(`AI summary failed: ${err.message}`));
+                }
+            }
+        }
+    } catch (error) {
+        if (error.code === 'ENOENT' && error.message.includes('.gent')) {
+            console.error(chalk.red('Error: Not a gent repository'));
+            console.log(chalk.yellow('\nRun "gent init" to initialize a repository'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = summary;

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

@@ -0,0 +1,115 @@
+/**
+ * ============================================================================
+ * Undo / Redo Commands - One-command safety net over the operation journal
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Reverse (or re-apply) the last history-changing operation without having to
+ *   reason about reflogs and commit hashes.
+ *
+ * USAGE:
+ *   gent undo            → Reverse the last operation
+ *   gent undo --list     → Show the operation history (most recent first)
+ *   gent redo            → Re-apply the last undone operation
+ *
+ * See src/utils/journal.js for the recorded state and exact undo semantics
+ * (working files are never deleted).
+ *
+ * ============================================================================
+ */
+
+const chalk = require('chalk');
+const { formatDistanceToNow } = require('date-fns');
+const { getGentPath } = require('../utils/fileSystem');
+const journal = require('../utils/journal');
+
+function shortHash(h) {
+    return h ? h.substring(0, 7) : '(none)';
+}
+
+function notARepo(error) {
+    return error.code === 'ENOENT' && error.message.includes('.gent');
+}
+
+/**
+ * `gent undo` — reverse the last operation, or list history with --list.
+ * @param {Object} options
+ */
+async function undo(options = {}) {
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+
+        if (options.list) {
+            await printHistory(gentPath);
+            return;
+        }
+
+        const result = await journal.applyUndo(gentPath, cwd);
+        if (!result.ok) {
+            console.log(chalk.yellow('Nothing to undo'));
+            console.log(chalk.gray('History-changing operations (commit, merge, reset, checkout) can be undone.'));
+            return;
+        }
+
+        const { entry } = result;
+        console.log(chalk.green(`✓ Undid ${chalk.bold(entry.op)}: ${entry.description}`));
+        console.log(chalk.gray(`  Now on '${result.branch}' at ${shortHash(result.head)}`));
+        console.log(chalk.cyan('  Run "gent redo" to re-apply.'));
+    } catch (error) {
+        if (notARepo(error)) {
+            console.error(chalk.red('Error: Not a gent repository'));
+            console.log(chalk.yellow('\nRun "gent init" to initialize a repository'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * `gent redo` — re-apply the last undone operation.
+ */
+async function redo() {
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+
+        const result = await journal.applyRedo(gentPath, cwd);
+        if (!result.ok) {
+            console.log(chalk.yellow('Nothing to redo'));
+            return;
+        }
+
+        const { entry } = result;
+        console.log(chalk.green(`✓ Redid ${chalk.bold(entry.op)}: ${entry.description}`));
+        console.log(chalk.gray(`  Now on '${result.branch}' at ${shortHash(result.head)}`));
+    } catch (error) {
+        if (notARepo(error)) {
+            console.error(chalk.red('Error: Not a gent repository'));
+            console.log(chalk.yellow('\nRun "gent init" to initialize a repository'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+async function printHistory(gentPath) {
+    const entries = await journal.listEntries(gentPath);
+    if (entries.length === 0) {
+        console.log(chalk.yellow('No operations recorded yet'));
+        return;
+    }
+
+    console.log(chalk.bold.cyan('\nOperation history (most recent first):\n'));
+    entries.forEach((e, i) => {
+        const when = chalk.gray(`(${formatDistanceToNow(new Date(e.timestamp), { addSuffix: true })})`);
+        const marker = i === 0 ? chalk.yellow('● ') : chalk.gray('○ ');
+        console.log(`${marker}${chalk.bold(e.op.padEnd(14))} ${e.description} ${when}`);
+    });
+    console.log(chalk.gray('\n"gent undo" reverses the most recent (●).'));
+}
+
+module.exports = undo;
+module.exports.redo = redo;