gent-cli 2.0.0 → 5.0.0

package/src/commands/commit.js

@@ -1,18 +1,17 @@
 /**
  * Commit Command - Record changes to the repository
- * Creates a new commit with staged files
+ * Creates a new commit with tree object referencing staged blobs
  */
 
 const path = require('path');
-const fs = require('fs').promises;
 const chalk = require('chalk');
 const inquirer = require('inquirer');
 const ora = require('ora');
-const { getGentPath, readJSON, writeJSON, saveBlob, getBlob } = require('../utils/fileSystem');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
 const authStorage = require('../utils/auth-storage');
 const { STAGING_FILE, COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
-const { generateCommitHash, getFileHash } = require('../utils/helpers');
-const { computeDiff } = require('../utils/diff');
+const { generateCommitHash } = require('../utils/helpers');
+const { storeTree, snapshotFile } = require('../utils/hash-engine');
 
 /**
  * Create a new commit
@@ -25,9 +24,10 @@ async function commit(options) {
 
         // Read staging area
         const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+        const stagedEntries = staging.entries || [];
         const stagedFiles = staging.files || [];
 
-        if (stagedFiles.length === 0) {
+        if (stagedEntries.length === 0 && stagedFiles.length === 0) {
             console.log(chalk.yellow('No changes added to commit'));
             console.log(chalk.gray('Use "gent add <file>..." to stage files'));
             return;
@@ -59,20 +59,14 @@ async function commit(options) {
         let authorName = config.user.name;
         let authorEmail = config.user.email;
 
-        // Fallback to global auth if local config is empty
         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;
-                }
+                if (!authorName) authorName = [globalUser.first_name, globalUser.last_name].filter(Boolean).join(' ');
+                if (!authorEmail) authorEmail = globalUser.email;
             }
         }
 
-        // Fail if still no identity
         if (!authorName || !authorEmail) {
             spinner.stop();
             console.error(chalk.red('Author identity unknown'));
@@ -80,92 +74,106 @@ async function commit(options) {
             return;
         }
 
-        // Create commit object
-        const commit = {
-            sha: generateCommitHash(),
-            message: message,
-            author: {
-                name: authorName,
-                email: authorEmail
-            },
-            timestamp: new Date().toISOString(),
-            parent: repository.branches[repository.currentBranch] ? [repository.branches[repository.currentBranch]] : [],
-            files: []
-        };
+        // Build tree entries from staged data
+        let treeEntries = [];
+
+        if (stagedEntries.length > 0) {
+            // New format: entries already have blob hashes from gent add
+            // Carry forward unchanged files from parent commit
+            const parentHash = repository.branches[repository.currentBranch] || null;
+            const parentCommit = parentHash
+                ? (repository.commits || []).find(c => c.hash === parentHash)
+                : null;
+            const parentTree = parentCommit && parentCommit.tree
+                ? parentCommit.tree
+                : (parentCommit ? parentCommit.files.map(f => ({ mode: '100644', name: f.path, hash: f.hash, type: 'blob' })) : []);
+
+            // Start from parent tree, overlay staged changes
+            const treeMap = new Map(parentTree.map(e => [e.name, e]));
+
+            for (const entry of stagedEntries) {
+                if (entry.status === 'deleted') {
+                    treeMap.delete(entry.path);
+                } else {
+                    treeMap.set(entry.path, {
+                        mode: '100644',
+                        name: entry.path,
+                        hash: entry.hash,
+                        type: 'blob'
+                    });
+                }
+            }
 
-        // Create a map of parent files for quick lookup
-        const parentFilesMap = new Map();
-        if (commit.parent && commit.parent.length > 0) {
-            const parentSha = commit.parent[0];
-            const parentCommit = repository.commits.find(c => c.sha === parentSha);
-            if (parentCommit) {
-                parentCommit.files.forEach(f => parentFilesMap.set(f.path, f.hash));
+            treeEntries = Array.from(treeMap.values());
+        } else {
+            // Legacy fallback: files array without blob hashes
+            for (const file of stagedFiles) {
+                const entry = await snapshotFile(gentPath, cwd, file);
+                treeEntries.push(entry);
             }
         }
 
-        // Hash staged files and compute diffs
-        for (const file of stagedFiles) {
-            const filePath = path.join(cwd, file);
-            let content;
-
-            try {
-                content = await fs.readFile(filePath, 'utf-8');
-            } catch (err) {
-                // If file is deleted or unreadable, we handle it as empty content or handle deletion if we supported it
-                // For now assuming staged files exist
-                content = '';
+        // Store tree object
+        const treeHash = await storeTree(gentPath, treeEntries);
+
+        // Compute diff stats
+        let totalInsertions = 0;
+        let totalDeletions = 0;
+        if (stagedEntries.length > 0) {
+            for (const e of stagedEntries) {
+                if (e.stats) {
+                    totalInsertions += e.stats.insertions || 0;
+                    totalDeletions += e.stats.deletions || 0;
+                }
             }
+        }
 
-            const hash = await getFileHash(filePath);
-
-            // Save the blob for future diffs
-            await saveBlob(content, hash);
-
-            // Get previous content
-            let oldContent = '';
-            if (parentFilesMap.has(file)) {
-                const oldHash = parentFilesMap.get(file);
-                oldContent = await getBlob(oldHash);
+        // Create commit object
+        const commitObj = {
+            hash: generateCommitHash(),
+            message,
+            author: {
+                name: authorName,
+                email: authorEmail
+            },
+            timestamp: new Date().toISOString(),
+            parent: repository.branches[repository.currentBranch] || null,
+            treeHash,
+            tree: treeEntries,
+            files: treeEntries.map(e => ({ path: e.name, hash: e.hash })), // backward compat
+            stats: {
+                filesChanged: stagedEntries.length || stagedFiles.length,
+                insertions: totalInsertions,
+                deletions: totalDeletions
             }
+        };
 
-            // Compute Myers diff
-            const changes = computeDiff(oldContent, content);
-
-            commit.files.push({
-                path: file,
-                hash: hash,
-                diff: changes
-            });
-        }
-
-        // Add commit to repository
+        // Save commit
         repository.commits = repository.commits || [];
-        repository.commits.push(commit);
-        repository.branches[repository.currentBranch] = commit.sha;
+        repository.commits.push(commitObj);
+        repository.branches[repository.currentBranch] = commitObj.hash;
 
-        // Save repository and clear staging
         await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+        // Clear staging
+        staging.entries = [];
         staging.files = [];
         await writeJSON(path.join(gentPath, STAGING_FILE), staging);
 
-        spinner.succeed(chalk.green('✓ Changes committed successfully!'));
-
-        // Display commit info
-        console.log(chalk.cyan(`\n[${repository.currentBranch} ${commit.sha.substring(0, 7)}] ${message}`));
-        console.log(chalk.gray(`Author: ${commit.author.name} <${commit.author.email}>`));
-        console.log(chalk.gray(`Date: ${new Date(commit.timestamp).toLocaleString()}`));
-        console.log(chalk.gray(`\n${commit.files.length} file(s) changed`));
+        spinner.succeed(chalk.green('Changes committed successfully!'));
 
-        // Handle --push option
-        if (options.push) {
-            const push = require('./push');
-            await push('origin', repository.currentBranch, {});
-        }
+        console.log(chalk.cyan(`\n[${repository.currentBranch} ${commitObj.hash.substring(0, 7)}] ${message}`));
+        console.log(chalk.gray(`Author: ${commitObj.author.name} <${commitObj.author.email}>`));
+        console.log(chalk.gray(`Date: ${new Date(commitObj.timestamp).toLocaleString()}`));
+        console.log(chalk.gray(`Tree: ${treeHash.substring(0, 7)}`));
+        console.log(chalk.gray(`\n${commitObj.stats.filesChanged} file(s) changed, `) +
+            chalk.green(`+${totalInsertions} insertions`) + ', ' +
+            chalk.red(`-${totalDeletions} deletions`));
 
     } catch (error) {
         if (error.code === 'ENOENT' && error.message.includes('.gent')) {
             console.error(chalk.red('Error: Not a gent repository'));
-            console.log(chalk.yellow('\nℹ Run "gent init" to initialize a repository'));
+            console.log(chalk.yellow('\nRun "gent init" to initialize a repository'));
         } else {
             console.error(chalk.red('Error:'), error.message);
         }

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 })})`);