gent-cli 6.0.1 → 7.0.0

package/src/commands/explain.js

@@ -0,0 +1,145 @@
+/**
+ * ============================================================================
+ * Explain Command - Plain-language summary of a commit or pending changes
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Turn a diff into a human explanation. With an API key set this uses Claude;
+ *   without one it still prints the unified diff plus a hint, so the command is
+ *   useful either way.
+ *
+ * USAGE:
+ *   gent explain            → explain the latest commit (HEAD)
+ *   gent explain <ref>      → explain a specific commit (full or short hash)
+ *   gent explain --staged   → explain the currently staged changes
+ *
+ * ============================================================================
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { getGentPath, readJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE, STAGING_FILE } = require('../utils/constants');
+const { readBlobAsString, treeToMap } = require('../utils/hash-engine');
+const { formatUnifiedDiff } = require('../utils/diff-engine');
+const ai = require('../utils/ai-service');
+
+const MAX_DIFF_CHARS = 12000;
+
+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 }));
+}
+
+/**
+ * Build a unified-diff text between two trees (old → new).
+ */
+async function diffTrees(gentPath, oldEntries, newEntries) {
+    const oldMap = treeToMap(oldEntries);
+    const newMap = treeToMap(newEntries);
+    const files = new Set([...oldMap.keys(), ...newMap.keys()]);
+
+    const parts = [];
+    for (const file of files) {
+        const oh = oldMap.get(file);
+        const nh = newMap.get(file);
+        if (oh === nh) continue;
+        let oldText = '', newText = '';
+        try { if (oh) oldText = await readBlobAsString(gentPath, oh); } catch { /* binary/legacy */ }
+        try { if (nh) newText = await readBlobAsString(gentPath, nh); } catch { /* binary/legacy */ }
+        const d = formatUnifiedDiff(file, oldText, newText);
+        if (d) parts.push(d);
+    }
+    return parts.join('\n\n');
+}
+
+async function explain(ref, options = {}) {
+    try {
+        const gentPath = await getGentPath();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const commits = repository.commits || [];
+        const commitMap = new Map(commits.map(c => [c.hash, c]));
+
+        let title;
+        let diffText;
+
+        if (options.staged) {
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+            const entries = staging.entries || [];
+            if (entries.length === 0) {
+                console.log(chalk.yellow('No staged changes to explain'));
+                return;
+            }
+            const headHash = repository.branches[repository.currentBranch];
+            const headTree = treeEntriesOf(commitMap.get(headHash));
+            const stagedTree = entries
+                .filter(e => e.status !== 'deleted')
+                .map(e => ({ name: e.path, hash: e.hash }));
+            // Overlay staged entries on the HEAD tree
+            const overlay = new Map(headTree.map(e => [e.name, e.hash]));
+            for (const e of entries) {
+                if (e.status === 'deleted') overlay.delete(e.path);
+                else overlay.set(e.path, e.hash);
+            }
+            title = 'Staged changes';
+            diffText = await diffTrees(
+                gentPath,
+                headTree,
+                [...overlay].map(([name, hash]) => ({ name, hash }))
+            );
+            void stagedTree;
+        } else {
+            const targetHash = ref
+                ? (commits.find(c => c.hash === ref || c.hash.startsWith(ref)) || {}).hash
+                : repository.branches[repository.currentBranch];
+            const commit = targetHash ? commitMap.get(targetHash) : null;
+            if (!commit) {
+                console.log(chalk.yellow(ref ? `Commit '${ref}' not found` : 'No commits yet'));
+                return;
+            }
+            const parent = commit.parent ? commitMap.get(commit.parent) : null;
+            title = `Commit ${commit.hash.substring(0, 7)} — ${commit.message}`;
+            diffText = await diffTrees(gentPath, treeEntriesOf(parent), treeEntriesOf(commit));
+        }
+
+        if (!diffText) {
+            console.log(chalk.gray('No textual changes to explain.'));
+            return;
+        }
+
+        const trimmed = diffText.length > MAX_DIFF_CHARS
+            ? diffText.slice(0, MAX_DIFF_CHARS) + '\n... (diff truncated)'
+            : diffText;
+
+        console.log(chalk.bold.cyan(`\n${title}\n`));
+
+        if (!ai.isEnabled()) {
+            console.log(trimmed);
+            console.log(chalk.gray(`\n${ai.disabledHint()}`));
+            return;
+        }
+
+        const spinner = ora(`Asking ${ai.getModel()} to explain...`).start();
+        try {
+            const explanation = await ai.explainChanges(trimmed);
+            spinner.stop();
+            console.log(explanation);
+        } catch (err) {
+            spinner.fail(chalk.yellow('AI request failed — showing the raw diff instead'));
+            console.log(chalk.gray(`(${err.message})\n`));
+            console.log(trimmed);
+        }
+    } 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 = explain;

package/src/commands/log.js

@@ -60,7 +60,9 @@ async function log(options) {
             cur = c.parent;
         }
 
-        if (options.oneline) {
+        if (options.graph) {
+            displayGraphLog(commits, headHash, repository.branches || {}, limit);
+        } else if (options.oneline) {
             displayOnelineLog(ordered, headHash);
         } else {
             displayDetailedLog(ordered, headHash, currentBranch, options);
@@ -118,6 +120,54 @@ function displayDetailedLog(commits, currentCommitHash, currentBranch, options)
     });
 }
 
+/**
+ * Display a commit graph reachable from HEAD (parent + mergeParent edges),
+ * ordered newest-first, with branch/HEAD decorations and merge annotations.
+ * A simplified single-rail graph: merges are annotated rather than drawn as
+ * separate lanes, which keeps the output readable in a terminal.
+ */
+function displayGraphLog(allCommits, headHash, branches, limit) {
+    const map = new Map(allCommits.map(c => [c.hash, c]));
+
+    // Reachable set from HEAD via both edges.
+    const reachable = [];
+    const seen = new Set();
+    const stack = [headHash];
+    while (stack.length) {
+        const h = stack.pop();
+        if (!h || seen.has(h)) continue;
+        const c = map.get(h);
+        if (!c) continue;
+        seen.add(h);
+        reachable.push(c);
+        if (c.parent) stack.push(c.parent);
+        if (c.mergeParent) stack.push(c.mergeParent);
+    }
+    reachable.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+    const limited = reachable.slice(0, limit);
+
+    // Branch labels by commit hash.
+    const refs = new Map();
+    for (const [name, hash] of Object.entries(branches)) {
+        if (!hash) continue;
+        if (!refs.has(hash)) refs.set(hash, []);
+        refs.get(hash).push(name);
+    }
+
+    console.log(chalk.bold.cyan('\nCommit graph:\n'));
+    limited.forEach((c, i) => {
+        const headLabel = c.hash === headHash ? chalk.yellow.bold(' (HEAD)') : '';
+        const refLabel = refs.has(c.hash) ? chalk.green(` (${refs.get(c.hash).join(', ')})`) : '';
+        const time = chalk.gray(`(${formatDistanceToNow(new Date(c.timestamp), { addSuffix: true })})`);
+        console.log(`${chalk.yellow('*')} ${chalk.yellow(c.hash.substring(0, 7))}${headLabel}${refLabel} ${c.message} ${time}`);
+        if (c.mergeParent) {
+            console.log(chalk.gray(`|\\  merge: ${(c.parent || '').substring(0, 7)} + ${c.mergeParent.substring(0, 7)}`));
+        }
+        if (i < limited.length - 1) console.log(chalk.gray('|'));
+    });
+    console.log();
+}
+
 /**
  * Display oneline commit log
  */

package/src/commands/merge.js

@@ -13,6 +13,7 @@ const { generateCommitHash } = require('../utils/helpers');
 const authStorage = require('../utils/auth-storage');
 const { findMergeBase, mergeTreeEntries, autoMerge } = require('../utils/merge-engine');
 const { storeTree, readBlobAsString, storeBlob } = require('../utils/hash-engine');
+const journal = require('../utils/journal');
 
 /**
  * Merge a branch into the current branch
@@ -66,6 +67,7 @@ async function merge(sourceBranch, options) {
         // Fast-forward: current branch is merge base → just move pointer
         if (baseHash === oursHash) {
             spinner.text = 'Fast-forward merge...';
+            await journal.recordOp(gentPath, 'merge', `fast-forward '${sourceBranch}' into ${currentBranch}`, { restoreTree: true });
             repository.branches[currentBranch] = theirsHash;
             await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
 
@@ -165,6 +167,8 @@ async function merge(sourceBranch, options) {
                 }
             };
 
+            await journal.recordOp(gentPath, 'merge', `merge '${sourceBranch}' into ${currentBranch}`);
+
             repository.commits.push(mergeCommit);
             repository.branches[currentBranch] = mergeCommit.hash;
             await writeJSON(path.join(gentPath, COMMITS_FILE), repository);

package/src/commands/reset.js

@@ -30,6 +30,7 @@ const ora = require('ora');
 const { getGentPath, readJSON, writeJSON, pathExists } = require('../utils/fileSystem');
 const { STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
 const { readBlobAsString } = require('../utils/hash-engine');
+const journal = require('../utils/journal');
 
 /**
  * Reset staging or HEAD
@@ -112,6 +113,15 @@ async function resetHead(gentPath, cwd, args, options) {
 
     const spinner = ora(`Resetting to ${target.hash.substring(0, 7)}...`).start();
 
+    // Journal pre-state. A hard reset discards working-tree content, so flag it
+    // for working-tree restore on undo.
+    await journal.recordOp(
+        gentPath,
+        'reset',
+        `${options.hard ? 'hard' : 'soft'} reset to ${target.hash.substring(0, 7)}`,
+        { restoreTree: !!options.hard }
+    );
+
     // Move branch pointer
     repository.branches[currentBranch] = target.hash;
     await writeJSON(path.join(gentPath, COMMITS_FILE), repository);

package/src/commands/resolve.js

@@ -0,0 +1,280 @@
+/**
+ * ============================================================================
+ * Resolve Command - Interactive merge-conflict resolver
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Walk each conflict hunk left by `gent merge` and let the user choose how to
+ *   resolve it — ours / theirs / both / edit / (optionally) ask AI — instead of
+ *   hand-editing conflict markers. When every conflict is resolved it offers to
+ *   finalize the merge commit.
+ *
+ * USAGE:
+ *   gent resolve            → interactively resolve the in-progress merge
+ *
+ * STATE:
+ *   Reads staging.mergeState (written by merge.js on conflict): sourceBranch,
+ *   oursHash, theirsHash, baseHash, mergedEntries, conflicts.
+ *
+ * ============================================================================
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE, STAGING_FILE, CONFIG_FILE } = require('../utils/constants');
+const { storeBlob, storeTree, readBlobAsString } = require('../utils/hash-engine');
+const { parseConflictMarkers, hasConflictMarkers } = require('../utils/merge-engine');
+const { generateCommitHash } = require('../utils/helpers');
+const authStorage = require('../utils/auth-storage');
+const journal = require('../utils/journal');
+const ai = require('../utils/ai-service');
+
+async function resolve() {
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+
+        const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+        const mergeState = staging.mergeState;
+
+        if (!mergeState) {
+            console.log(chalk.yellow('No merge in progress'));
+            console.log(chalk.gray('Run "gent merge <branch>" first; if it conflicts, resolve it here.'));
+            return;
+        }
+
+        // Files that carry conflict markers on disk.
+        const markerFiles = (mergeState.conflicts || [])
+            .filter(c => c.type === 'content' || c.type === 'add-add')
+            .map(c => c.file);
+
+        if (markerFiles.length === 0) {
+            console.log(chalk.green('No conflict markers to resolve.'));
+            console.log(chalk.cyan('Run "gent commit" to finalize the merge.'));
+            return;
+        }
+
+        console.log(chalk.bold.cyan(`\nResolving merge of '${mergeState.sourceBranch}' — ${markerFiles.length} file(s)\n`));
+
+        // Working copy of merged tree entries (we patch hashes as files resolve).
+        const entriesByName = new Map((mergeState.mergedEntries || []).map(e => [e.name, { ...e }]));
+        let unresolvedFiles = 0;
+
+        for (const file of markerFiles) {
+            const full = path.join(cwd, file);
+            let content;
+            try {
+                content = await fs.readFile(full, 'utf-8');
+            } catch {
+                console.log(chalk.gray(`  (skipping ${file} — not on disk)`));
+                continue;
+            }
+
+            if (!hasConflictMarkers(content)) {
+                console.log(chalk.green(`  ✓ ${file} already resolved`));
+                await stageResolved(gentPath, staging, entriesByName, file, content);
+                continue;
+            }
+
+            console.log(chalk.bold(`\n${file}`));
+            const segments = parseConflictMarkers(content);
+            const conflictCount = segments.filter(s => s.type === 'conflict').length;
+            let idx = 0;
+            let aborted = false;
+            const out = [];
+
+            for (const seg of segments) {
+                if (seg.type === 'text') {
+                    out.push(...seg.lines);
+                    continue;
+                }
+                idx++;
+                const resolvedLines = await resolveHunk(seg, file, idx, conflictCount);
+                if (resolvedLines === null) { aborted = true; break; }
+                out.push(...resolvedLines);
+            }
+
+            if (aborted) {
+                console.log(chalk.yellow(`  Left ${file} with remaining markers — re-run "gent resolve" later.`));
+                unresolvedFiles++;
+                continue;
+            }
+
+            const resolvedContent = out.join('\n');
+            await fs.writeFile(full, resolvedContent, 'utf-8');
+
+            if (hasConflictMarkers(resolvedContent)) {
+                unresolvedFiles++;
+                console.log(chalk.yellow(`  ${file} still has markers`));
+            } else {
+                await stageResolved(gentPath, staging, entriesByName, file, resolvedContent);
+                console.log(chalk.green(`  ✓ resolved ${file}`));
+            }
+        }
+
+        await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+
+        if (unresolvedFiles > 0) {
+            console.log(chalk.yellow(`\n${unresolvedFiles} file(s) still have conflicts. Re-run "gent resolve" when ready.`));
+            return;
+        }
+
+        // All conflicts resolved — offer to finalize the merge commit.
+        const { finalize } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'finalize',
+            message: 'All conflicts resolved. Create the merge commit now?',
+            default: true
+        }]);
+
+        if (!finalize) {
+            console.log(chalk.cyan('Resolved files staged. Run "gent commit" when ready.'));
+            return;
+        }
+
+        await finalizeMerge(gentPath, staging, mergeState, entriesByName);
+    } 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);
+    }
+}
+
+/**
+ * Prompt for one conflict hunk. Returns the chosen lines, or null to abort
+ * (leave the rest of the file as-is with markers).
+ */
+async function resolveHunk(seg, file, idx, total) {
+    console.log(chalk.gray(`  Conflict ${idx}/${total}:`));
+    console.log(chalk.green('    <<< ours'));
+    seg.ours.forEach(l => console.log(chalk.green(`      ${l}`)));
+    console.log(chalk.red('    >>> theirs'));
+    seg.theirs.forEach(l => console.log(chalk.red(`      ${l}`)));
+
+    const choices = [
+        { name: 'Keep ours', value: 'ours' },
+        { name: 'Keep theirs', value: 'theirs' },
+        { name: 'Keep both (ours then theirs)', value: 'both' },
+        { name: 'Edit manually', value: 'edit' }
+    ];
+    if (ai.isEnabled()) {
+        choices.splice(3, 0, { name: `Ask AI (${ai.getModel()})`, value: 'ai' });
+    }
+    choices.push({ name: 'Skip the rest of this file', value: 'skip' });
+
+    const { choice } = await inquirer.prompt([{
+        type: 'list',
+        name: 'choice',
+        message: `Resolve conflict ${idx}`,
+        choices
+    }]);
+
+    switch (choice) {
+        case 'ours': return seg.ours;
+        case 'theirs': return seg.theirs;
+        case 'both': return [...seg.ours, ...seg.theirs];
+        case 'skip': return null;
+        case 'edit': {
+            const { text } = await inquirer.prompt([{
+                type: 'editor',
+                name: 'text',
+                message: 'Edit the resolved section',
+                default: [...seg.ours, ...seg.theirs].join('\n')
+            }]);
+            return text.replace(/\n$/, '').split('\n');
+        }
+        case 'ai': {
+            try {
+                const suggestion = await ai.resolveConflictHunk({
+                    ours: seg.ours.join('\n'),
+                    theirs: seg.theirs.join('\n'),
+                    fileName: file
+                });
+                console.log(chalk.cyan('    AI suggestion:'));
+                suggestion.split('\n').forEach(l => console.log(chalk.cyan(`      ${l}`)));
+                const { accept } = await inquirer.prompt([{
+                    type: 'confirm', name: 'accept', message: 'Use this suggestion?', default: true
+                }]);
+                if (accept) return suggestion.split('\n');
+                return resolveHunk(seg, file, idx, total); // re-ask
+            } catch (err) {
+                console.log(chalk.yellow(`    AI failed (${err.message}); choose another option.`));
+                return resolveHunk(seg, file, idx, total);
+            }
+        }
+        default: return seg.ours;
+    }
+}
+
+/** Store the resolved file as a blob, patch the tree entry, and stage it. */
+async function stageResolved(gentPath, staging, entriesByName, file, content) {
+    const hash = await storeBlob(gentPath, content);
+    const entry = entriesByName.get(file) || { mode: '100644', name: file, type: 'blob' };
+    entry.hash = hash;
+    entriesByName.set(file, entry);
+
+    staging.entries = staging.entries || [];
+    const existing = staging.entries.find(e => e.path === file);
+    if (existing) {
+        existing.hash = hash;
+        existing.status = 'modified';
+    } else {
+        staging.entries.push({ path: file, hash, status: 'modified', binary: false, stats: { insertions: 0, deletions: 0 } });
+    }
+    staging.files = staging.entries.map(e => e.path);
+}
+
+/** Create the merge commit from the resolved tree and clear merge state. */
+async function finalizeMerge(gentPath, staging, mergeState, entriesByName) {
+    const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+    const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+
+    let authorName = config.user && config.user.name;
+    let authorEmail = config.user && config.user.email;
+    if (!authorName || !authorEmail) {
+        const globalUser = await authStorage.getUser();
+        if (globalUser) {
+            if (!authorName) authorName = [globalUser.first_name, globalUser.last_name].filter(Boolean).join(' ');
+            if (!authorEmail) authorEmail = globalUser.email;
+        }
+    }
+
+    const mergedEntries = [...entriesByName.values()];
+    const treeHash = await storeTree(gentPath, mergedEntries);
+
+    const mergeCommit = {
+        hash: generateCommitHash(),
+        message: `Merge branch '${mergeState.sourceBranch}' into ${repository.currentBranch}`,
+        author: { name: authorName || 'Unknown', email: authorEmail || 'unknown@gent' },
+        timestamp: new Date().toISOString(),
+        parent: mergeState.oursHash,
+        mergeParent: mergeState.theirsHash,
+        treeHash,
+        tree: mergedEntries,
+        files: mergedEntries.map(e => ({ path: e.name, hash: e.hash })),
+        stats: { filesChanged: mergedEntries.length, insertions: 0, deletions: 0 }
+    };
+
+    await journal.recordOp(gentPath, 'merge', `resolve+merge '${mergeState.sourceBranch}' into ${repository.currentBranch}`);
+
+    repository.commits = repository.commits || [];
+    repository.commits.push(mergeCommit);
+    repository.branches[repository.currentBranch] = mergeCommit.hash;
+    await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+    staging.entries = [];
+    staging.files = [];
+    staging.mergeState = null;
+    await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+
+    console.log(chalk.green(`\n✓ Merge committed — ${mergeCommit.hash.substring(0, 7)}`));
+}
+
+module.exports = resolve;