gent-cli 6.0.1 → 8.0.0

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;

package/src/commands/review.js

@@ -0,0 +1,157 @@
+/**
+ * Review Command - AI code review on staged or HEAD changes.
+ *
+ *   gent review                → review staged changes (or HEAD if no staging)
+ *   gent review --staged       → force staged
+ *   gent review --head         → force HEAD commit diff
+ *   gent review <ref>          → review diff for that commit
+ *
+ * Output: prioritized bug/risk list followed by smaller polish suggestions.
+ * Without an AI key, prints the raw diff so the command still has value.
+ */
+
+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 = 16000;
+
+async function review(refArg, 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;
+
+        const explicitStaged = options.staged === true;
+        const explicitHead = options.head === true;
+        let useStaged = explicitStaged;
+
+        if (!explicitStaged && !explicitHead && !refArg) {
+            // Default: staged if anything is staged, else HEAD
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE)).catch(() => ({}));
+            const entries = staging.entries || [];
+            useStaged = entries.length > 0;
+        }
+
+        if (useStaged) {
+            const result = await stagedDiff(gentPath, repository, commitMap);
+            if (!result) {
+                console.log(chalk.yellow('Nothing staged to review.'));
+                return;
+            }
+            title = 'Staged changes';
+            diffText = result;
+        } else {
+            const ref = refArg || repository.branches[repository.currentBranch];
+            const commit = ref ? (commitMap.get(ref) || commits.find(c => c.hash.startsWith(ref))) : 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.slice(0, 7)} — ${commit.message.split('\n')[0]}`;
+            diffText = await diffTrees(gentPath, treeEntriesOf(parent), treeEntriesOf(commit));
+        }
+
+        if (!diffText) {
+            console.log(chalk.gray('No textual changes to review.'));
+            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(`Reviewing with ${ai.getModel()}...`).start();
+        try {
+            const out = await ai.complete({
+                system:
+                    'You are a senior code reviewer. Given a unified diff, list concrete ' +
+                    'issues you would block on, then smaller suggestions. Format:\n' +
+                    '🔴 Bugs / risks\n  - file:line — short description\n' +
+                    '🟡 Suggestions\n  - file — short description\n' +
+                    '🟢 Looks good\n  - one-line positive note\n' +
+                    'Be specific. If nothing is wrong, say so plainly.',
+                prompt: `Review this diff:\n\n${trimmed}`,
+                maxTokens: 1500,
+                thinking: true,
+            });
+            spinner.stop();
+            console.log(out + '\n');
+        } catch (err) {
+            spinner.fail(chalk.yellow('AI review 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'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+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 }));
+}
+
+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 */ }
+        try { if (nh) newText = await readBlobAsString(gentPath, nh); } catch { /* binary */ }
+        const d = formatUnifiedDiff(file, oldText, newText);
+        if (d) parts.push(d);
+    }
+    return parts.join('\n\n');
+}
+
+async function stagedDiff(gentPath, repository, commitMap) {
+    const staging = await readJSON(path.join(gentPath, STAGING_FILE)).catch(() => ({}));
+    const entries = staging.entries || [];
+    if (entries.length === 0) return null;
+
+    const headHash = repository.branches[repository.currentBranch];
+    const head = headHash ? commitMap.get(headHash) : null;
+    const headTree = treeEntriesOf(head);
+    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);
+    }
+    return diffTrees(
+        gentPath,
+        headTree,
+        [...overlay].map(([name, hash]) => ({ name, hash }))
+    );
+}
+
+module.exports = review;

package/src/commands/search.js

@@ -0,0 +1,77 @@
+/**
+ * Search Command - Fuzzy-search your repositories on the gent backend.
+ *
+ *   gent search <query>
+ *   gent search --mine                   → only repos you own
+ *   gent search --json                   → machine-readable output
+ *
+ * The current backend's /api/repos/ endpoint returns the user's repos; we
+ * filter client-side. If the backend grows a search endpoint, switch the URL.
+ */
+
+const chalk = require('chalk');
+const ora = require('ora');
+const { API_ENDPOINTS } = require('../utils/constants');
+const apiClient = require('../utils/api-client');
+const authStorage = require('../utils/auth-storage');
+
+async function search(query, options = {}) {
+    try {
+        if (!query && !options.mine) {
+            console.error(chalk.red('Usage: gent search <query>'));
+            process.exit(1);
+        }
+
+        const isAuth = await authStorage.isAuthenticated();
+        if (!isAuth) {
+            console.error(chalk.red('Not authenticated.'));
+            console.log(chalk.yellow('Run `gent login` first.'));
+            process.exit(1);
+        }
+
+        const spinner = ora('Searching...').start();
+        const data = await apiClient.get(API_ENDPOINTS.REPOS);
+        const repos = Array.isArray(data) ? data : (data.results || []);
+        spinner.stop();
+
+        const me = await authStorage.getUser();
+        const myId = me?.id;
+
+        const q = (query || '').toLowerCase();
+        const filtered = repos.filter(r => {
+            if (options.mine && myId && r.owner_id !== myId) return false;
+            if (!q) return true;
+            const haystack = [r.name, r.description, r.owner_name, r.owner_email]
+                .filter(Boolean).join(' ').toLowerCase();
+            return haystack.includes(q);
+        });
+
+        if (options.json) {
+            console.log(JSON.stringify(filtered, null, 2));
+            return;
+        }
+
+        if (filtered.length === 0) {
+            console.log(chalk.gray('No matches.'));
+            return;
+        }
+
+        console.log(chalk.bold.cyan(`\nFound ${filtered.length} repo(s):\n`));
+        for (const r of filtered) {
+            const visibility = r.is_private ? chalk.red('private') : chalk.green('public');
+            const desc = r.description ? chalk.gray(` — ${r.description}`) : '';
+            console.log(`  ${chalk.white.bold(r.name)} [${visibility}]${desc}`);
+            console.log(`    ${chalk.gray(`/api/repos/${r.owner_id}/${r.name}`)}`);
+        }
+        console.log();
+    } catch (error) {
+        if (error.response?.status === 401) {
+            console.error(chalk.red('Authentication failed — run `gent login`.'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = search;