@compass-ai/nova 1.0.74 → 1.0.76

package/dist/services/git-service.js

@@ -1,1215 +0,0 @@
-/**
- * Git integration service using simple-git
- *
- * This module provides comprehensive Git operations for the Compass CLI,
- * including commits, branches, diffs, conflict detection, and intelligent
- * commit message generation. It wraps the simple-git library to provide
- * a clean, promise-based API for all Git operations.
- */
-import { simpleGit } from 'simple-git';
-import path from 'path';
-import fs from 'fs/promises';
-import { logger } from '../utils/logger.js';
-import { getSystemEventLogger } from './system-event-logger.js';
-import { createIgnoreInstance } from '../utils/ignore-patterns.js';
-/**
- * GitService class provides comprehensive Git operations for the Compass CLI.
- * It wraps simple-git to provide a clean, typed API for all Git operations
- * including commits, branches, diffs, conflict detection, and more.
- */
-class GitService {
-    git;
-    projectRoot;
-    constructor(projectRoot) {
-        this.projectRoot = projectRoot || process.cwd();
-        const options = {
-            baseDir: this.projectRoot,
-            binary: 'git',
-            maxConcurrentProcesses: 6,
-            trimmed: true,
-        };
-        // Call simpleGit as a function with options
-        this.git = simpleGit(options);
-    }
-    /**
-     * Initializes the Git service and verifies the repository
-     */
-    async initialize() {
-        try {
-            const isRepo = await this.isGitRepo();
-            if (!isRepo) {
-                logger.warn('Not a Git repository');
-                return false;
-            }
-            logger.debug('Git service initialized');
-            return true;
-        }
-        catch (error) {
-            logger.error('Failed to initialize Git service', error);
-            return false;
-        }
-    }
-    /**
-     * Checks if the directory is a Git repository
-     */
-    async isGitRepo() {
-        try {
-            await this.git.status();
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Initializes a new Git repository
-     */
-    async initRepo(bare = false) {
-        await this.git.init(bare);
-        logger.info(`Initialized ${bare ? 'bare ' : ''}Git repository in ${this.projectRoot}`);
-    }
-    /**
-     * Gets the current Git status
-     */
-    async getStatus() {
-        try {
-            const status = await this.git.status();
-            const staged = status.staged.map((file) => ({
-                path: file,
-                index: 'A',
-                workingDir: ' ',
-                staged: true,
-                modified: false,
-                isNew: true,
-                deleted: false,
-                conflicted: false,
-            }));
-            // Add modified staged files
-            for (const file of status.modified) {
-                if (status.staged.includes(file)) {
-                    const existing = staged.find((s) => s.path === file);
-                    if (existing) {
-                        existing.index = 'M';
-                        existing.modified = true;
-                        existing.isNew = false;
-                    }
-                }
-            }
-            const modified = status.modified
-                .filter((file) => !status.staged.includes(file))
-                .map((file) => ({
-                path: file,
-                index: ' ',
-                workingDir: 'M',
-                staged: false,
-                modified: true,
-                isNew: false,
-                deleted: false,
-                conflicted: false,
-            }));
-            // Add deleted files
-            for (const file of status.deleted) {
-                const fileStatus = {
-                    path: file,
-                    index: status.staged.includes(file) ? 'D' : ' ',
-                    workingDir: status.staged.includes(file) ? ' ' : 'D',
-                    staged: status.staged.includes(file),
-                    modified: false,
-                    isNew: false,
-                    deleted: true,
-                    conflicted: false,
-                };
-                if (fileStatus.staged) {
-                    staged.push(fileStatus);
-                }
-                else {
-                    modified.push(fileStatus);
-                }
-            }
-            return {
-                branch: status.current || 'HEAD',
-                tracking: status.tracking || null,
-                ahead: status.ahead,
-                behind: status.behind,
-                staged,
-                modified,
-                untracked: status.not_added,
-                conflicted: status.conflicted,
-                isClean: status.isClean(),
-            };
-        }
-        catch (error) {
-            logger.debug(`Git status failed, attempting .gitignore fallback: ${error}`);
-            return this.getStatusWithGitignoreFallback();
-        }
-    }
-    /**
-     * Gets the current branch name
-     */
-    async getCurrentBranch() {
-        const status = await this.git.status();
-        return status.current || 'HEAD';
-    }
-    /**
-     * Gets the diff for staged changes
-     */
-    async getStagedDiff(options = {}) {
-        const args = ['--cached'];
-        if (options.context !== undefined) {
-            args.push(`-U${options.context}`);
-        }
-        if (options.ignoreWhitespace) {
-            args.push('-w');
-        }
-        if (options.wordDiff) {
-            args.push('--word-diff');
-        }
-        return this.git.diff(args);
-    }
-    /**
-     * Gets the diff for unstaged changes
-     */
-    async getUnstagedDiff(options = {}) {
-        const args = [];
-        if (options.context !== undefined) {
-            args.push(`-U${options.context}`);
-        }
-        if (options.ignoreWhitespace) {
-            args.push('-w');
-        }
-        if (options.wordDiff) {
-            args.push('--word-diff');
-        }
-        return this.git.diff(args);
-    }
-    /**
-     * Gets the diff for a specific file
-     */
-    async getFileDiff(filePath, options = {}) {
-        const args = [];
-        if (options.context !== undefined) {
-            args.push(`-U${options.context}`);
-        }
-        if (options.ignoreWhitespace) {
-            args.push('-w');
-        }
-        if (options.commit) {
-            args.push(options.commit);
-        }
-        args.push('--', filePath);
-        return this.git.diff(args);
-    }
-    /**
-     * Gets the diff between two commits
-     */
-    async getDiffBetweenCommits(fromCommit, toCommit, options = {}) {
-        const args = [];
-        if (options.context !== undefined) {
-            args.push(`-U${options.context}`);
-        }
-        if (options.ignoreWhitespace) {
-            args.push('-w');
-        }
-        args.push(fromCommit, toCommit);
-        return this.git.diff(args);
-    }
-    /**
-     * Stages files for commit
-     */
-    async stage(files) {
-        const fileList = Array.isArray(files) ? files : [files];
-        await this.git.add(fileList);
-        logger.debug(`Staged: ${fileList.join(', ')}`);
-    }
-    /**
-     * Stages all changes
-     */
-    async stageAll() {
-        await this.git.add('.');
-        logger.debug('Staged all changes');
-    }
-    /**
-     * Unstages files
-     */
-    async unstage(files) {
-        const fileList = Array.isArray(files) ? files : [files];
-        await this.git.reset(['HEAD', '--', ...fileList]);
-        logger.debug(`Unstaged: ${fileList.join(', ')}`);
-    }
-    /**
-     * Unstages all files
-     */
-    async unstageAll() {
-        await this.git.reset(['HEAD']);
-        logger.debug('Unstaged all files');
-    }
-    /**
-     * Commits staged changes
-     */
-    async commit(message, options = {}) {
-        const startTime = Date.now();
-        const isMultiLine = message.includes('\n');
-        let tempFilePath = null;
-        try {
-            if (isMultiLine) {
-                const repoRoot = await this.getRepoRoot();
-                tempFilePath = path.join(repoRoot, '.git', 'COMMIT_EDITMSG_TEMP');
-                await fs.writeFile(tempFilePath, message, 'utf8');
-                const commitArgs = ['-F', tempFilePath];
-                if (options.amend) {
-                    commitArgs.push('--amend');
-                }
-                if (options.allowEmpty) {
-                    commitArgs.push('--allow-empty');
-                }
-                if (options.noVerify) {
-                    commitArgs.push('--no-verify');
-                }
-                if (options.author) {
-                    commitArgs.push(`--author=${options.author}`);
-                }
-                const result = await this.git.raw(['commit', ...commitArgs]);
-                const hashMatch = result.match(/\[.+?\s+([a-f0-9]+)\]/);
-                const commitHash = hashMatch ? hashMatch[1] : 'unknown';
-                logger.info(`Committed: ${commitHash}`);
-                const systemEventLogger = getSystemEventLogger();
-                await systemEventLogger.logGitOperation({
-                    operation: 'commit',
-                    branch: await this.getCurrentBranch(),
-                    success: true,
-                    duration_ms: Date.now() - startTime,
-                    details: { hash: commitHash, amend: options.amend, multiLine: true },
-                });
-                return commitHash;
-            }
-            else {
-                const commitOptions = [];
-                if (options.amend) {
-                    commitOptions.push('--amend');
-                }
-                if (options.allowEmpty) {
-                    commitOptions.push('--allow-empty');
-                }
-                if (options.noVerify) {
-                    commitOptions.push('--no-verify');
-                }
-                if (options.author) {
-                    commitOptions.push(`--author=${options.author}`);
-                }
-                const result = await this.git.commit(message, commitOptions);
-                logger.info(`Committed: ${result.commit}`);
-                const systemEventLogger = getSystemEventLogger();
-                await systemEventLogger.logGitOperation({
-                    operation: 'commit',
-                    branch: await this.getCurrentBranch(),
-                    success: true,
-                    duration_ms: Date.now() - startTime,
-                    details: { hash: result.commit, amend: options.amend },
-                });
-                return result.commit;
-            }
-        }
-        finally {
-            if (tempFilePath) {
-                try {
-                    await fs.unlink(tempFilePath);
-                }
-                catch (error) {
-                    logger.debug(`Failed to clean up temp commit file: ${error}`);
-                }
-            }
-        }
-    }
-    /**
-     * Commits with a conventional commit message
-     */
-    async commitConventional(commit) {
-        const message = this.formatConventionalCommit(commit);
-        return this.commit(message);
-    }
-    /**
-     * Formats a conventional commit message
-     */
-    formatConventionalCommit(commit) {
-        let message = commit.type;
-        if (commit.scope) {
-            message += `(${commit.scope})`;
-        }
-        if (commit.breaking) {
-            message += '!';
-        }
-        message += `: ${commit.description}`;
-        if (commit.body) {
-            message += `\n\n${commit.body}`;
-        }
-        if (commit.footer) {
-            message += `\n\n${commit.footer}`;
-        }
-        if (commit.breaking && !commit.footer?.includes('BREAKING CHANGE')) {
-            message += `\n\nBREAKING CHANGE: ${commit.description}`;
-        }
-        return message;
-    }
-    /**
-     * Creates a new branch
-     */
-    async createBranch(branchName, startPoint) {
-        if (startPoint) {
-            await this.git.checkoutBranch(branchName, startPoint);
-        }
-        else {
-            await this.git.checkoutLocalBranch(branchName);
-        }
-        logger.info(`Created and switched to branch: ${branchName}`);
-    }
-    /**
-     * Switches to a branch
-     */
-    async checkout(branchName) {
-        await this.git.checkout(branchName);
-        logger.info(`Switched to branch: ${branchName}`);
-    }
-    /**
-     * Checks out a specific file from a commit
-     */
-    async checkoutFile(filePath, commit) {
-        if (commit) {
-            await this.git.checkout([commit, '--', filePath]);
-        }
-        else {
-            await this.git.checkout(['--', filePath]);
-        }
-        logger.debug(`Checked out file: ${filePath}`);
-    }
-    /**
-     * Gets the list of local branches
-     */
-    async getBranches() {
-        const result = await this.git.branchLocal();
-        return Object.entries(result.branches).map(([name, data]) => ({
-            name,
-            current: data.current,
-            commit: data.commit,
-            label: data.label,
-        }));
-    }
-    /**
-     * Gets all branches including remote
-     */
-    async getAllBranches() {
-        const result = await this.git.branch(['-a', '-v']);
-        return Object.entries(result.branches).map(([name, data]) => ({
-            name,
-            current: data.current,
-            commit: data.commit,
-            label: data.label,
-        }));
-    }
-    /**
-     * Deletes a branch
-     */
-    async deleteBranch(branchName, force = false) {
-        const flag = force ? '-D' : '-d';
-        await this.git.branch([flag, branchName]);
-        logger.info(`Deleted branch: ${branchName}`);
-    }
-    /**
-     * Renames a branch
-     */
-    async renameBranch(oldName, newName) {
-        await this.git.branch(['-m', oldName, newName]);
-        logger.info(`Renamed branch: ${oldName} -> ${newName}`);
-    }
-    /**
-     * Gets recent commits
-     */
-    async getRecentCommits(options = {}) {
-        const logOptions = {};
-        if (options.maxCount) {
-            logOptions['--max-count'] = options.maxCount;
-        }
-        else {
-            logOptions['--max-count'] = 10;
-        }
-        if (options.from) {
-            logOptions['--since'] = options.from;
-        }
-        if (options.author) {
-            logOptions['--author'] = options.author;
-        }
-        if (options.since) {
-            logOptions['--since'] = options.since;
-        }
-        if (options.until) {
-            logOptions['--until'] = options.until;
-        }
-        if (!options.includeMerges) {
-            logOptions['--no-merges'] = null;
-        }
-        const log = await this.git.log(logOptions);
-        return log.all.map((commit) => ({
-            hash: commit.hash.substring(0, 7),
-            fullHash: commit.hash,
-            message: commit.message,
-            author: commit.author_name,
-            authorEmail: commit.author_email,
-            date: commit.date,
-            parents: commit.refs ? commit.refs.split(', ') : [],
-        }));
-    }
-    /**
-     * Gets the log for a specific file
-     */
-    async getFileHistory(filePath, options = {}) {
-        const logOptions = {
-            file: filePath,
-        };
-        if (options.maxCount) {
-            logOptions['--max-count'] = options.maxCount;
-        }
-        else {
-            logOptions['--max-count'] = 20;
-        }
-        const log = await this.git.log(logOptions);
-        return log.all.map((commit) => ({
-            hash: commit.hash.substring(0, 7),
-            fullHash: commit.hash,
-            message: commit.message,
-            author: commit.author_name,
-            authorEmail: commit.author_email,
-            date: commit.date,
-            parents: [],
-        }));
-    }
-    /**
-     * Checks for merge conflicts
-     */
-    async hasConflicts() {
-        const status = await this.git.status();
-        return status.conflicted.length > 0;
-    }
-    /**
-     * Gets conflicted files
-     */
-    async getConflictedFiles() {
-        const status = await this.git.status();
-        return status.conflicted;
-    }
-    /**
-     * Marks a file as resolved
-     */
-    async markResolved(filePath) {
-        await this.git.add(filePath);
-        logger.debug(`Marked as resolved: ${filePath}`);
-    }
-    /**
-     * Aborts a merge in progress
-     */
-    async abortMerge() {
-        await this.git.merge(['--abort']);
-        logger.info('Merge aborted');
-    }
-    /**
-     * Merges a branch into the current branch
-     */
-    async merge(branchName, options = {}) {
-        const startTime = Date.now();
-        const systemEventLogger = getSystemEventLogger();
-        try {
-            const mergeOptions = [branchName];
-            if (options.noFastForward) {
-                mergeOptions.unshift('--no-ff');
-            }
-            if (options.squash) {
-                mergeOptions.unshift('--squash');
-            }
-            if (options.message) {
-                mergeOptions.unshift('-m', options.message);
-            }
-            const result = await this.git.merge(mergeOptions);
-            logger.info(`Merged ${branchName} into current branch`);
-            // Convert conflicts array to string array if needed
-            const conflicts = Array.isArray(result.conflicts)
-                ? result.conflicts.map((c) => typeof c === 'string' ? c : c.file || '')
-                : [];
-            // Log successful merge
-            await systemEventLogger.logGitOperation({
-                operation: 'merge',
-                branch: await this.getCurrentBranch(),
-                success: true,
-                duration_ms: Date.now() - startTime,
-                details: { sourceBranch: branchName, conflicts: conflicts.length },
-            });
-            return {
-                success: true,
-                message: result.result || 'Merge successful',
-                conflicts,
-                fastForward: result.merges?.length === 0 || false,
-            };
-        }
-        catch (error) {
-            const conflicts = await this.getConflictedFiles();
-            // Log failed merge
-            await systemEventLogger.logGitOperation({
-                operation: 'merge',
-                branch: await this.getCurrentBranch(),
-                success: false,
-                duration_ms: Date.now() - startTime,
-                error: error instanceof Error ? error.message : 'Merge failed',
-                details: { sourceBranch: branchName, conflicts: conflicts.length },
-            });
-            return {
-                success: false,
-                message: error instanceof Error ? error.message : 'Merge failed',
-                conflicts,
-                fastForward: false,
-            };
-        }
-    }
-    /**
-     * Generates a commit message based on changes
-     */
-    async generateCommitMessage() {
-        const status = await this.git.status();
-        const stagedCount = status.staged.length;
-        const modifiedCount = status.modified.filter((f) => status.staged.includes(f)).length;
-        const deletedCount = status.deleted.filter((f) => status.staged.includes(f)).length;
-        const newCount = stagedCount - modifiedCount - deletedCount;
-        if (stagedCount === 0) {
-            return 'chore: update files';
-        }
-        // Analyze file types to determine commit type
-        const fileTypes = new Map();
-        for (const file of status.staged) {
-            const ext = path.extname(file).toLowerCase();
-            fileTypes.set(ext, (fileTypes.get(ext) || 0) + 1);
-        }
-        // Determine commit type based on files
-        let commitType = 'chore';
-        let scope;
-        // Check for specific patterns
-        const hasTestFiles = status.staged.some((f) => f.includes('test') || f.includes('spec') || f.includes('__tests__'));
-        const hasDocFiles = status.staged.some((f) => f.endsWith('.md') || f.includes('docs/'));
-        const hasConfigFiles = status.staged.some((f) => f.includes('config') ||
-            f.endsWith('.json') ||
-            f.endsWith('.yaml') ||
-            f.endsWith('.yml'));
-        const hasSrcFiles = status.staged.some((f) => f.startsWith('src/') || f.includes('/src/'));
-        if (hasTestFiles && !hasSrcFiles) {
-            commitType = 'test';
-        }
-        else if (hasDocFiles && !hasSrcFiles) {
-            commitType = 'docs';
-        }
-        else if (hasConfigFiles && !hasSrcFiles) {
-            commitType = 'build';
-        }
-        else if (hasSrcFiles) {
-            commitType = newCount > 0 ? 'feat' : 'fix';
-        }
-        // Determine scope from directory
-        if (status.staged.length === 1) {
-            const file = status.staged[0];
-            const parts = file.split('/');
-            if (parts.length > 1) {
-                scope = parts[parts.length - 2];
-            }
-        }
-        else {
-            // Find common directory
-            const dirs = status.staged.map((f) => path.dirname(f));
-            const commonDir = this.findCommonPrefix(dirs);
-            if (commonDir && commonDir !== '.') {
-                scope = path.basename(commonDir);
-            }
-        }
-        // Generate description
-        let description;
-        if (stagedCount === 1) {
-            const file = path.basename(status.staged[0]);
-            if (newCount === 1) {
-                description = `add ${file}`;
-            }
-            else if (deletedCount === 1) {
-                description = `remove ${file}`;
-            }
-            else {
-                description = `update ${file}`;
-            }
-        }
-        else {
-            const parts = [];
-            if (newCount > 0)
-                parts.push(`add ${newCount} file${newCount > 1 ? 's' : ''}`);
-            if (modifiedCount > 0)
-                parts.push(`update ${modifiedCount} file${modifiedCount > 1 ? 's' : ''}`);
-            if (deletedCount > 0)
-                parts.push(`remove ${deletedCount} file${deletedCount > 1 ? 's' : ''}`);
-            description = parts.join(', ');
-        }
-        // Format the message
-        let message = commitType;
-        if (scope) {
-            message += `(${scope})`;
-        }
-        message += `: ${description}`;
-        return message;
-    }
-    /**
-     * Finds the common prefix among an array of paths
-     */
-    findCommonPrefix(paths) {
-        if (paths.length === 0)
-            return '';
-        if (paths.length === 1)
-            return paths[0];
-        const sorted = paths.slice().sort();
-        const first = sorted[0].split('/');
-        const last = sorted[sorted.length - 1].split('/');
-        const common = [];
-        for (let i = 0; i < Math.min(first.length, last.length); i++) {
-            if (first[i] === last[i]) {
-                common.push(first[i]);
-            }
-            else {
-                break;
-            }
-        }
-        return common.join('/');
-    }
-    /**
-     * Pulls latest changes from remote
-     */
-    async pull(remote, branch) {
-        const startTime = Date.now();
-        const result = await this.git.pull(remote, branch);
-        logger.info('Pulled latest changes');
-        // Log the git operation
-        const systemEventLogger = getSystemEventLogger();
-        await systemEventLogger.logGitOperation({
-            operation: 'pull',
-            branch: await this.getCurrentBranch(),
-            success: true,
-            duration_ms: Date.now() - startTime,
-            details: { remote, filesChanged: result.files?.length },
-        });
-        return result;
-    }
-    /**
-     * Fetches from remote without merging
-     */
-    async fetch(remote, branch) {
-        if (remote && branch) {
-            const result = await this.git.fetch(remote, branch);
-            logger.debug('Fetched from remote');
-            return result;
-        }
-        else if (remote) {
-            const result = await this.git.fetch(remote);
-            logger.debug('Fetched from remote');
-            return result;
-        }
-        else {
-            const result = await this.git.fetch();
-            logger.debug('Fetched from remote');
-            return result;
-        }
-    }
-    /**
-     * Pushes commits to remote
-     */
-    async push(remote = 'origin', branch, options = {}) {
-        const startTime = Date.now();
-        const currentBranch = branch || (await this.getCurrentBranch());
-        const pushOptions = [];
-        if (options.force) {
-            pushOptions.push('--force');
-        }
-        if (options.setUpstream) {
-            pushOptions.push('--set-upstream');
-        }
-        const result = await this.git.push(remote, currentBranch, pushOptions);
-        logger.info(`Pushed to ${remote}/${currentBranch}`);
-        // Log the git operation
-        const systemEventLogger = getSystemEventLogger();
-        await systemEventLogger.logGitOperation({
-            operation: 'push',
-            branch: currentBranch,
-            success: true,
-            duration_ms: Date.now() - startTime,
-            details: { remote, force: options.force },
-        });
-        return result;
-    }
-    /**
-     * Stashes current changes
-     */
-    async stash(message) {
-        if (message) {
-            await this.git.stash(['push', '-m', message]);
-        }
-        else {
-            await this.git.stash(['push']);
-        }
-        logger.info('Changes stashed');
-    }
-    /**
-     * Applies stashed changes
-     */
-    async stashPop(index) {
-        if (index !== undefined) {
-            await this.git.stash(['pop', `stash@{${index}}`]);
-        }
-        else {
-            await this.git.stash(['pop']);
-        }
-        logger.info('Stash applied');
-    }
-    /**
-     * Applies stash without removing it
-     */
-    async stashApply(index) {
-        if (index !== undefined) {
-            await this.git.stash(['apply', `stash@{${index}}`]);
-        }
-        else {
-            await this.git.stash(['apply']);
-        }
-        logger.debug('Stash applied (kept in stash list)');
-    }
-    /**
-     * Lists all stashes
-     */
-    async listStashes() {
-        const result = await this.git.stashList();
-        return result.all.map((stash, index) => ({
-            index,
-            message: stash.message,
-            date: stash.date,
-            branch: stash.refs || '',
-        }));
-    }
-    /**
-     * Drops a stash
-     */
-    async dropStash(index) {
-        if (index !== undefined) {
-            await this.git.stash(['drop', `stash@{${index}}`]);
-        }
-        else {
-            await this.git.stash(['drop']);
-        }
-        logger.debug('Stash dropped');
-    }
-    /**
-     * Clears all stashes
-     */
-    async clearStashes() {
-        await this.git.stash(['clear']);
-        logger.info('All stashes cleared');
-    }
-    /**
-     * Resets a file to its last committed state
-     */
-    async resetFile(filePath) {
-        await this.git.checkout(['--', filePath]);
-        logger.info(`Reset file: ${filePath}`);
-    }
-    /**
-     * Resets to a specific commit
-     */
-    async reset(commit, mode = 'mixed') {
-        await this.git.reset([`--${mode}`, commit]);
-        logger.info(`Reset to ${commit} (${mode})`);
-    }
-    /**
-     * Reverts a commit
-     */
-    async revert(commit, noCommit = false) {
-        if (noCommit) {
-            await this.git.raw(['revert', '--no-commit', commit]);
-        }
-        else {
-            await this.git.raw(['revert', commit]);
-        }
-        logger.info(`Reverted commit: ${commit}`);
-    }
-    /**
-     * Gets the remote URL
-     */
-    async getRemoteUrl(remote = 'origin') {
-        try {
-            const remotes = await this.git.getRemotes(true);
-            const found = remotes.find((r) => r.name === remote);
-            return found?.refs.fetch || null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Gets all remotes
-     */
-    async getRemotes() {
-        const remotes = await this.git.getRemotes(true);
-        return remotes.map((r) => ({
-            name: r.name,
-            fetchUrl: r.refs.fetch || '',
-            pushUrl: r.refs.push || '',
-        }));
-    }
-    /**
-     * Adds a remote
-     */
-    async addRemote(name, url) {
-        await this.git.addRemote(name, url);
-        logger.info(`Added remote: ${name} -> ${url}`);
-    }
-    /**
-     * Removes a remote
-     */
-    async removeRemote(name) {
-        await this.git.removeRemote(name);
-        logger.info(`Removed remote: ${name}`);
-    }
-    /**
-     * Gets tags
-     */
-    async getTags() {
-        const result = await this.git.tags();
-        return result.all;
-    }
-    /**
-     * Creates a tag
-     */
-    async createTag(tagName, message, commit) {
-        if (message) {
-            // Annotated tag with message
-            const options = ['-a', tagName, '-m', message];
-            if (commit) {
-                options.push(commit);
-            }
-            await this.git.tag(options);
-        }
-        else {
-            // Lightweight tag
-            if (commit) {
-                await this.git.tag([tagName, commit]);
-            }
-            else {
-                await this.git.tag([tagName]);
-            }
-        }
-        logger.info(`Created tag: ${tagName}`);
-    }
-    /**
-     * Deletes a tag
-     */
-    async deleteTag(tagName) {
-        await this.git.tag(['-d', tagName]);
-        logger.info(`Deleted tag: ${tagName}`);
-    }
-    /**
-     * Gets the content of a file at a specific commit
-     */
-    async getFileAtCommit(filePath, commit) {
-        return this.git.show(`${commit}:${filePath}`);
-    }
-    /**
-     * Checks if a file exists in the repository
-     */
-    async fileExistsInRepo(filePath) {
-        try {
-            await this.git.show(`HEAD:${filePath}`);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Gets blame information for a file
-     */
-    async blame(filePath) {
-        const result = await this.git.raw(['blame', filePath]);
-        return result;
-    }
-    /**
-     * Cleans untracked files
-     */
-    async clean(options = {}) {
-        const args = [];
-        if (options.force) {
-            args.push('-f');
-        }
-        if (options.directories) {
-            args.push('-d');
-        }
-        if (options.dryRun) {
-            args.push('-n');
-        }
-        const result = await this.git.clean(args);
-        // CleanSummary has a files array
-        if (typeof result === 'object' && 'files' in result) {
-            return result.files;
-        }
-        return [];
-    }
-    /**
-     * Gets the root directory of the Git repository
-     */
-    async getRepoRoot() {
-        const result = await this.git.revparse(['--show-toplevel']);
-        return result.trim();
-    }
-    /**
-     * Checks if there are uncommitted changes
-     */
-    async hasUncommittedChanges() {
-        const status = await this.git.status();
-        return !status.isClean();
-    }
-    /**
-     * Gets the short hash of HEAD
-     */
-    async getHeadShortHash() {
-        const result = await this.git.revparse(['--short', 'HEAD']);
-        return result.trim();
-    }
-    /**
-     * Gets the full hash of HEAD
-     */
-    async getHeadHash() {
-        const result = await this.git.revparse(['HEAD']);
-        return result.trim();
-    }
-    /**
-     * Checks if a branch exists
-     */
-    async branchExists(branchName) {
-        const branches = await this.getBranches();
-        return branches.some((b) => b.name === branchName);
-    }
-    /**
-     * Gets the tracking branch for the current branch
-     */
-    async getTrackingBranch() {
-        try {
-            const result = await this.git.raw([
-                'rev-parse',
-                '--abbrev-ref',
-                '--symbolic-full-name',
-                '@{u}',
-            ]);
-            return result.trim() || null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Sets the upstream branch
-     */
-    async setUpstream(remote, branch) {
-        await this.git.branch(['--set-upstream-to', `${remote}/${branch}`]);
-        logger.debug(`Set upstream to ${remote}/${branch}`);
-    }
-    /**
-     * Cherry-picks a commit
-     */
-    async cherryPick(commit, noCommit = false) {
-        const options = noCommit ? ['--no-commit', commit] : [commit];
-        await this.git.raw(['cherry-pick', ...options]);
-        logger.info(`Cherry-picked commit: ${commit}`);
-    }
-    /**
-     * Aborts a cherry-pick in progress
-     */
-    async abortCherryPick() {
-        await this.git.raw(['cherry-pick', '--abort']);
-        logger.info('Cherry-pick aborted');
-    }
-    /**
-     * Continues a cherry-pick after resolving conflicts
-     */
-    async continueCherryPick() {
-        await this.git.raw(['cherry-pick', '--continue']);
-        logger.info('Cherry-pick continued');
-    }
-    // ===========================================================================
-    // Worktree Operations
-    // ===========================================================================
-    /**
-     * Represents a git worktree entry
-     */
-    /**
-     * Adds a new git worktree at the given path on a new branch
-     */
-    async addWorktree(worktreePath, branchName, baseBranch) {
-        const args = ['worktree', 'add', '-b', branchName, worktreePath];
-        if (baseBranch) {
-            args.push(baseBranch);
-        }
-        await this.git.raw(args);
-        logger.info(`Added worktree at ${worktreePath} on branch ${branchName}`);
-    }
-    /**
-     * Lists all git worktrees
-     */
-    async listWorktrees() {
-        const result = await this.git.raw(['worktree', 'list', '--porcelain']);
-        const worktrees = [];
-        let current = { path: '', head: '', branch: '' };
-        for (const line of result.split('\n')) {
-            if (line.startsWith('worktree ')) {
-                current = { path: line.replace('worktree ', ''), head: '', branch: '' };
-            }
-            else if (line.startsWith('HEAD ')) {
-                current.head = line.replace('HEAD ', '');
-            }
-            else if (line.startsWith('branch ')) {
-                current.branch = line.replace('branch refs/heads/', '');
-                worktrees.push(current);
-            }
-            else if (line === 'detached') {
-                current.branch = '(detached)';
-                worktrees.push(current);
-            }
-        }
-        return worktrees;
-    }
-    /**
-     * Removes a git worktree (with force option for dirty worktrees)
-     */
-    async removeWorktree(worktreePath, force = false) {
-        const args = ['worktree', 'remove', worktreePath];
-        if (force) {
-            args.push('--force');
-        }
-        await this.git.raw(args);
-        logger.info(`Removed worktree at ${worktreePath}`);
-    }
-    /**
-     * Prunes stale worktree metadata
-     */
-    async pruneWorktrees() {
-        await this.git.raw(['worktree', 'prune']);
-        logger.debug('Pruned stale worktree metadata');
-    }
-    /**
-     * Gets the default remote branch (e.g., origin/main or origin/master)
-     */
-    async getDefaultRemoteBranch() {
-        try {
-            // Try HEAD of default remote
-            const result = await this.git.raw(['symbolic-ref', 'refs/remotes/origin/HEAD']);
-            return result.trim().replace('refs/remotes/origin/', '');
-        }
-        catch {
-            // Fallback: check if main or master exists
-            try {
-                await this.git.raw(['rev-parse', '--verify', 'origin/main']);
-                return 'main';
-            }
-            catch {
-                try {
-                    await this.git.raw(['rev-parse', '--verify', 'origin/master']);
-                    return 'master';
-                }
-                catch {
-                    return null;
-                }
-            }
-        }
-    }
-    /**
-     * Reads and parses .gitignore file using shared utility.
-     * Falls back to DEFAULT_IGNORE_PATTERNS if .gitignore doesn't exist.
-     */
-    async readGitignore(_gitignorePath) {
-        // Use shared utility which handles .gitignore loading and fallback
-        return createIgnoreInstance(this.projectRoot, true);
-    }
-    /**
-     * Recursively walks directory tree and collects files
-     */
-    async walkDirectory(dir, ig, baseDir) {
-        const files = [];
-        try {
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
-                // Skip if ignored by .gitignore
-                if (ig && ig.ignores(relativePath)) {
-                    continue;
-                }
-                if (entry.isDirectory()) {
-                    // Skip .git directory
-                    if (entry.name === '.git') {
-                        continue;
-                    }
-                    // Recursively walk subdirectories
-                    const subFiles = await this.walkDirectory(fullPath, ig, baseDir);
-                    files.push(...subFiles);
-                }
-                else if (entry.isFile()) {
-                    files.push(relativePath);
-                }
-            }
-        }
-        catch (error) {
-            logger.debug(`Failed to walk directory ${dir}: ${error}`);
-        }
-        return files;
-    }
-    /**
-     * Gets file status using .gitignore as fallback when git is not available
-     */
-    async getStatusWithGitignoreFallback() {
-        logger.debug('Using .gitignore fallback for status');
-        const gitignorePath = path.join(this.projectRoot, '.gitignore');
-        const ig = await this.readGitignore(gitignorePath);
-        // Walk the directory tree
-        const allFiles = await this.walkDirectory(this.projectRoot, ig, this.projectRoot);
-        // All files are considered untracked in fallback mode
-        return {
-            branch: 'unknown',
-            tracking: null,
-            ahead: 0,
-            behind: 0,
-            staged: [],
-            modified: [],
-            untracked: allFiles,
-            conflicted: [],
-            isClean: allFiles.length === 0,
-        };
-    }
-}
-/**
- * Factory function to create a GitService instance
- *
- * @param projectRoot - Optional project root directory
- * @returns A new GitService instance
- */
-export function createGitService(projectRoot) {
-    return new GitService(projectRoot);
-}
-// Singleton instance
-let gitServiceInstance = null;
-/**
- * Gets the singleton GitService instance.
- * Creates the instance on first call.
- *
- * @param projectRoot - Optional project root directory
- * @returns Promise resolving to the GitService instance
- */
-export async function getGitService(projectRoot) {
-    if (!gitServiceInstance) {
-        gitServiceInstance = new GitService(projectRoot);
-        await gitServiceInstance.initialize();
-    }
-    return gitServiceInstance;
-}
-export { GitService };
-//# sourceMappingURL=git-service.js.map