gent-cli 2.1.0 → 5.0.1

package/src/commands/diff.js

@@ -0,0 +1,257 @@
+/**
+ * ============================================================================
+ * Diff Command - Show changes between commits, staging, and working tree
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Display line-by-line differences between file versions, similar to
+ *   `git diff`. Shows what changed, where, and how much.
+ *
+ * USAGE:
+ *   gent diff                  → Working tree vs staging area
+ *   gent diff --staged         → Staging area vs last commit
+ *   gent diff <file>           → Diff specific file(s)
+ *   gent diff --stat           → Summary only (no patch)
+ *
+ * ALGORITHM:
+ *   Uses LCS (Longest Common Subsequence) line-level diff from diff-engine.js.
+ *   Outputs unified diff format with context lines (3 by default).
+ *   Time complexity: O(m*n) where m,n = line counts of old/new files.
+ *
+ * BACKEND EXPECTATIONS:
+ *   None (local only). Backend receives final blob hashes, not diffs.
+ *
+ * ============================================================================
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const { getGentPath, readJSON, pathExists, getAllFiles, getIgnorePatterns } = require('../utils/fileSystem');
+const { STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+const { readBlobAsString, hashBlob } = require('../utils/hash-engine');
+const { formatUnifiedDiff, diffText } = require('../utils/diff-engine');
+
+/**
+ * Show differences
+ * @param {Array} files - Optional specific files to diff
+ * @param {Object} options - Command options
+ */
+async function diff(files, options) {
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+
+        const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+
+        const currentBranch = repository.currentBranch || 'main';
+        const headHash = repository.branches[currentBranch] || null;
+        const headCommit = headHash
+            ? (repository.commits || []).find(c => c.hash === headHash)
+            : null;
+
+        // Build HEAD tree map: path → blobHash
+        const headTree = buildTreeMap(headCommit);
+
+        // Build staging map: path → blobHash
+        const stagingEntries = staging.entries || [];
+        const stagingMap = new Map(stagingEntries.map(e => [e.path, e.hash]));
+
+        if (options.staged) {
+            // Staged vs HEAD
+            await diffStagedVsHead(gentPath, cwd, stagingEntries, headTree, files, options);
+        } else {
+            // Working tree vs staged (or HEAD if not staged)
+            await diffWorkingTree(gentPath, cwd, stagingMap, headTree, files, options);
+        }
+
+    } catch (error) {
+        if (error.code === 'ENOENT' && error.message.includes('.gent')) {
+            console.error(chalk.red('Error: Not a gent repository'));
+            console.log(chalk.yellow('Run "gent init" to initialize a repository'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * Diff working tree vs staging/HEAD
+ */
+async function diffWorkingTree(gentPath, cwd, stagingMap, headTree, filterFiles, options) {
+    const ignorePatterns = await getIgnorePatterns(cwd);
+    const allFiles = await getAllFiles(cwd, ignorePatterns);
+    let hasDiffs = false;
+
+    let totalInsertions = 0;
+    let totalDeletions = 0;
+    const fileSummaries = [];
+
+    for (const absPath of allFiles) {
+        const relPath = path.relative(cwd, absPath);
+
+        // Filter if specific files provided
+        if (filterFiles && filterFiles.length > 0 && !filterFiles.includes(relPath)) continue;
+
+        // Determine base hash (staging → HEAD fallback)
+        const baseHash = stagingMap.get(relPath) || headTree.get(relPath);
+        if (!baseHash) continue; // untracked
+
+        const currentContent = await fs.readFile(absPath, 'utf-8');
+        const currentHash = hashBlob(currentContent);
+
+        if (currentHash === baseHash) continue; // unchanged
+
+        let oldContent = '';
+        try {
+            oldContent = await readBlobAsString(gentPath, baseHash);
+        } catch {
+            // No blob = new file
+        }
+
+        const d = diffText(oldContent, currentContent);
+        totalInsertions += d.stats.insertions;
+        totalDeletions += d.stats.deletions;
+        fileSummaries.push({ file: relPath, stats: d.stats });
+
+        if (!options.stat) {
+            const unified = formatUnifiedDiff(relPath, oldContent, currentContent);
+            if (unified) {
+                hasDiffs = true;
+                printColorizedDiff(unified);
+            }
+        } else {
+            hasDiffs = true;
+        }
+    }
+
+    if (options.stat || hasDiffs) {
+        printDiffStat(fileSummaries, totalInsertions, totalDeletions);
+    }
+
+    if (!hasDiffs) {
+        console.log(chalk.gray('No changes'));
+    }
+}
+
+/**
+ * Diff staged files vs HEAD commit
+ */
+async function diffStagedVsHead(gentPath, cwd, stagedEntries, headTree, filterFiles, options) {
+    let hasDiffs = false;
+    let totalInsertions = 0;
+    let totalDeletions = 0;
+    const fileSummaries = [];
+
+    for (const entry of stagedEntries) {
+        if (filterFiles && filterFiles.length > 0 && !filterFiles.includes(entry.path)) continue;
+
+        const headBlobHash = headTree.get(entry.path);
+
+        if (entry.status === 'deleted') {
+            if (headBlobHash) {
+                const oldContent = await readBlobAsString(gentPath, headBlobHash);
+                const d = diffText(oldContent, '');
+                totalDeletions += d.stats.deletions;
+                fileSummaries.push({ file: entry.path, stats: d.stats });
+                if (!options.stat) {
+                    printColorizedDiff(formatUnifiedDiff(entry.path, oldContent, ''));
+                }
+                hasDiffs = true;
+            }
+            continue;
+        }
+
+        if (!entry.hash) continue;
+
+        if (entry.hash === headBlobHash) continue; // unchanged
+
+        let oldContent = '';
+        try {
+            if (headBlobHash) oldContent = await readBlobAsString(gentPath, headBlobHash);
+        } catch { /* new file */ }
+
+        const newContent = await readBlobAsString(gentPath, entry.hash);
+        const d = diffText(oldContent, newContent);
+        totalInsertions += d.stats.insertions;
+        totalDeletions += d.stats.deletions;
+        fileSummaries.push({ file: entry.path, stats: d.stats });
+
+        if (!options.stat) {
+            const unified = formatUnifiedDiff(entry.path, oldContent, newContent);
+            if (unified) {
+                hasDiffs = true;
+                printColorizedDiff(unified);
+            }
+        } else {
+            hasDiffs = true;
+        }
+    }
+
+    if (options.stat || hasDiffs) {
+        printDiffStat(fileSummaries, totalInsertions, totalDeletions);
+    }
+
+    if (!hasDiffs) {
+        console.log(chalk.gray('No staged changes'));
+    }
+}
+
+/**
+ * Build path → hash map from commit object
+ */
+function buildTreeMap(commit) {
+    const map = new Map();
+    if (!commit) return map;
+    const tree = commit.tree || commit.files || [];
+    for (const f of tree) {
+        map.set(f.path || f.name, f.hash);
+    }
+    return map;
+}
+
+/**
+ * Print colorized unified diff
+ */
+function printColorizedDiff(unifiedDiff) {
+    const lines = unifiedDiff.split('\n');
+    for (const line of lines) {
+        if (line.startsWith('---') || line.startsWith('+++')) {
+            console.log(chalk.bold(line));
+        } else if (line.startsWith('@@')) {
+            console.log(chalk.cyan(line));
+        } else if (line.startsWith('+')) {
+            console.log(chalk.green(line));
+        } else if (line.startsWith('-')) {
+            console.log(chalk.red(line));
+        } else {
+            console.log(line);
+        }
+    }
+    console.log('');
+}
+
+/**
+ * Print diff stat summary
+ */
+function printDiffStat(fileSummaries, totalIns, totalDel) {
+    if (fileSummaries.length === 0) return;
+
+    console.log('');
+    const maxLen = Math.max(...fileSummaries.map(f => f.file.length));
+
+    for (const { file, stats } of fileSummaries) {
+        const total = stats.insertions + stats.deletions;
+        const bar = chalk.green('+'.repeat(Math.min(stats.insertions, 30))) +
+            chalk.red('-'.repeat(Math.min(stats.deletions, 30)));
+        console.log(` ${file.padEnd(maxLen)} | ${String(total).padStart(4)} ${bar}`);
+    }
+
+    console.log(chalk.gray(` ${fileSummaries.length} file(s) changed, `) +
+        chalk.green(`${totalIns} insertion(s)`) + ', ' +
+        chalk.red(`${totalDel} deletion(s)`));
+}
+
+module.exports = diff;

package/src/commands/init.js

@@ -28,10 +28,9 @@ async function init(options) {
         // Get authenticated user profile if available
         let defaultName = '';
         let defaultEmail = '';
-        let user = null;
 
         try {
-            user = await authStorage.getUser();
+            const user = await authStorage.getUser();
             if (user) {
                 if (user.first_name || user.last_name) {
                     defaultName = [user.first_name, user.last_name].filter(Boolean).join(' ');
@@ -63,8 +62,12 @@ async function init(options) {
         await ensureDir(path.join(gentPath, 'refs', 'tags'));
 
         // Create/Update configuration
+        // Only write config if it doesn't exist OR if we have valid user info to update
         const configPath = path.join(gentPath, CONFIG_FILE);
         if (!(await pathExists(configPath)) || (defaultName && defaultEmail)) {
+            // If re-init, we might want to preserve existing config unless we have better info?
+            // Git re-init doesn't overwrite config usually.
+            // But for now, let's write ensuring we have a config file.
             if (!isReinit || !(await pathExists(configPath))) {
                 await writeJSON(configPath, config);
             }
@@ -106,40 +109,6 @@ node_modules/
             console.log(chalk.gray(`Initialized empty Gent repository in ${gentPath}`));
         }
 
-        // Handle --cloud option
-        if (options.cloud) {
-            if (!user) {
-                console.log(chalk.yellow('\nWarning: Skipping cloud repository creation (not logged in)'));
-                console.log(chalk.gray('Run "gent login" then "gent create <name> --init-local"'));
-            } else {
-                try {
-                    const repoService = require('../services/repo-service');
-                    const { addRemote } = require('../utils/cloud-sync');
-                    const ora = require('ora');
-
-                    const spinner = ora('Creating cloud repository...').start();
-                    const repoName = path.basename(cwd);
-
-                    const repository = await repoService.createRepository(
-                        repoName,
-                        options.description || 'A gent repository',
-                        options.private || false,
-                        'main'
-                    );
-
-                    const ownerId = repository.owner_id || repository.owner?.id || repository.owner;
-                    const name = repository.name || repository.project_name || repoName;
-
-                    await addRemote('origin', ownerId, name, cwd);
-                    spinner.succeed(chalk.green(`Created cloud repository: ${ownerId}/${name}`));
-                    console.log(chalk.gray(`Remote 'origin' added`));
-                } catch (error) {
-                    console.log(chalk.red(`\nFailed to create cloud repository: ${error.message}`));
-                    console.log(chalk.gray('You can create it later with "gent create <name>"'));
-                }
-            }
-        }
-
     } catch (error) {
         console.error(chalk.red('Failed to initialize repository'));
         console.error(chalk.red('Error:'), error.message);

package/src/commands/log.js

@@ -1,6 +1,25 @@
 /**
- * Log Command - Show commit logs
- * Displays commit history with details
+ * ============================================================================
+ * Log Command - Show commit history
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Display commit history with details, stats, and merge info. Like `git log`.
+ *
+ * USAGE:
+ *   gent log                   → Show last 10 commits (detailed)
+ *   gent log -n 20             → Show last 20 commits
+ *   gent log --oneline         → Condensed one-line-per-commit view
+ *   gent log --stat            → Include diffstat per commit
+ *
+ * ALGORITHM:
+ *   Reads commits.json, filters by branch HEAD → parent chain, displays
+ *   in reverse chronological order.
+ *
+ * BACKEND EXPECTATIONS:
+ *   GET /api/repos/:id/commits/?branch=main&limit=10
+ *
+ * ============================================================================
  */
 
 const path = require('path');
@@ -27,14 +46,24 @@ async function log(options) {
             return;
         }
 
-        // Limit number of commits to show
         const limit = parseInt(options.number) || 10;
-        const commitsToShow = commits.slice(-limit).reverse();
+
+        // Walk branch chain for ordered display
+        const headHash = repository.branches[currentBranch];
+        const commitMap = new Map(commits.map(c => [c.hash, c]));
+        const ordered = [];
+        let cur = headHash;
+        while (cur && ordered.length < limit) {
+            const c = commitMap.get(cur);
+            if (!c) break;
+            ordered.push(c);
+            cur = c.parent;
+        }
 
         if (options.oneline) {
-            displayOnelineLog(commitsToShow, repository.branches[currentBranch]);
+            displayOnelineLog(ordered, headHash);
         } else {
-            displayDetailedLog(commitsToShow, repository.branches[currentBranch], currentBranch);
+            displayDetailedLog(ordered, headHash, currentBranch, options);
         }
 
     } catch (error) {
@@ -51,21 +80,36 @@ async function log(options) {
 /**
  * Display detailed commit log
  */
-function displayDetailedLog(commits, currentCommitHash, currentBranch) {
-    console.log(chalk.bold.cyan(`\nCommit History (${currentBranch} branch):\n`));
+function displayDetailedLog(commits, currentCommitHash, currentBranch, options) {
+    console.log(chalk.bold.cyan(`\nCommit History (${currentBranch}):\n`));
 
     commits.forEach((commit, index) => {
-        const isHead = commit.sha === currentCommitHash;
+        const isHead = commit.hash === currentCommitHash;
         const headLabel = isHead ? chalk.yellow.bold(' (HEAD)') : '';
 
-        console.log(chalk.yellow(`commit ${commit.sha}`) + headLabel);
+        console.log(chalk.yellow(`commit ${commit.hash}`) + headLabel);
+        if (commit.mergeParent) {
+            console.log(chalk.gray(`Merge: ${commit.parent?.substring(0, 7)} ${commit.mergeParent.substring(0, 7)}`));
+        }
         console.log(chalk.white(`Author: ${commit.author.name} <${commit.author.email}>`));
         console.log(chalk.white(`Date:   ${new Date(commit.timestamp).toLocaleString()}`));
         console.log(chalk.gray(`        (${formatDistanceToNow(new Date(commit.timestamp), { addSuffix: true })})`));
+        if (commit.treeHash) {
+            console.log(chalk.gray(`Tree:   ${commit.treeHash.substring(0, 7)}`));
+        }
         console.log();
         console.log(chalk.white(`    ${commit.message}`));
         console.log();
-        console.log(chalk.gray(`    ${commit.files.length} file(s) changed`));
+
+        // Show stats if --stat flag or if commit has stats
+        if (options && options.stat && commit.stats) {
+            console.log(chalk.gray(`    ${commit.stats.filesChanged} file(s), `) +
+                chalk.green(`+${commit.stats.insertions}`) + ' ' +
+                chalk.red(`-${commit.stats.deletions}`));
+        } else {
+            const fileCount = commit.files ? commit.files.length : (commit.tree ? commit.tree.length : 0);
+            console.log(chalk.gray(`    ${fileCount} file(s) in tree`));
+        }
 
         if (index < commits.length - 1) {
             console.log(chalk.gray('    │'));
@@ -79,9 +123,9 @@ function displayDetailedLog(commits, currentCommitHash, currentBranch) {
  */
 function displayOnelineLog(commits, currentCommitHash) {
     commits.forEach(commit => {
-        const isHead = commit.sha === currentCommitHash;
+        const isHead = commit.hash === currentCommitHash;
         const headLabel = isHead ? chalk.yellow(' (HEAD)') : '';
-        const shortHash = chalk.yellow(commit.sha.substring(0, 7));
+        const shortHash = chalk.yellow(commit.hash.substring(0, 7));
         const message = chalk.white(commit.message);
         const timeAgo = chalk.gray(`(${formatDistanceToNow(new Date(commit.timestamp), { addSuffix: true })})`);
 

package/src/commands/merge.js

@@ -0,0 +1,245 @@
+/**
+ * Merge Command - Merge a branch into the current branch
+ * Uses 3-way smart merge with automatic conflict resolution
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { getGentPath, readJSON, writeJSON, pathExists } = require('../utils/fileSystem');
+const { COMMITS_FILE, STAGING_FILE, CONFIG_FILE } = require('../utils/constants');
+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');
+
+/**
+ * Merge a branch into the current branch
+ * @param {String} sourceBranch - Branch to merge from
+ * @param {Object} options - Command options
+ */
+async function merge(sourceBranch, options) {
+    const spinner = ora(`Merging '${sourceBranch}'...`).start();
+
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        const commits = repository.commits || [];
+        const branches = repository.branches || {};
+        const currentBranch = repository.currentBranch;
+
+        // Validate branches
+        if (!branches.hasOwnProperty(sourceBranch)) {
+            spinner.fail(chalk.red(`Branch '${sourceBranch}' not found`));
+            return;
+        }
+
+        if (sourceBranch === currentBranch) {
+            spinner.fail(chalk.red('Cannot merge a branch into itself'));
+            return;
+        }
+
+        const oursHash = branches[currentBranch];
+        const theirsHash = branches[sourceBranch];
+
+        if (!oursHash) {
+            spinner.fail(chalk.red(`Current branch '${currentBranch}' has no commits`));
+            return;
+        }
+
+        if (!theirsHash) {
+            spinner.fail(chalk.red(`Branch '${sourceBranch}' has no commits`));
+            return;
+        }
+
+        // Fast-forward check: if ours is ancestor of theirs
+        if (oursHash === theirsHash) {
+            spinner.succeed(chalk.green('Already up to date'));
+            return;
+        }
+
+        // Find merge base (common ancestor)
+        const baseHash = findMergeBase(commits, oursHash, theirsHash);
+
+        // Fast-forward: current branch is merge base → just move pointer
+        if (baseHash === oursHash) {
+            spinner.text = 'Fast-forward merge...';
+            repository.branches[currentBranch] = theirsHash;
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+            // Restore working tree from theirs commit
+            const theirsCommit = commits.find(c => c.hash === theirsHash);
+            if (theirsCommit) {
+                await restoreWorkingTree(gentPath, cwd, theirsCommit);
+            }
+
+            spinner.succeed(chalk.green(`Fast-forward merge: ${currentBranch} → ${theirsHash.substring(0, 7)}`));
+            return;
+        }
+
+        // 3-way merge
+        spinner.text = 'Computing 3-way merge...';
+
+        const oursCommit = commits.find(c => c.hash === oursHash);
+        const theirsCommit = commits.find(c => c.hash === theirsHash);
+        const baseCommit = baseHash ? commits.find(c => c.hash === baseHash) : null;
+
+        // Extract tree entries from commits
+        const getTree = (commit) => {
+            if (!commit) return [];
+            if (commit.tree && Array.isArray(commit.tree)) return commit.tree;
+            if (commit.files) return commit.files.map(f => ({
+                mode: '100644', name: f.path || f.name, hash: f.hash, type: 'blob'
+            }));
+            return [];
+        };
+
+        const baseTree = getTree(baseCommit);
+        const oursTree = getTree(oursCommit);
+        const theirsTree = getTree(theirsCommit);
+
+        // Perform tree-level merge
+        const mergeResult = await mergeTreeEntries(gentPath, baseTree, oursTree, theirsTree);
+
+        if (mergeResult.hasConflicts) {
+            spinner.warn(chalk.yellow(`Merged with ${mergeResult.conflicts.length} conflict(s)`));
+            console.log('');
+
+            for (const conflict of mergeResult.conflicts) {
+                if (conflict.type === 'content') {
+                    console.log(chalk.red(`  CONFLICT (content): ${conflict.file}`));
+                    console.log(chalk.gray(`    ${conflict.details.length} conflicting region(s) — markers inserted`));
+                } else if (conflict.type === 'modify-delete') {
+                    console.log(chalk.yellow(`  CONFLICT (modify/delete): ${conflict.file}`));
+                    console.log(chalk.gray(`    Deleted by ${conflict.deletedBy}, modified by ${conflict.modifiedBy} — kept modified version`));
+                } else if (conflict.type === 'add-add') {
+                    console.log(chalk.yellow(`  CONFLICT (add/add): ${conflict.file}`));
+                    console.log(chalk.gray(`    Both branches added differently — markers inserted`));
+                }
+            }
+
+            console.log(chalk.yellow('\nConflict markers: <<<<<<< ours / ======= / >>>>>>> theirs'));
+            console.log(chalk.cyan('Resolve conflicts, then run "gent add" and "gent commit"'));
+        }
+
+        // Store merged tree
+        const mergedTreeHash = await storeTree(gentPath, mergeResult.mergedEntries);
+
+        // Write merged files to working directory
+        await writeTreeToWorkDir(gentPath, cwd, mergeResult.mergedEntries);
+
+        // If no conflicts, create merge commit automatically
+        if (!mergeResult.hasConflicts) {
+            // Resolve author
+            const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+            let authorName = config.user.name;
+            let authorEmail = 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 mergeCommit = {
+                hash: generateCommitHash(),
+                message: options.message || `Merge branch '${sourceBranch}' into ${currentBranch}`,
+                author: {
+                    name: authorName || 'Unknown',
+                    email: authorEmail || 'unknown@gent'
+                },
+                timestamp: new Date().toISOString(),
+                parent: oursHash,
+                mergeParent: theirsHash,
+                treeHash: mergedTreeHash,
+                tree: mergeResult.mergedEntries,
+                files: mergeResult.mergedEntries.map(e => ({ path: e.name, hash: e.hash })),
+                stats: {
+                    filesChanged: mergeResult.mergedEntries.length,
+                    insertions: 0,
+                    deletions: 0
+                }
+            };
+
+            repository.commits.push(mergeCommit);
+            repository.branches[currentBranch] = mergeCommit.hash;
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+            // Clear staging
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+            staging.entries = [];
+            staging.files = [];
+            await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+
+            spinner.succeed(chalk.green(`Merged '${sourceBranch}' into '${currentBranch}' — ${mergeCommit.hash.substring(0, 7)}`));
+
+            const autoResolved = mergeResult.mergedEntries.length;
+            console.log(chalk.gray(`\n  Base: ${baseHash ? baseHash.substring(0, 7) : 'none'}`));
+            console.log(chalk.gray(`  Ours: ${oursHash.substring(0, 7)}  Theirs: ${theirsHash.substring(0, 7)}`));
+            console.log(chalk.green(`  ${autoResolved} file(s) merged automatically`));
+        } else {
+            // Stage the merge state for manual resolution
+            const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+            staging.mergeState = {
+                sourceBranch,
+                oursHash,
+                theirsHash,
+                baseHash,
+                mergedTreeHash,
+                mergedEntries: mergeResult.mergedEntries,
+                conflicts: mergeResult.conflicts
+            };
+            await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+        }
+
+    } catch (error) {
+        spinner.fail(chalk.red('Merge failed'));
+        if (error.code === 'ENOENT' && error.message.includes('.gent')) {
+            console.error(chalk.red('\nError: Not a gent repository'));
+            console.log(chalk.yellow('Run "gent init" to initialize a repository'));
+        } else {
+            console.error(chalk.red('\nError:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * Write tree entries to working directory.
+ * @param {String} gentPath
+ * @param {String} cwd
+ * @param {Array} entries
+ */
+async function writeTreeToWorkDir(gentPath, cwd, entries) {
+    for (const entry of entries) {
+        const fullPath = path.join(cwd, entry.name);
+        await fs.mkdir(path.dirname(fullPath), { recursive: true });
+
+        const content = await readBlobAsString(gentPath, entry.hash);
+        await fs.writeFile(fullPath, content, 'utf-8');
+    }
+}
+
+/**
+ * Restore working tree from a commit's tree entries.
+ * @param {String} gentPath
+ * @param {String} cwd
+ * @param {Object} commit
+ */
+async function restoreWorkingTree(gentPath, cwd, commit) {
+    const tree = commit.tree || (commit.files || []).map(f => ({
+        mode: '100644', name: f.path || f.name, hash: f.hash, type: 'blob'
+    }));
+
+    try {
+        await writeTreeToWorkDir(gentPath, cwd, tree);
+    } catch {
+        // Best-effort restore — blobs may not exist for legacy commits
+    }
+}
+
+module.exports = merge;