gent-cli 1.0.0

package/src/commands/checkout.js

@@ -0,0 +1,74 @@
+/**
+ * Checkout Command - Switch branches
+ * Changes the current working branch
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE } = require('../utils/constants');
+
+/**
+ * Switch to a different branch
+ * @param {String} branch - Branch name
+ * @param {Object} options - Command options
+ */
+async function checkout(branch, options) {
+    try {
+        const gentPath = await getGentPath();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+
+        const branches = repository.branches || {};
+
+        // Create new branch if -b flag is used
+        if (options.create) {
+            if (branches.hasOwnProperty(branch)) {
+                console.error(chalk.red(`Error: Branch '${branch}' already exists`));
+                process.exit(1);
+            }
+
+            // Create and switch to new branch
+            const currentCommit = branches[repository.currentBranch] || null;
+            branches[branch] = currentCommit;
+            repository.branches = branches;
+            repository.currentBranch = branch;
+
+            await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+            console.log(chalk.green(`✓ Created and switched to branch '${branch}'`));
+            return;
+        }
+
+        // Switch to existing branch
+        if (!branches.hasOwnProperty(branch)) {
+            console.error(chalk.red(`Error: Branch '${branch}' not found`));
+            console.log(chalk.yellow(`\nℹ Use "gent branch" to see available branches`));
+            console.log(chalk.yellow(`ℹ Use "gent checkout -b ${branch}" to create a new branch`));
+            process.exit(1);
+        }
+
+        if (branch === repository.currentBranch) {
+            console.log(chalk.yellow(`Already on branch '${branch}'`));
+            return;
+        }
+
+        repository.currentBranch = branch;
+        await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+
+        const commitHash = branches[branch];
+        const commitInfo = commitHash ? chalk.gray(` at ${commitHash.substring(0, 7)}`) : '';
+
+        console.log(chalk.green(`✓ Switched to branch '${branch}'${commitInfo}`));
+
+    } 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'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = checkout;

package/src/commands/commit.js

@@ -0,0 +1,108 @@
+/**
+ * Commit Command - Record changes to the repository
+ * Creates a new commit with staged files
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const { getGentPath, readJSON, writeJSON } = require('../utils/fileSystem');
+const { STAGING_FILE, COMMITS_FILE, CONFIG_FILE } = require('../utils/constants');
+const { generateCommitHash, getFileHash } = require('../utils/helpers');
+
+/**
+ * Create a new commit
+ * @param {Object} options - Command options
+ */
+async function commit(options) {
+    try {
+        const gentPath = await getGentPath();
+        const cwd = process.cwd();
+
+        // Read staging area
+        const staging = await readJSON(path.join(gentPath, STAGING_FILE));
+        const stagedFiles = staging.files || [];
+
+        if (stagedFiles.length === 0) {
+            console.log(chalk.yellow('No changes added to commit'));
+            console.log(chalk.gray('Use "gent add <file>..." to stage files'));
+            return;
+        }
+
+        // Get commit message
+        let message = options.message;
+
+        if (!message) {
+            const answer = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'message',
+                    message: 'Commit message:',
+                    validate: (input) => {
+                        return input.length > 0 || 'Commit message cannot be empty';
+                    }
+                }
+            ]);
+            message = answer.message;
+        }
+
+        const spinner = ora('Creating commit...').start();
+
+        // Read config and repository
+        const config = await readJSON(path.join(gentPath, CONFIG_FILE));
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+
+        // Create commit object
+        const commit = {
+            hash: generateCommitHash(),
+            message: message,
+            author: {
+                name: config.user.name,
+                email: config.user.email
+            },
+            timestamp: new Date().toISOString(),
+            parent: repository.branches[repository.currentBranch] || null,
+            files: []
+        };
+
+        // Hash staged files
+        for (const file of stagedFiles) {
+            const filePath = path.join(cwd, file);
+            const hash = await getFileHash(filePath);
+            commit.files.push({
+                path: file,
+                hash: hash
+            });
+        }
+
+        // Add commit to repository
+        repository.commits = repository.commits || [];
+        repository.commits.push(commit);
+        repository.branches[repository.currentBranch] = commit.hash;
+
+        // Save repository and clear staging
+        await writeJSON(path.join(gentPath, COMMITS_FILE), repository);
+        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.hash.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`));
+
+    } 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'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+module.exports = commit;

package/src/commands/init.js

@@ -0,0 +1,140 @@
+/**
+ * Init Command - Initialize a new gent repository
+ * Creates .gent directory and necessary files
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const boxen = require('boxen');
+const { ensureDir, writeJSON, pathExists } = require('../utils/fileSystem');
+const { GENT_DIR, CONFIG_FILE, STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+
+/**
+ * Initialize a new gent repository
+ * @param {Object} options - Command options
+ */
+async function init(options) {
+    const spinner = ora('Initializing gent repository...').start();
+
+    try {
+        const cwd = process.cwd();
+        const gentPath = path.join(cwd, GENT_DIR);
+
+        // Check if already initialized
+        if (await pathExists(gentPath)) {
+            spinner.fail(chalk.red('Gent repository already exists!'));
+            console.log(chalk.yellow('\nℹ Use gent status to see the current state'));
+            return;
+        }
+
+        // Get user configuration if not using defaults
+        let config = {
+            user: {
+                name: 'Anonymous',
+                email: 'anonymous@example.com'
+            },
+            repository: {
+                name: path.basename(cwd),
+                description: 'A gent repository',
+                created: new Date().toISOString()
+            }
+        };
+
+        if (!options.yes) {
+            spinner.stop();
+
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'userName',
+                    message: 'Enter your name:',
+                    default: 'Anonymous'
+                },
+                {
+                    type: 'input',
+                    name: 'userEmail',
+                    message: 'Enter your email:',
+                    default: 'anonymous@example.com',
+                    validate: (input) => {
+                        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+                        return emailRegex.test(input) || 'Please enter a valid email';
+                    }
+                },
+                {
+                    type: 'input',
+                    name: 'repoName',
+                    message: 'Repository name:',
+                    default: path.basename(cwd)
+                },
+                {
+                    type: 'input',
+                    name: 'repoDescription',
+                    message: 'Repository description:',
+                    default: 'A gent repository'
+                }
+            ]);
+
+            config.user.name = answers.userName;
+            config.user.email = answers.userEmail;
+            config.repository.name = answers.repoName;
+            config.repository.description = answers.repoDescription;
+
+            spinner.start('Creating repository structure...');
+        }
+
+        // Create directory structure
+        await ensureDir(gentPath);
+        await ensureDir(path.join(gentPath, 'objects'));
+        await ensureDir(path.join(gentPath, 'refs', 'heads'));
+        await ensureDir(path.join(gentPath, 'refs', 'tags'));
+
+        // Create initial files
+        await writeJSON(path.join(gentPath, CONFIG_FILE), config);
+        await writeJSON(path.join(gentPath, STAGING_FILE), { files: [] });
+        await writeJSON(path.join(gentPath, COMMITS_FILE), { commits: [], branches: { main: null }, currentBranch: 'main' });
+
+        // Create HEAD file
+        await fs.writeFile(path.join(gentPath, 'HEAD'), 'ref: refs/heads/main\n');
+
+        // Create .gentignore
+        const gentignore = `# Gent ignore patterns
+node_modules/
+.DS_Store
+*.log
+.env
+.gent/
+`;
+        await fs.writeFile(path.join(cwd, '.gentignore'), gentignore);
+
+        spinner.succeed(chalk.green('✓ Gent repository initialized successfully!'));
+
+        // Display success message
+        const message = chalk.white(`
+${chalk.bold('Repository:')} ${config.repository.name}
+${chalk.bold('User:')} ${config.user.name} <${config.user.email}>
+${chalk.bold('Branch:')} main
+
+${chalk.cyan('Next steps:')}
+  ${chalk.gray('•')} gent add <files>     - Add files to staging
+  ${chalk.gray('•')} gent commit          - Commit your changes
+  ${chalk.gray('•')} gent status          - View repository status
+    `);
+
+        console.log(boxen(message, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: 'cyan'
+        }));
+
+    } catch (error) {
+        spinner.fail(chalk.red('Failed to initialize repository'));
+        console.error(chalk.red('\nError:'), error.message);
+        process.exit(1);
+    }
+}
+
+module.exports = init;

package/src/commands/log.js

@@ -0,0 +1,92 @@
+/**
+ * Log Command - Show commit logs
+ * Displays commit history with details
+ */
+
+const path = require('path');
+const chalk = require('chalk');
+const { formatDistanceToNow } = require('date-fns');
+const { getGentPath, readJSON } = require('../utils/fileSystem');
+const { COMMITS_FILE } = require('../utils/constants');
+
+/**
+ * Show commit history
+ * @param {Object} options - Command options
+ */
+async function log(options) {
+    try {
+        const gentPath = await getGentPath();
+        const repository = await readJSON(path.join(gentPath, COMMITS_FILE));
+
+        const commits = repository.commits || [];
+        const currentBranch = repository.currentBranch || 'main';
+
+        if (commits.length === 0) {
+            console.log(chalk.yellow('No commits yet'));
+            console.log(chalk.gray('Use "gent commit" to create your first commit'));
+            return;
+        }
+
+        // Limit number of commits to show
+        const limit = parseInt(options.number) || 10;
+        const commitsToShow = commits.slice(-limit).reverse();
+
+        if (options.oneline) {
+            displayOnelineLog(commitsToShow, repository.branches[currentBranch]);
+        } else {
+            displayDetailedLog(commitsToShow, repository.branches[currentBranch], currentBranch);
+        }
+
+    } 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'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * Display detailed commit log
+ */
+function displayDetailedLog(commits, currentCommitHash, currentBranch) {
+    console.log(chalk.bold.cyan(`\nCommit History (${currentBranch} branch):\n`));
+
+    commits.forEach((commit, index) => {
+        const isHead = commit.hash === currentCommitHash;
+        const headLabel = isHead ? chalk.yellow.bold(' (HEAD)') : '';
+
+        console.log(chalk.yellow(`commit ${commit.hash}`) + headLabel);
+        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 })})`));
+        console.log();
+        console.log(chalk.white(`    ${commit.message}`));
+        console.log();
+        console.log(chalk.gray(`    ${commit.files.length} file(s) changed`));
+
+        if (index < commits.length - 1) {
+            console.log(chalk.gray('    │'));
+        }
+        console.log();
+    });
+}
+
+/**
+ * Display oneline commit log
+ */
+function displayOnelineLog(commits, currentCommitHash) {
+    commits.forEach(commit => {
+        const isHead = commit.hash === currentCommitHash;
+        const headLabel = isHead ? chalk.yellow(' (HEAD)') : '';
+        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 })})`);
+
+        console.log(`${shortHash}${headLabel} ${message} ${timeAgo}`);
+    });
+}
+
+module.exports = log;

package/src/commands/status.js

@@ -0,0 +1,167 @@
+/**
+ * Status Command - Show the working tree status
+ * Displays staged, modified, and untracked files
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const { getGentPath, readJSON, pathExists, getTrackedFiles, getIgnorePatterns } = require('../utils/fileSystem');
+const { STAGING_FILE, COMMITS_FILE } = require('../utils/constants');
+const { getFileHash, getAllFiles } = require('../utils/helpers');
+
+/**
+ * Show repository status
+ * @param {Object} options - Command options
+ */
+async function status(options) {
+    try {
+        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 currentBranch = repository.currentBranch || 'main';
+        const lastCommit = repository.branches[currentBranch];
+
+        // Get all files in the working directory
+        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);
+                }
+            } else if (!stagedSet.has(relativePath)) {
+                untracked.push(relativePath);
+            }
+        }
+
+        // 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);
+            }
+        }
+
+        // Display status
+        if (options.short) {
+            displayShortStatus(stagedFiles, modified, untracked, deleted);
+        } else {
+            displayDetailedStatus(currentBranch, stagedFiles, modified, untracked, deleted, lastCommit);
+        }
+
+    } 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'));
+        } else {
+            console.error(chalk.red('Error:'), error.message);
+        }
+        process.exit(1);
+    }
+}
+
+/**
+ * Display detailed status output
+ */
+function displayDetailedStatus(branch, staged, modified, untracked, deleted, lastCommit) {
+    console.log(chalk.bold(`On branch ${chalk.cyan(branch)}`));
+
+    if (!lastCommit) {
+        console.log(chalk.gray('No commits yet\n'));
+    } else {
+        console.log(chalk.gray(`Last commit: ${lastCommit.substring(0, 7)}\n`));
+    }
+
+    // Staged files
+    if (staged.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}`));
+        });
+        console.log();
+    }
+
+    // Modified files
+    if (modified.length > 0) {
+        console.log(chalk.red.bold('Changes not staged for commit:'));
+        console.log(chalk.gray('  (use "gent add <file>..." to update what will be committed)\n'));
+        modified.forEach(file => {
+            console.log(chalk.red(`\tmodified:   ${file}`));
+        });
+        console.log();
+    }
+
+    // Deleted files
+    if (deleted.length > 0) {
+        deleted.forEach(file => {
+            console.log(chalk.red(`\tdeleted:    ${file}`));
+        });
+        console.log();
+    }
+
+    // Untracked files
+    if (untracked.length > 0) {
+        console.log(chalk.red.bold('Untracked files:'));
+        console.log(chalk.gray('  (use "gent add <file>..." to include in what will be committed)\n'));
+        untracked.forEach(file => {
+            console.log(chalk.red(`\t${file}`));
+        });
+        console.log();
+    }
+
+    // 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) {
+        console.log(chalk.yellow('No changes added to commit (use "gent add" to track files)'));
+    }
+}
+
+/**
+ * Display short status output
+ */
+function displayShortStatus(staged, modified, untracked, deleted) {
+    staged.forEach(file => {
+        console.log(chalk.green('A  ') + file);
+    });
+
+    modified.forEach(file => {
+        console.log(chalk.red(' M ') + file);
+    });
+
+    deleted.forEach(file => {
+        console.log(chalk.red(' D ') + file);
+    });
+
+    untracked.forEach(file => {
+        console.log(chalk.red('?? ') + file);
+    });
+}
+
+module.exports = status;

package/src/index.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+/**
+ * Gent CLI - A Git-like version control system
+ * Main entry point for the CLI application
+ * 
+ * @author Your Name
+ * @version 1.0.0
+ */
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const packageJson = require('../package.json');
+
+// Import commands
+const initCommand = require('./commands/init');
+const statusCommand = require('./commands/status');
+const addCommand = require('./commands/add');
+const commitCommand = require('./commands/commit');
+const logCommand = require('./commands/log');
+const branchCommand = require('./commands/branch');
+const checkoutCommand = require('./commands/checkout');
+
+// Configure CLI
+program
+    .name('gent')
+    .description(chalk.cyan('🚀 Gent - A Git-like version control CLI'))
+    .version(packageJson.version, '-v, --version', 'Output the current version');
+
+// Register commands
+program
+    .command('init')
+    .description('Initialize a new gent repository')
+    .option('-y, --yes', 'Skip prompts and use defaults')
+    .action(initCommand);
+
+program
+    .command('status')
+    .description('Show the working tree status')
+    .option('-s, --short', 'Give the output in short format')
+    .action(statusCommand);
+
+program
+    .command('add <files...>')
+    .description('Add file contents to the staging area')
+    .option('-A, --all', 'Add all files')
+    .action(addCommand);
+
+program
+    .command('commit')
+    .description('Record changes to the repository')
+    .option('-m, --message <message>', 'Commit message')
+    .option('-a, --all', 'Automatically stage all modified files')
+    .action(commitCommand);
+
+program
+    .command('log')
+    .description('Show commit logs')
+    .option('-n, --number <count>', 'Limit the number of commits to show', '10')
+    .option('--oneline', 'Show each commit on a single line')
+    .action(logCommand);
+
+program
+    .command('branch')
+    .description('List, create, or delete branches')
+    .argument('[name]', 'Branch name to create')
+    .option('-d, --delete <name>', 'Delete a branch')
+    .option('-a, --all', 'List all branches')
+    .action(branchCommand);
+
+program
+    .command('checkout <branch>')
+    .description('Switch branches or restore working tree files')
+    .option('-b, --create', 'Create a new branch')
+    .action(checkoutCommand);
+
+// Help command
+program
+    .command('help [command]')
+    .description('Display help for a specific command')
+    .action((command) => {
+        if (command) {
+            program.commands.find(cmd => cmd.name() === command)?.help();
+        } else {
+            program.help();
+        }
+    });
+
+// Error handling
+program.exitOverride();
+
+try {
+    program.parse(process.argv);
+
+    // Show help if no command provided
+    if (!process.argv.slice(2).length) {
+        program.outputHelp();
+    }
+} catch (err) {
+    if (err.code !== 'commander.help' && err.code !== 'commander.helpDisplayed') {
+        console.error(chalk.red('Error:'), err.message);
+        process.exit(1);
+    }
+}