{
  "name": "mygit",
  "version": "1.0.0",
  "description": "A Git implementation for learning",
  "main": "src/mygit.js",
  "bin": {
    "mygit": "./src/mygit.js"
  },
  "scripts": {
    "test": "node test/test.js"
  },
  "keywords": ["git", "vcs", "learning"],
  "license": "MIT"
}

#!/usr/bin/env node

/**
 * mygit - A Git implementation for learning
 * 
 * Usage: mygit <command> [options]
 * 
 * This file is the "front door" of our CLI tool. Its only job is to
 * figure out which command the user wants and hand off to the right module.
 * Keeping this file thin means each command can evolve independently --
 * the same separation-of-concerns principle behind real Git's source layout.
 */

const commands = {
    init: require('./commands/init'),
    // We'll add more commands later
};

function main() {
    // process.argv: [node, script, ...userArgs]
    // We slice off the first two to get the user-supplied arguments.
    const args = process.argv.slice(2);
    
    if (args.length === 0) {
        console.log('usage: mygit <command> [<args>]');
        console.log('\nAvailable commands:');
        console.log('   init       Initialize a new repository');
        process.exit(1);
    }
    
    const command = args[0];
    const commandArgs = args.slice(1);
    
    if (!commands[command]) {
        console.error(`mygit: '${command}' is not a mygit command.`);
        process.exit(1);
    }
    
    try {
        commands[command].execute(commandArgs);
    } catch (error) {
        console.error(`error: ${error.message}`);
        process.exit(1);
    }
}

main();

const path = require('path');
const fs = require('fs');

/**
 * Find the .git directory by walking up from the current directory.
 *
 * Why walk upward? Because Git commands work from any subdirectory
 * inside a repository. When you run `git status` from `src/utils/`,
 * Git doesn't give up -- it climbs the directory tree until it finds
 * the `.git` folder. This is the same behavior we're implementing here.
 *
 * Debugging tip: if this function returns null when you expect a repo,
 * check that you're calling it from a directory that actually lives
 * inside an initialized repository. A common mistake is running
 * `mygit init` in one terminal directory and testing in another.
 */
function findGitDir(startDir = process.cwd()) {
    let currentDir = startDir;
    
    // Walk up until we hit the filesystem root (e.g., "/" or "C:\")
    while (currentDir !== path.parse(currentDir).root) {
        const gitDir = path.join(currentDir, '.git');
        if (fs.existsSync(gitDir) && fs.statSync(gitDir).isDirectory()) {
            return gitDir;
        }
        currentDir = path.dirname(currentDir);
    }
    
    return null;
}

/**
 * Get the repository root (parent of .git)
 */
function getRepoRoot(gitDir) {
    return path.dirname(gitDir);
}

/**
 * Ensure we're in a Git repository
 */
function requireGitDir() {
    const gitDir = findGitDir();
    if (!gitDir) {
        throw new Error('not a git repository (or any of the parent directories): .git');
    }
    return gitDir;
}

module.exports = {
    findGitDir,
    getRepoRoot,
    requireGitDir
};

const fs = require('fs');
const path = require('path');

/**
 * Initialize a new Git repository
 * 
 * Creates the .git directory structure:
 * - HEAD: Points to refs/heads/master
 * - config: Repository configuration
 * - objects/: Object database
 * - refs/heads/: Branch refs
 * - refs/tags/: Tag refs
 */
function execute(args) {
    // Parse arguments
    const directory = args[0] || '.';
    const repoPath = path.resolve(directory);
    const gitDir = path.join(repoPath, '.git');
    
    // Check if already a repository
    if (fs.existsSync(gitDir)) {
        console.log(`Reinitialized existing Git repository in ${gitDir}`);
        return;
    }
    
    // Create the directory structure.
    // Each of these directories serves a specific purpose:
    //   objects/      -> the database of all file contents, trees, and commits
    //   objects/info/ -> auxiliary info for dumb-protocol transfers (rarely used)
    //   objects/pack/ -> packed objects for storage efficiency (we'll skip packing)
    //   refs/heads/   -> one file per branch, each containing a commit hash
    //   refs/tags/    -> one file per tag, pointing to a tagged object
    //   info/         -> repo-level metadata like local exclude patterns
    const directories = [
        gitDir,
        path.join(gitDir, 'objects'),
        path.join(gitDir, 'objects', 'info'),
        path.join(gitDir, 'objects', 'pack'),
        path.join(gitDir, 'refs'),
        path.join(gitDir, 'refs', 'heads'),
        path.join(gitDir, 'refs', 'tags'),
        path.join(gitDir, 'info'),
    ];
    
    directories.forEach(dir => {
        fs.mkdirSync(dir, { recursive: true });
    });
    
    // Create HEAD file - points to the master branch.
    // This is a "symbolic reference" (symref). HEAD is the answer to
    // "where am I right now?" -- it almost always points to a branch name,
    // which in turn points to a commit hash. This level of indirection is
    // what lets commits advance a branch automatically.
    const headContent = 'ref: refs/heads/master\n';
    fs.writeFileSync(path.join(gitDir, 'HEAD'), headContent);
    
    // Create config file with minimal settings
    const configContent = `[core]
\trepositoryformatversion = 0
\tfilemode = false
\tbare = false
`;
    fs.writeFileSync(path.join(gitDir, 'config'), configContent);
    
    // Create description file (used by GitWeb)
    const descContent = 'Unnamed repository; edit this file to name the repository.\n';
    fs.writeFileSync(path.join(gitDir, 'description'), descContent);
    
    // Create info/exclude (local gitignore)
    const excludeContent = '# git ls-files --others --exclude-from=.git/info/exclude\n';
    fs.writeFileSync(path.join(gitDir, 'info', 'exclude'), excludeContent);
    
    console.log(`Initialized empty Git repository in ${gitDir}`);
}

module.exports = { execute };