@compass-ai/nova 1.0.73 → 1.0.74

package/dist/services/git-service.js

@@ -0,0 +1,1215 @@
+/**
+ * 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