gent-cli 2.1.0 → 5.0.1

package/src/commands/stash.js

@@ -0,0 +1,255 @@
+/**
+ * ============================================================================
+ * Stash Command - Temporarily shelve working tree changes
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Save uncommitted changes on a stack so you can switch branches cleanly,
+ *   then restore them later. Like `git stash`.
+ *
+ * USAGE:
+ *   gent stash                 → Stash all modified tracked files
+ *   gent stash pop             → Restore most recent stash and remove it
+ *   gent stash list            → List all stashed entries
+ *   gent stash drop [index]    → Drop a specific stash entry
+ *   gent stash apply [index]   → Apply stash without removing it
+ *
+ * ALGORITHM:
+ *   Saved as JSON stack in .gent/stash.json. Each entry stores:
+ *   - Snapshot of staged entries (staging.entries)
+ *   - Blob hashes of modified working tree files
+ *   After stashing, staging is cleared and files are restored to HEAD state.
+ *
+ * BACKEND EXPECTATIONS:
+ *   Stash is local only. Backend does not need stash support.
+ *
+ * ============================================================================
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { getGentPath, readJSON, writeJSON, pathExists, getAllFiles, getIgnorePatterns } = require('../utils/fileSystem');
+const { STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+const { storeBlob, readBlobAsString, hashBlob } = require('../utils/hash-engine');
+
+const STASH_FILE = 'stash.json';
+
+/**
+ * Stash management
+ * @param {String} subcommand - pop|list|drop|apply (null = stash push)
+ * @param {Object} options
+ */
+async function stash(subcommand, options) {
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+
+        switch (subcommand) {
+            case 'pop':
+                await stashPop(gentPath, cwd, options);
+                break;
+            case 'list':
+                await stashList(gentPath);
+                break;
+            case 'drop':
+                await stashDrop(gentPath, options);
+                break;
+            case 'apply':
+                await stashApply(gentPath, cwd, options, false);
+                break;
+            default:
+                await stashPush(gentPath, cwd, options);
+                break;
+        }
+    } 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);
+    }
+}
+
+/**
+ * Push current changes onto stash stack
+ */
+async function stashPush(gentPath, cwd, options) {
+    const spinner = ora('Stashing changes...').start();
+
+    const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+    const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+    const headHash = repository.branches[repository.currentBranch] || null;
+    const headCommit = headHash ? (repository.commits || []).find(c => c.hash === headHash) : null;
+
+    // Get HEAD tree
+    const headTree = new Map();
+    if (headCommit) {
+        const tree = headCommit.tree || headCommit.files || [];
+        for (const f of tree) headTree.set(f.path || f.name, f.hash);
+    }
+
+    // Collect modified working tree files
+    const ignorePatterns = await getIgnorePatterns(cwd);
+    const allFiles = await getAllFiles(cwd, ignorePatterns);
+    const workingChanges = [];
+
+    for (const absPath of allFiles) {
+        const relPath = path.relative(cwd, absPath);
+        const content = await fs.readFile(absPath, 'utf-8');
+        const currentHash = hashBlob(content);
+        const headBlobHash = headTree.get(relPath);
+
+        if (headBlobHash && currentHash !== headBlobHash) {
+            const blobHash = await storeBlob(gentPath, content);
+            workingChanges.push({ path: relPath, hash: blobHash });
+        }
+    }
+
+    const stagedEntries = staging.entries || [];
+
+    if (workingChanges.length === 0 && stagedEntries.length === 0) {
+        spinner.info(chalk.yellow('No local changes to stash'));
+        return;
+    }
+
+    // Save stash entry
+    const stashes = await readStashes(gentPath);
+    stashes.unshift({
+        message: options.message || `WIP on ${repository.currentBranch}`,
+        branch: repository.currentBranch,
+        timestamp: new Date().toISOString(),
+        stagedEntries: stagedEntries,
+        workingChanges: workingChanges
+    });
+    await writeStashes(gentPath, stashes);
+
+    // Clear staging
+    staging.entries = [];
+    staging.files = [];
+    await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+
+    // Restore working tree to HEAD state
+    for (const change of workingChanges) {
+        const headBlobHash = headTree.get(change.path);
+        if (headBlobHash) {
+            try {
+                const content = await readBlobAsString(gentPath, headBlobHash);
+                await fs.writeFile(path.join(cwd, change.path), content, 'utf-8');
+            } catch { /* best effort */ }
+        }
+    }
+
+    spinner.succeed(chalk.green(`Stashed ${stagedEntries.length} staged + ${workingChanges.length} working tree changes`));
+}
+
+/**
+ * Pop: apply and remove most recent stash
+ */
+async function stashPop(gentPath, cwd, options) {
+    await stashApply(gentPath, cwd, options, true);
+}
+
+/**
+ * Apply stash entry to working tree
+ */
+async function stashApply(gentPath, cwd, options, removAfter) {
+    const index = options.index ? parseInt(options.index) : 0;
+    const stashes = await readStashes(gentPath);
+
+    if (stashes.length === 0) {
+        console.log(chalk.yellow('No stash entries'));
+        return;
+    }
+
+    if (index >= stashes.length) {
+        console.error(chalk.red(`stash@{${index}} does not exist`));
+        return;
+    }
+
+    const entry = stashes[index];
+
+    // Restore working tree changes
+    for (const change of (entry.workingChanges || [])) {
+        try {
+            const content = await readBlobAsString(gentPath, change.hash);
+            const fullPath = path.join(cwd, change.path);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, content, 'utf-8');
+        } catch { /* blob missing */ }
+    }
+
+    // Restore staged entries
+    if (entry.stagedEntries && entry.stagedEntries.length > 0) {
+        const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+        staging.entries = entry.stagedEntries;
+        staging.files = entry.stagedEntries.map(e => e.path);
+        await writeJSON(path.join(gentPath, STAGING_FILE), staging);
+    }
+
+    if (removAfter) {
+        stashes.splice(index, 1);
+        await writeStashes(gentPath, stashes);
+    }
+
+    console.log(chalk.green(`Applied stash@{${index}}: ${entry.message}`));
+}
+
+/**
+ * List stash entries
+ */
+async function stashList(gentPath) {
+    const stashes = await readStashes(gentPath);
+
+    if (stashes.length === 0) {
+        console.log(chalk.gray('No stash entries'));
+        return;
+    }
+
+    stashes.forEach((entry, i) => {
+        const ts = new Date(entry.timestamp).toLocaleString();
+        console.log(
+            chalk.yellow(`stash@{${i}}: `) +
+            chalk.white(entry.message) +
+            chalk.gray(` (${entry.branch}, ${ts})`)
+        );
+    });
+}
+
+/**
+ * Drop stash entry
+ */
+async function stashDrop(gentPath, options) {
+    const index = options.index ? parseInt(options.index) : 0;
+    const stashes = await readStashes(gentPath);
+
+    if (index >= stashes.length) {
+        console.error(chalk.red(`stash@{${index}} does not exist`));
+        return;
+    }
+
+    const removed = stashes.splice(index, 1);
+    await writeStashes(gentPath, stashes);
+    console.log(chalk.green(`Dropped stash@{${index}}: ${removed[0].message}`));
+}
+
+/**
+ * Read stash stack from disk
+ */
+async function readStashes(gentPath) {
+    const stashPath = path.join(gentPath, STASH_FILE);
+    if (!await pathExists(stashPath)) return [];
+    const data = await readJSON(stashPath);
+    return data.stashes || [];
+}
+
+/**
+ * Write stash stack to disk
+ */
+async function writeStashes(gentPath, stashes) {
+    await writeJSON(path.join(gentPath, STASH_FILE), { stashes });
+}
+
+module.exports = stash;

package/src/commands/status.js

@@ -1,14 +1,33 @@
 /**
- * Status Command - Show the working tree status
- * Displays staged, modified, and untracked files
+ * ============================================================================
+ * Status Command - Show working tree status
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Display staged, modified, untracked, and deleted files. Like `git status`.
+ *
+ * USAGE:
+ *   gent status                → Detailed status
+ *   gent status -s             → Short format
+ *
+ * ALGORITHM:
+ *   Computes SHA-256 blob hash for each working file, compares against:
+ *   - Staging entries (from gent add)
+ *   - Last commit tree (from commits.json)
+ *   Classifies files as staged/modified/untracked/deleted.
+ *
+ * BACKEND EXPECTATIONS:
+ *   None (local only).
+ *
+ * ============================================================================
  */
 
 const fs = require('fs').promises;
 const path = require('path');
 const chalk = require('chalk');
-const { getGentPath, readJSON, pathExists, getTrackedFiles, getIgnorePatterns } = require('../utils/fileSystem');
+const { getGentPath, readJSON, pathExists, getIgnorePatterns, getAllFiles } = require('../utils/fileSystem');
 const { STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
-const { getFileHash, getAllFiles } = require('../utils/helpers');
+const { hashBlob } = require('../utils/hash-engine');
 
 /**
  * Show repository status
@@ -19,59 +38,66 @@ async function status(options) {
         const gentPath = await getGentPath();
         const cwd = process.cwd();
 
-        // Read staging area and commits
         const staging = await readJSON(path.join(gentPath, STAGING_FILE));
         const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
 
-        const stagedFiles = staging.files || [];
+        const stagedEntries = staging.entries || [];
+        const stagedFiles = stagedEntries.map(e => e.path);
         const currentBranch = repository.currentBranch || 'main';
-        const lastCommit = repository.branches[currentBranch];
+        const lastCommitHash = repository.branches[currentBranch];
+
+        // Build HEAD tree map: path → blobHash
+        const lastCommit = lastCommitHash
+            ? (repository.commits || []).find(c => c.hash === lastCommitHash)
+            : null;
+        const trackedMap = new Map();
+        if (lastCommit) {
+            const tree = lastCommit.tree || lastCommit.files || [];
+            for (const f of tree) trackedMap.set(f.path || f.name, f.hash);
+        }
 
-        // Get all files in the working directory
+        // Get all working directory files
         const ignorePatterns = await getIgnorePatterns(cwd);
         const allFiles = await getAllFiles(cwd, ignorePatterns);
 
-        // Get tracked files from last commit
-        const trackedFiles = await getTrackedFiles(gentPath, lastCommit);
-
-        // Categorize files
         const stagedSet = new Set(stagedFiles);
-        const trackedSet = new Set(trackedFiles.map(f => f.path));
-
         const modified = [];
         const untracked = [];
         const deleted = [];
 
-        // Check for modifications and untracked files
-        for (const file of allFiles) {
-            const relativePath = path.relative(cwd, file);
-
-            if (trackedSet.has(relativePath)) {
-                // Check if modified
-                const currentHash = await getFileHash(file);
-                const trackedFile = trackedFiles.find(f => f.path === relativePath);
-
-                if (trackedFile && currentHash !== trackedFile.hash && !stagedSet.has(relativePath)) {
-                    modified.push(relativePath);
+        // Check working tree against HEAD
+        for (const absFile of allFiles) {
+            const relPath = path.relative(cwd, absFile);
+            const headHash = trackedMap.get(relPath);
+
+            if (headHash) {
+                // Tracked file — check modification via blob hash
+                const content = await fs.readFile(absFile);
+                const currentHash = hashBlob(content);
+                if (currentHash !== headHash && !stagedSet.has(relPath)) {
+                    modified.push(relPath);
                 }
-            } else if (!stagedSet.has(relativePath)) {
-                untracked.push(relativePath);
+            } else if (!stagedSet.has(relPath)) {
+                untracked.push(relPath);
             }
         }
 
         // Check for deleted files
-        for (const trackedFile of trackedFiles) {
-            const fullPath = path.join(cwd, trackedFile.path);
-            if (!await pathExists(fullPath) && !stagedSet.has(trackedFile.path)) {
-                deleted.push(trackedFile.path);
+        for (const [trackedPath] of trackedMap) {
+            const fullPath = path.join(cwd, trackedPath);
+            if (!await pathExists(fullPath) && !stagedSet.has(trackedPath)) {
+                deleted.push(trackedPath);
             }
         }
 
-        // Display status
+        // Check for merge in progress
+        const mergeState = staging.mergeState || null;
+
+        // Display
         if (options.short) {
-            displayShortStatus(stagedFiles, modified, untracked, deleted);
+            displayShortStatus(stagedEntries, modified, untracked, deleted);
         } else {
-            displayDetailedStatus(currentBranch, stagedFiles, modified, untracked, deleted, lastCommit);
+            displayDetailedStatus(currentBranch, stagedEntries, modified, untracked, deleted, lastCommitHash, mergeState);
         }
 
     } catch (error) {
@@ -88,9 +114,13 @@ async function status(options) {
 /**
  * Display detailed status output
  */
-function displayDetailedStatus(branch, staged, modified, untracked, deleted, lastCommit) {
+function displayDetailedStatus(branch, stagedEntries, modified, untracked, deleted, lastCommit, mergeState) {
     console.log(chalk.bold(`On branch ${chalk.cyan(branch)}`));
 
+    if (mergeState) {
+        console.log(chalk.yellow(`Merging branch '${mergeState.sourceBranch}'`));
+    }
+
     if (!lastCommit) {
         console.log(chalk.gray('No commits yet\n'));
     } else {
@@ -98,12 +128,15 @@ function displayDetailedStatus(branch, staged, modified, untracked, deleted, las
     }
 
     // Staged files
-    if (staged.length > 0) {
+    if (stagedEntries.length > 0) {
         console.log(chalk.green.bold('Changes to be committed:'));
         console.log(chalk.gray('  (use "gent reset <file>..." to unstage)\n'));
-        staged.forEach(file => {
-            console.log(chalk.green(`\t${file}`));
-        });
+        for (const entry of stagedEntries) {
+            const icon = entry.status === 'added' ? 'new file:  '
+                : entry.status === 'deleted' ? 'deleted:   '
+                    : 'modified:  ';
+            console.log(chalk.green(`\t${icon}${entry.path}`));
+        }
         console.log();
     }
 
@@ -136,9 +169,9 @@ function displayDetailedStatus(branch, staged, modified, untracked, deleted, las
     }
 
     // Status summary
-    if (staged.length === 0 && modified.length === 0 && untracked.length === 0 && deleted.length === 0) {
-        console.log(chalk.green('✓ Working tree clean'));
-    } else if (staged.length === 0) {
+    if (stagedEntries.length === 0 && modified.length === 0 && untracked.length === 0 && deleted.length === 0) {
+        console.log(chalk.green('Working tree clean'));
+    } else if (stagedEntries.length === 0) {
         console.log(chalk.yellow('No changes added to commit (use "gent add" to track files)'));
     }
 }
@@ -146,10 +179,11 @@ function displayDetailedStatus(branch, staged, modified, untracked, deleted, las
 /**
  * Display short status output
  */
-function displayShortStatus(staged, modified, untracked, deleted) {
-    staged.forEach(file => {
-        console.log(chalk.green('A  ') + file);
-    });
+function displayShortStatus(stagedEntries, modified, untracked, deleted) {
+    for (const entry of stagedEntries) {
+        const code = entry.status === 'added' ? 'A ' : entry.status === 'deleted' ? 'D ' : 'M ';
+        console.log(chalk.green(code) + entry.path);
+    }
 
     modified.forEach(file => {
         console.log(chalk.red(' M ') + file);

package/src/commands/tag.js

@@ -0,0 +1,146 @@
+/**
+ * ============================================================================
+ * Tag Command - Create, list, and delete named references to commits
+ * ============================================================================
+ *
+ * PURPOSE:
+ *   Mark specific commits with version labels (e.g. v1.0.0). Like `git tag`.
+ *
+ * USAGE:
+ *   gent tag                   → List all tags
+ *   gent tag <name>            → Create lightweight tag on HEAD
+ *   gent tag <name> -m <msg>   → Create annotated tag with message
+ *   gent tag -d <name>         → Delete a tag
+ *
+ * ALGORITHM:
+ *   Tags stored in commits.json under "tags" map: { name → { hash, message, ... } }
+ *   Lightweight tag = just a name pointing to commit hash.
+ *   Annotated tag = includes tagger info, message, timestamp.
+ *
+ * BACKEND EXPECTATIONS:
+ *   POST /api/repos/:id/tags/ { name, hash, message, annotated }
+ *   GET  /api/repos/:id/tags/
+ *   DELETE /api/repos/:id/tags/:name/
+ *
+ * ============================================================================
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const authStorage = require('../utils/auth-storage');
+
+/**
+ * Manage tags
+ * @param {String} name - Tag name (optional)
+ * @param {Object} options
+ */
+async function tag(name, options) {
+    try {
+        const gentPath = await getGentPath();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+        repository.tags = repository.tags || {};
+
+        if (options.delete) {
+            await deleteTag(options.delete, repository, gentPath);
+            return;
+        }
+
+        if (name) {
+            await createTag(name, repository, gentPath, options);
+            return;
+        }
+
+        // List tags
+        listTags(repository);
+
+    } 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);
+    }
+}
+
+/**
+ * List all tags
+ */
+function listTags(repository) {
+    const tags = Object.keys(repository.tags).sort();
+
+    if (tags.length === 0) {
+        console.log(chalk.gray('No tags'));
+        return;
+    }
+
+    for (const tagName of tags) {
+        const t = repository.tags[tagName];
+        const short = t.hash ? t.hash.substring(0, 7) : '???????';
+        const msg = t.message ? chalk.gray(` — ${t.message}`) : '';
+        console.log(chalk.yellow(tagName) + chalk.gray(` → ${short}`) + msg);
+    }
+}
+
+/**
+ * Create a tag
+ */
+async function createTag(name, repository, gentPath, options) {
+    if (repository.tags[name]) {
+        console.error(chalk.red(`Tag '${name}' already exists`));
+        process.exit(1);
+    }
+
+    const currentBranch = repository.currentBranch;
+    const commitHash = repository.branches[currentBranch];
+
+    if (!commitHash) {
+        console.error(chalk.red('No commits to tag'));
+        return;
+    }
+
+    const tagObj = { hash: commitHash };
+
+    // Annotated tag
+    if (options.message) {
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        let taggerName = config.user.name;
+        let taggerEmail = config.user.email;
+
+        if (!taggerName || !taggerEmail) {
+            const user = await authStorage.getUser();
+            if (user) {
+                taggerName = taggerName || [user.first_name, user.last_name].filter(Boolean).join(' ');
+                taggerEmail = taggerEmail || user.email;
+            }
+        }
+
+        tagObj.message = options.message;
+        tagObj.annotated = true;
+        tagObj.tagger = { name: taggerName || 'Unknown', email: taggerEmail || '' };
+        tagObj.timestamp = new Date().toISOString();
+    }
+
+    repository.tags[name] = tagObj;
+    await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+    console.log(chalk.green(`Created tag '${name}' → ${commitHash.substring(0, 7)}`));
+}
+
+/**
+ * Delete a tag
+ */
+async function deleteTag(name, repository, gentPath) {
+    if (!repository.tags[name]) {
+        console.error(chalk.red(`Tag '${name}' not found`));
+        process.exit(1);
+    }
+
+    delete repository.tags[name];
+    await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+    console.log(chalk.green(`Deleted tag '${name}'`));
+}
+
+module.exports = tag;