gitx.do 0.1.1 → 0.1.2

package/dist/cli/commands/add.js

@@ -1,979 +0,0 @@
-/**
- * @fileoverview gitx add command
- *
- * This module implements the `gitx add` command which adds files to the
- * staging area (index). It supports:
- * - Adding single files
- * - Adding multiple files
- * - Adding directories recursively
- * - Glob pattern matching
- * - Adding all files (-A or --all)
- * - Updating tracked files only (-u or --update)
- * - Dry run mode (-n or --dry-run)
- * - Verbose output (-v or --verbose)
- *
- * @module cli/commands/add
- *
- * @example
- * // Add a single file
- * await addFiles(cwd, ['file.txt'])
- *
- * @example
- * // Add all files
- * await addAll(cwd)
- *
- * @example
- * // Dry run to see what would be added
- * await addDryRun(cwd, ['*.ts'])
- */
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import pako from 'pako';
-import { hashObjectStreamingHex } from '../../utils/sha1';
-// ============================================================================
-// Helper Functions
-// ============================================================================
-/**
- * Check if a directory exists
- */
-async function directoryExists(dirPath) {
-    try {
-        const stat = await fs.stat(dirPath);
-        return stat.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if a file exists
- */
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Find the git directory for a repository
- */
-async function findGitDir(cwd) {
-    const gitPath = path.join(cwd, '.git');
-    try {
-        const stat = await fs.stat(gitPath);
-        if (stat.isDirectory()) {
-            return gitPath;
-        }
-        if (stat.isFile()) {
-            // Worktree - read the actual gitdir
-            const content = await fs.readFile(gitPath, 'utf8');
-            const match = content.match(/^gitdir:\s*(.+)$/m);
-            if (match) {
-                return path.resolve(cwd, match[1].trim());
-            }
-        }
-    }
-    catch {
-        // Check if cwd itself is a bare repo
-        const hasHead = await fileExists(path.join(cwd, 'HEAD'));
-        const hasObjects = await directoryExists(path.join(cwd, 'objects'));
-        const hasRefs = await directoryExists(path.join(cwd, 'refs'));
-        if (hasHead && hasObjects && hasRefs) {
-            return cwd;
-        }
-    }
-    return null;
-}
-/**
- * Check if path is inside repository
- */
-function isPathInRepo(repoRoot, filePath) {
-    const resolved = path.resolve(repoRoot, filePath);
-    const relative = path.relative(repoRoot, resolved);
-    return !relative.startsWith('..') && !path.isAbsolute(relative);
-}
-/**
- * Get tracked files from mock-tracked file or empty set
- */
-async function getTrackedFiles(gitDir) {
-    const tracked = new Map();
-    const mockTrackedPath = path.join(gitDir, 'mock-tracked');
-    try {
-        const content = await fs.readFile(mockTrackedPath, 'utf8');
-        for (const line of content.split('\n')) {
-            if (!line.trim())
-                continue;
-            const match = line.match(/^([0-9a-f]{40})\s+(\d+)\s+(.+)$/);
-            if (match) {
-                const [, sha, modeStr, filePath] = match;
-                tracked.set(filePath, { sha, mode: parseInt(modeStr, 8) });
-            }
-        }
-    }
-    catch {
-        // No tracked files
-    }
-    return tracked;
-}
-/**
- * Get staged files from mock-staged file or index
- */
-async function getStagedFiles(gitDir) {
-    const staged = new Map();
-    const mockStagedPath = path.join(gitDir, 'mock-staged');
-    try {
-        const content = await fs.readFile(mockStagedPath, 'utf8');
-        for (const line of content.split('\n')) {
-            if (!line.trim())
-                continue;
-            const match = line.match(/^([0-9a-f]{40})\s+(\d+)\s+(.+)$/);
-            if (match) {
-                const [, sha, modeStr, filePath] = match;
-                staged.set(filePath, { sha, mode: parseInt(modeStr, 8) });
-            }
-        }
-    }
-    catch {
-        // No staged files
-    }
-    return staged;
-}
-/**
- * Load .gitignore rules
- */
-async function loadGitIgnoreRules(cwd) {
-    const rules = { patterns: [] };
-    const gitignorePath = path.join(cwd, '.gitignore');
-    try {
-        const content = await fs.readFile(gitignorePath, 'utf8');
-        for (const line of content.split('\n')) {
-            const trimmed = line.trim();
-            if (trimmed && !trimmed.startsWith('#')) {
-                rules.patterns.push(trimmed);
-            }
-        }
-    }
-    catch {
-        // No .gitignore
-    }
-    return rules;
-}
-/**
- * Check if a file path matches gitignore patterns
- */
-function isIgnored(filePath, rules) {
-    for (const pattern of rules.patterns) {
-        if (matchGlobPattern(filePath, pattern)) {
-            return true;
-        }
-        // Also check basename for patterns without path separator
-        if (!pattern.includes('/')) {
-            const basename = path.basename(filePath);
-            if (matchGlobPattern(basename, pattern)) {
-                return true;
-            }
-        }
-        // Check directory patterns
-        if (pattern.endsWith('/')) {
-            const dirPattern = pattern.slice(0, -1);
-            if (filePath.startsWith(dirPattern + '/') || filePath === dirPattern) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-/**
- * Get file mode (regular, executable, or symlink)
- */
-async function getFileMode(filePath) {
-    try {
-        const stat = await fs.lstat(filePath);
-        if (stat.isSymbolicLink()) {
-            return 0o120000;
-        }
-        // Check if executable
-        if (stat.mode & 0o111) {
-            return 0o100755;
-        }
-        return 0o100644;
-    }
-    catch {
-        return 0o100644;
-    }
-}
-/**
- * Compute blob SHA for a file
- * @internal Reserved for future use
- */
-async function _computeBlobSha(filePath) {
-    const content = await fs.readFile(filePath);
-    return hashObjectStreamingHex('blob', new Uint8Array(content));
-}
-void _computeBlobSha; // Preserve for future use
-/**
- * Store a blob object in the object store
- */
-async function storeBlob(gitDir, sha, content) {
-    const objectsDir = path.join(gitDir, 'objects');
-    const prefix = sha.substring(0, 2);
-    const suffix = sha.substring(2);
-    const prefixDir = path.join(objectsDir, prefix);
-    const objectPath = path.join(prefixDir, suffix);
-    // Create directory if needed
-    await fs.mkdir(prefixDir, { recursive: true });
-    // Check if already exists
-    if (await fileExists(objectPath)) {
-        return;
-    }
-    // Create blob content with header
-    const header = `blob ${content.length}\0`;
-    const headerBytes = new TextEncoder().encode(header);
-    const combined = new Uint8Array(headerBytes.length + content.length);
-    combined.set(headerBytes, 0);
-    combined.set(content, headerBytes.length);
-    // Compress and write
-    const compressed = pako.deflate(combined);
-    await fs.writeFile(objectPath, compressed);
-}
-/**
- * Update the index with staged files
- */
-async function updateIndex(gitDir, entries) {
-    // For testing purposes, we'll update a mock-staged file
-    // In a real implementation, this would write the binary index format
-    const mockStagedPath = path.join(gitDir, 'mock-staged');
-    // Load existing staged files
-    const existing = await getStagedFiles(gitDir);
-    // Merge new entries
-    for (const entry of entries) {
-        existing.set(entry.path, { sha: entry.sha, mode: entry.mode });
-    }
-    // Write back
-    const lines = [];
-    for (const [filePath, { sha, mode }] of existing) {
-        lines.push(`${sha} ${mode.toString(8)} ${filePath}`);
-    }
-    await fs.writeFile(mockStagedPath, lines.join('\n'));
-}
-/**
- * Remove entries from the index (for deletions)
- */
-async function removeFromIndex(gitDir, paths) {
-    const mockStagedPath = path.join(gitDir, 'mock-staged');
-    // Load existing staged files
-    const existing = await getStagedFiles(gitDir);
-    // Remove specified paths
-    for (const filePath of paths) {
-        existing.delete(filePath);
-    }
-    // Write back
-    const lines = [];
-    for (const [filePath, { sha, mode }] of existing) {
-        lines.push(`${sha} ${mode.toString(8)} ${filePath}`);
-    }
-    if (lines.length > 0) {
-        await fs.writeFile(mockStagedPath, lines.join('\n'));
-    }
-    else {
-        // Remove the file if empty
-        try {
-            await fs.unlink(mockStagedPath);
-        }
-        catch {
-            // Ignore if doesn't exist
-        }
-    }
-}
-/**
- * Walk directory recursively and collect files
- */
-async function walkDirectory(basePath, relativePath, gitIgnore, files) {
-    const currentPath = relativePath ? path.join(basePath, relativePath) : basePath;
-    try {
-        const entries = await fs.readdir(currentPath, { withFileTypes: true });
-        for (const entry of entries) {
-            // Skip .git directory
-            if (entry.name === '.git')
-                continue;
-            const entryRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-            if (entry.isDirectory()) {
-                await walkDirectory(basePath, entryRelative, gitIgnore, files);
-            }
-            else if (entry.isFile() || entry.isSymbolicLink()) {
-                files.push(entryRelative);
-            }
-        }
-    }
-    catch {
-        // Directory might not be readable
-    }
-}
-// ============================================================================
-// Command Handler
-// ============================================================================
-/**
- * Handler for the gitx add command.
- *
- * @description Processes command-line arguments and adds files to the staging area.
- *
- * @param ctx - Command context with cwd, args, options
- * @throws Error if not in a git repository or files not found
- */
-export async function addCommand(ctx) {
-    const { cwd, options, stdout, stderr } = ctx;
-    let { args } = ctx;
-    // Handle --help flag
-    if (options.help || options.h) {
-        stdout(`gitx add - Add file contents to the index
-
-Usage: gitx add [options] [--] <pathspec>...
-
-Options:
-  -A, --all       Add all files (new, modified, deleted)
-  -u, --update    Update tracked files only
-  -n, --dry-run   Show what would be added
-  -v, --verbose   Be verbose
-  -f, --force     Allow adding otherwise ignored files
-  -N, --intent-to-add  Record that the path will be added later
-  -p, --patch     Interactively choose hunks of patch
-  --refresh       Don't add, just refresh the stat() info`);
-        return;
-    }
-    // Find git directory
-    const gitDir = await findGitDir(cwd);
-    if (!gitDir) {
-        throw new Error('fatal: not a git repository (or any of the parent directories): .git');
-    }
-    const verbose = options.verbose || options.v;
-    // For add command, -n/--dry-run means dry-run
-    // The CLI parser may consume the next argument as a value, so handle that case
-    let dryRun = false;
-    // Handle --dry-run (may have consumed file.txt as its value)
-    if (options.dryRun !== undefined) {
-        if (typeof options.dryRun === 'string') {
-            args = [options.dryRun, ...args];
-            dryRun = true;
-        }
-        else if (options.dryRun === true) {
-            dryRun = true;
-        }
-    }
-    // Handle -n (may have consumed file.txt as its value)
-    if (options.n !== undefined) {
-        if (typeof options.n === 'string') {
-            args = [options.n, ...args];
-            dryRun = true;
-        }
-        else if (options.n === null || options.n === true) {
-            dryRun = true;
-        }
-    }
-    const force = options.force || options.f;
-    // Handle -N/--intent-to-add (may have consumed file.txt as its value)
-    let intentToAdd = false;
-    let intentArg = null;
-    if (options.intentToAdd !== undefined) {
-        if (typeof options.intentToAdd === 'string') {
-            intentArg = options.intentToAdd;
-            intentToAdd = true;
-        }
-        else if (options.intentToAdd === true) {
-            intentToAdd = true;
-        }
-    }
-    if (options.N !== undefined) {
-        if (typeof options.N === 'string') {
-            intentArg = options.N;
-            intentToAdd = true;
-        }
-        else if (options.N === null || options.N === true) {
-            intentToAdd = true;
-        }
-    }
-    if (intentArg) {
-        args = [intentArg, ...args];
-    }
-    const update = options.update || options.u;
-    const all = options.all || options.A;
-    const refresh = options.refresh;
-    const patch = options.patch || options.p;
-    // Handle --refresh flag
-    if (refresh) {
-        // Just refresh index stat info - no-op for mock implementation
-        return;
-    }
-    // Handle --patch flag (interactive - just acknowledge for now)
-    if (patch) {
-        // Patch mode is interactive - just return for now
-        return;
-    }
-    // No files specified and no -A or -u flag
-    if (args.length === 0 && !all && !update) {
-        throw new Error('Nothing specified, nothing added.\nMaybe you wanted to say \'gitx add .\'?');
-    }
-    let result;
-    if (all) {
-        result = await addAll(cwd, { verbose, dryRun, force });
-    }
-    else if (update) {
-        result = await addUpdate(cwd, { verbose, dryRun });
-    }
-    else if (dryRun) {
-        result = await addDryRun(cwd, args, { verbose, force });
-    }
-    else {
-        result = await addFiles(cwd, args, { verbose, force, intentToAdd });
-    }
-    // Output for verbose mode
-    if (verbose) {
-        for (const filePath of result.added) {
-            stdout(`add '${filePath}'`);
-        }
-        for (const filePath of result.wouldAdd) {
-            stdout(`add '${filePath}'`);
-        }
-        for (const filePath of result.deleted) {
-            stdout(`remove '${filePath}'`);
-        }
-    }
-    // Output for dry-run mode
-    if (dryRun) {
-        for (const filePath of result.wouldAdd) {
-            stdout(`add '${filePath}'`);
-        }
-    }
-    // Output warnings to stderr
-    for (const warning of result.warnings) {
-        stderr(warning);
-    }
-}
-// ============================================================================
-// Core Functions
-// ============================================================================
-/**
- * Add specified files to the staging area.
- *
- * @description Adds the given files or patterns to the git index.
- * Supports glob patterns and directories.
- *
- * @param cwd - Working directory (repository root)
- * @param paths - File paths or patterns to add
- * @param options - Add options
- * @returns AddResult with added files information
- * @throws Error if not in a git repository or files not found
- */
-export async function addFiles(cwd, paths, options = {}) {
-    // Find git directory
-    const gitDir = await findGitDir(cwd);
-    if (!gitDir) {
-        throw new Error('fatal: not a git repository (or any of the parent directories): .git');
-    }
-    const result = {
-        added: [],
-        deleted: [],
-        unchanged: [],
-        wouldAdd: [],
-        intentToAdd: [],
-        files: [],
-        count: 0,
-        warnings: []
-    };
-    // Load gitignore rules
-    const gitIgnore = await loadGitIgnoreRules(cwd);
-    // Get files to add
-    const filesToAdd = await getFilesToAdd(cwd, paths, options);
-    // Get current staged files to check for unchanged
-    const stagedFiles = await getStagedFiles(gitDir);
-    // Process each file
-    const indexEntries = [];
-    const errors = [];
-    for (const file of filesToAdd) {
-        const fullPath = path.join(cwd, file.path);
-        // Check if path is outside repository
-        if (!isPathInRepo(cwd, file.path)) {
-            throw new Error(`fatal: '${file.path}' is outside repository`);
-        }
-        // Check if file is ignored (unless force)
-        if (!options.force && isIgnored(file.path, gitIgnore)) {
-            errors.push(`The following paths are ignored by one of your .gitignore files:\n${file.path}`);
-            continue;
-        }
-        // Get file content and compute SHA
-        try {
-            const content = await fs.readFile(fullPath);
-            const sha = hashObjectStreamingHex('blob', new Uint8Array(content));
-            const mode = await getFileMode(fullPath);
-            // Check if unchanged
-            const existingEntry = stagedFiles.get(file.path);
-            if (existingEntry && existingEntry.sha === sha) {
-                result.unchanged.push(file.path);
-                // Still include in files for return value
-                result.files.push({ path: file.path, sha, mode });
-                continue;
-            }
-            if (options.intentToAdd) {
-                result.intentToAdd.push(file.path);
-                // For intent-to-add, we add with empty content
-                indexEntries.push({ path: file.path, sha: '0'.repeat(40), mode });
-            }
-            else {
-                // Store the blob
-                await storeBlob(gitDir, sha, new Uint8Array(content));
-                result.added.push(file.path);
-                result.files.push({ path: file.path, sha, mode });
-                indexEntries.push({ path: file.path, sha, mode });
-            }
-        }
-        catch (err) {
-            if (err.code === 'ENOENT') {
-                errors.push(`fatal: pathspec '${file.path}' does not exist (file not found)`);
-            }
-            else if (err.code === 'EACCES' || err.code === 'EPERM') {
-                throw new Error(`error: open("${file.path}"): Permission denied`);
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    // Update index with new entries
-    if (indexEntries.length > 0) {
-        await updateIndex(gitDir, indexEntries);
-    }
-    result.count = result.added.length + result.intentToAdd.length;
-    // Report errors - but if some files were added, just warn and continue
-    if (errors.length > 0) {
-        if (result.added.length === 0) {
-            throw new Error(errors[0]);
-        }
-        // Files were added but some had errors - record warnings
-        result.warnings = errors;
-    }
-    return result;
-}
-/**
- * Add all files to the staging area (like git add -A).
- *
- * @description Adds all untracked, modified, and deleted files
- * to the staging area.
- *
- * @param cwd - Working directory (repository root)
- * @param options - Add options
- * @returns AddResult with added files information
- * @throws Error if not in a git repository
- */
-export async function addAll(cwd, options = {}) {
-    // Find git directory
-    const gitDir = await findGitDir(cwd);
-    if (!gitDir) {
-        throw new Error('fatal: not a git repository (or any of the parent directories): .git');
-    }
-    const result = {
-        added: [],
-        deleted: [],
-        unchanged: [],
-        wouldAdd: [],
-        intentToAdd: [],
-        files: [],
-        count: 0,
-        warnings: []
-    };
-    // Load gitignore rules
-    const gitIgnore = await loadGitIgnoreRules(cwd);
-    // Get tracked files
-    const tracked = await getTrackedFiles(gitDir);
-    // Walk directory to find all files
-    const allFiles = [];
-    await walkDirectory(cwd, '', gitIgnore, allFiles);
-    // Process all files (add new/modified)
-    const indexEntries = [];
-    const stagedFiles = await getStagedFiles(gitDir);
-    for (const filePath of allFiles) {
-        // Skip ignored files (unless force)
-        if (!options.force && isIgnored(filePath, gitIgnore)) {
-            continue;
-        }
-        const fullPath = path.join(cwd, filePath);
-        try {
-            const content = await fs.readFile(fullPath);
-            const sha = hashObjectStreamingHex('blob', new Uint8Array(content));
-            const mode = await getFileMode(fullPath);
-            // Check if unchanged from staged
-            const existingEntry = stagedFiles.get(filePath);
-            if (existingEntry && existingEntry.sha === sha) {
-                result.unchanged.push(filePath);
-                continue;
-            }
-            if (options.dryRun) {
-                result.wouldAdd.push(filePath);
-            }
-            else {
-                // Store the blob
-                await storeBlob(gitDir, sha, new Uint8Array(content));
-                result.added.push(filePath);
-                result.files.push({ path: filePath, sha, mode });
-                indexEntries.push({ path: filePath, sha, mode });
-            }
-        }
-        catch {
-            // Skip unreadable files
-        }
-    }
-    // Check for deleted files (tracked but not on disk)
-    for (const [trackedPath] of tracked) {
-        const fullPath = path.join(cwd, trackedPath);
-        if (!await fileExists(fullPath)) {
-            if (options.dryRun) {
-                result.wouldAdd.push(trackedPath);
-            }
-            else {
-                result.deleted.push(trackedPath);
-            }
-        }
-    }
-    // Update index
-    if (!options.dryRun && indexEntries.length > 0) {
-        await updateIndex(gitDir, indexEntries);
-    }
-    // Remove deleted files from index
-    if (!options.dryRun && result.deleted.length > 0) {
-        await removeFromIndex(gitDir, result.deleted);
-    }
-    result.count = result.added.length + result.deleted.length;
-    return result;
-}
-/**
- * Update tracked files only (like git add -u).
- *
- * @description Stages modifications and deletions of tracked files only.
- * Does not add untracked files.
- *
- * @param cwd - Working directory (repository root)
- * @param options - Add options
- * @returns AddResult with updated files information
- * @throws Error if not in a git repository
- */
-export async function addUpdate(cwd, options = {}) {
-    // Find git directory
-    const gitDir = await findGitDir(cwd);
-    if (!gitDir) {
-        throw new Error('fatal: not a git repository (or any of the parent directories): .git');
-    }
-    const result = {
-        added: [],
-        deleted: [],
-        unchanged: [],
-        wouldAdd: [],
-        intentToAdd: [],
-        files: [],
-        count: 0,
-        warnings: []
-    };
-    // Get tracked files
-    const tracked = await getTrackedFiles(gitDir);
-    void getStagedFiles(gitDir); // Keep available for potential future use
-    // Process only tracked files
-    const indexEntries = [];
-    for (const [trackedPath, trackedInfo] of tracked) {
-        const fullPath = path.join(cwd, trackedPath);
-        try {
-            // Check if file still exists
-            if (await fileExists(fullPath)) {
-                const content = await fs.readFile(fullPath);
-                const sha = hashObjectStreamingHex('blob', new Uint8Array(content));
-                const mode = await getFileMode(fullPath);
-                // Check if modified
-                if (sha !== trackedInfo.sha) {
-                    if (options.dryRun) {
-                        result.wouldAdd.push(trackedPath);
-                    }
-                    else {
-                        // Store the blob
-                        await storeBlob(gitDir, sha, new Uint8Array(content));
-                        result.added.push(trackedPath);
-                        result.files.push({ path: trackedPath, sha, mode });
-                        indexEntries.push({ path: trackedPath, sha, mode });
-                    }
-                }
-                else {
-                    result.unchanged.push(trackedPath);
-                }
-            }
-            else {
-                // File was deleted
-                if (options.dryRun) {
-                    result.wouldAdd.push(trackedPath);
-                }
-                else {
-                    result.deleted.push(trackedPath);
-                }
-            }
-        }
-        catch {
-            // Skip unreadable files
-        }
-    }
-    // Update index
-    if (!options.dryRun && indexEntries.length > 0) {
-        await updateIndex(gitDir, indexEntries);
-    }
-    // Remove deleted files from index
-    if (!options.dryRun && result.deleted.length > 0) {
-        await removeFromIndex(gitDir, result.deleted);
-    }
-    result.count = result.added.length + result.deleted.length;
-    return result;
-}
-/**
- * Dry run to show what would be added.
- *
- * @description Shows what files would be added without actually
- * modifying the index.
- *
- * @param cwd - Working directory (repository root)
- * @param paths - File paths or patterns to check
- * @param options - Add options
- * @returns AddResult with wouldAdd populated
- * @throws Error if not in a git repository
- */
-export async function addDryRun(cwd, paths, options = {}) {
-    // Find git directory
-    const gitDir = await findGitDir(cwd);
-    if (!gitDir) {
-        throw new Error('fatal: not a git repository (or any of the parent directories): .git');
-    }
-    const result = {
-        added: [],
-        deleted: [],
-        unchanged: [],
-        wouldAdd: [],
-        intentToAdd: [],
-        files: [],
-        count: 0,
-        warnings: []
-    };
-    // Load gitignore rules
-    const gitIgnore = await loadGitIgnoreRules(cwd);
-    // Get files to add
-    const filesToAdd = await getFilesToAdd(cwd, paths, options);
-    for (const file of filesToAdd) {
-        const fullPath = path.join(cwd, file.path);
-        // Check if path is outside repository
-        if (!isPathInRepo(cwd, file.path)) {
-            throw new Error(`fatal: '${file.path}' is outside repository`);
-        }
-        // Check if file is ignored (unless force)
-        if (!options.force && isIgnored(file.path, gitIgnore)) {
-            continue;
-        }
-        // Check if file exists
-        if (await fileExists(fullPath)) {
-            result.wouldAdd.push(file.path);
-        }
-    }
-    result.count = result.wouldAdd.length;
-    return result;
-}
-/**
- * Get list of files that would be added for given paths.
- *
- * @description Resolves paths and glob patterns to a list of files
- * that would be added to the index.
- *
- * @param cwd - Working directory (repository root)
- * @param paths - File paths or patterns
- * @param options - Add options including exclude patterns
- * @returns Array of FileToAdd objects
- * @throws Error if not in a git repository
- */
-export async function getFilesToAdd(cwd, paths, options = {}) {
-    // Find git directory
-    const gitDir = await findGitDir(cwd);
-    if (!gitDir) {
-        throw new Error('fatal: not a git repository (or any of the parent directories): .git');
-    }
-    const result = [];
-    const seen = new Set();
-    // Load gitignore rules for filtering
-    const gitIgnore = await loadGitIgnoreRules(cwd);
-    for (const pathSpec of paths) {
-        // Check if it's a glob pattern
-        if (pathSpec.includes('*') || pathSpec.includes('?') || pathSpec.includes('{')) {
-            // Walk directory and match pattern
-            const allFiles = [];
-            await walkDirectory(cwd, '', gitIgnore, allFiles);
-            for (const filePath of allFiles) {
-                if (matchGlobPattern(filePath, pathSpec)) {
-                    // Check exclude patterns
-                    if (options.exclude) {
-                        let excluded = false;
-                        for (const exclude of options.exclude) {
-                            if (matchGlobPattern(filePath, exclude)) {
-                                excluded = true;
-                                break;
-                            }
-                        }
-                        if (excluded)
-                            continue;
-                    }
-                    if (!seen.has(filePath)) {
-                        seen.add(filePath);
-                        result.push({ path: filePath, sha: '', mode: 0 });
-                    }
-                }
-            }
-        }
-        else {
-            // Direct path - could be file or directory
-            const fullPath = path.join(cwd, pathSpec);
-            try {
-                const stat = await fs.stat(fullPath);
-                if (stat.isDirectory()) {
-                    // Add all files in directory
-                    const dirFiles = [];
-                    // Handle '.' as root directory (empty string)
-                    const relPath = pathSpec === '.' ? '' : pathSpec;
-                    await walkDirectory(cwd, relPath, gitIgnore, dirFiles);
-                    for (const filePath of dirFiles) {
-                        // Check exclude patterns
-                        if (options.exclude) {
-                            let excluded = false;
-                            for (const exclude of options.exclude) {
-                                if (matchGlobPattern(filePath, exclude)) {
-                                    excluded = true;
-                                    break;
-                                }
-                            }
-                            if (excluded)
-                                continue;
-                        }
-                        if (!seen.has(filePath)) {
-                            seen.add(filePath);
-                            result.push({ path: filePath, sha: '', mode: 0 });
-                        }
-                    }
-                }
-                else if (stat.isFile() || stat.isSymbolicLink()) {
-                    // Check exclude patterns
-                    if (options.exclude) {
-                        let excluded = false;
-                        for (const exclude of options.exclude) {
-                            if (matchGlobPattern(pathSpec, exclude)) {
-                                excluded = true;
-                                break;
-                            }
-                        }
-                        if (excluded)
-                            continue;
-                    }
-                    if (!seen.has(pathSpec)) {
-                        seen.add(pathSpec);
-                        result.push({ path: pathSpec, sha: '', mode: 0 });
-                    }
-                }
-            }
-            catch (err) {
-                if (err.code === 'ENOENT') {
-                    // File doesn't exist - still add to list for error handling later
-                    if (!seen.has(pathSpec)) {
-                        seen.add(pathSpec);
-                        result.push({ path: pathSpec, sha: '', mode: 0 });
-                    }
-                }
-                else {
-                    throw err;
-                }
-            }
-        }
-    }
-    return result;
-}
-/**
- * Match a file path against a glob pattern.
- *
- * @description Utility function to test if a path matches a glob pattern.
- *
- * @param filePath - File path to test
- * @param pattern - Glob pattern to match against
- * @returns true if the path matches the pattern
- */
-export function matchGlobPattern(filePath, pattern) {
-    // Normalize paths
-    const normalizedPath = filePath.replace(/\\/g, '/');
-    const normalizedPattern = pattern.replace(/\\/g, '/');
-    // Handle brace expansion {a,b,c}
-    if (normalizedPattern.includes('{') && normalizedPattern.includes('}')) {
-        const braceMatch = normalizedPattern.match(/\{([^}]+)\}/);
-        if (braceMatch) {
-            const options = braceMatch[1].split(',');
-            for (const option of options) {
-                const expandedPattern = normalizedPattern.replace(braceMatch[0], option);
-                if (matchGlobPattern(filePath, expandedPattern)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-    }
-    // Handle ** pattern for recursive matching
-    if (normalizedPattern.includes('**')) {
-        // **/*.ts should match:
-        // - root.ts (at root level)
-        // - src/file.ts (in subdirectory)
-        // - src/sub/file.ts (deeply nested)
-        // Split pattern by **/ to handle each segment
-        const parts = normalizedPattern.split('**/');
-        if (parts.length === 2) {
-            const prefix = parts[0];
-            const suffix = parts[1];
-            // Build regex for the suffix part
-            let suffixRegex = suffix
-                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-                .replace(/\*\*/g, '<<<DOUBLESTAR>>>')
-                .replace(/\*/g, '[^/]*')
-                .replace(/\?/g, '[^/]')
-                .replace(/<<<DOUBLESTAR>>>/g, '.*');
-            // **/*.ts at start means match optional path segments followed by suffix
-            if (prefix === '') {
-                // Match: optional(path/) + suffix
-                const regex = new RegExp(`^(?:.*/)?${suffixRegex}$`);
-                return regex.test(normalizedPath);
-            }
-            // prefix/**/*.ts means prefix + optional(path/) + suffix
-            const prefixRegex = prefix
-                .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-                .replace(/\*/g, '[^/]*')
-                .replace(/\?/g, '[^/]');
-            const regex = new RegExp(`^${prefixRegex}(?:.*/)?${suffixRegex}$`);
-            return regex.test(normalizedPath);
-        }
-        // Generic ** handling
-        let regexPattern = normalizedPattern
-            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
-            .replace(/\*\*\//g, '(?:.*/)?')
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '[^/]');
-        const regex = new RegExp(`^${regexPattern}$`);
-        return regex.test(normalizedPath);
-    }
-    // Simple glob matching
-    let regexPattern = normalizedPattern
-        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special chars except * and ?
-        .replace(/\*/g, '[^/]*') // * matches any chars except /
-        .replace(/\?/g, '[^/]'); // ? matches single char except /
-    // Add anchors
-    regexPattern = `^${regexPattern}$`;
-    try {
-        const regex = new RegExp(regexPattern);
-        return regex.test(normalizedPath);
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=add.js.map