episoda 0.2.0

package/dist/core/git-executor.js

@@ -0,0 +1,1605 @@
+"use strict";
+/**
+ * Git Command Executor
+ *
+ * Executes git commands with error handling and returns structured results.
+ * Interface-agnostic: Returns structured data, not formatted strings.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitExecutor = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const git_validator_1 = require("./git-validator");
+const git_parser_1 = require("./git-parser");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Executes git commands with error handling
+ *
+ * DESIGN PRINCIPLES:
+ * - Interface-agnostic: Returns structured data, not formatted strings
+ * - No console.log: Let the interface handle output
+ * - Error codes: Return error codes, not messages
+ * - Reusable: Can be used by CLI, MCP, or any other interface
+ */
+class GitExecutor {
+    /**
+     * Execute a git command
+     * @param command - The git command to execute
+     * @param options - Execution options (timeout, cwd, etc.)
+     * @returns Structured result with success/error details
+     */
+    async execute(command, options) {
+        try {
+            // Validate git is installed
+            const gitInstalled = await this.validateGitInstalled();
+            if (!gitInstalled) {
+                return {
+                    success: false,
+                    error: 'GIT_NOT_INSTALLED'
+                };
+            }
+            // Determine working directory
+            const cwd = options?.cwd || process.cwd();
+            // Validate this is a git repository (except for init-like commands)
+            const isGitRepo = await this.isGitRepository(cwd);
+            if (!isGitRepo) {
+                return {
+                    success: false,
+                    error: 'NOT_GIT_REPO'
+                };
+            }
+            // Route to appropriate handler based on action
+            switch (command.action) {
+                case 'checkout':
+                    return await this.executeCheckout(command, cwd, options);
+                case 'create_branch':
+                    return await this.executeCreateBranch(command, cwd, options);
+                case 'commit':
+                    return await this.executeCommit(command, cwd, options);
+                case 'push':
+                    return await this.executePush(command, cwd, options);
+                case 'status':
+                    return await this.executeStatus(cwd, options);
+                case 'pull':
+                    return await this.executePull(command, cwd, options);
+                case 'delete_branch':
+                    return await this.executeDeleteBranch(command, cwd, options);
+                // EP597: Read operations for production local dev mode
+                case 'branch_exists':
+                    return await this.executeBranchExists(command, cwd, options);
+                case 'branch_has_commits':
+                    return await this.executeBranchHasCommits(command, cwd, options);
+                // EP598: Main branch check for production
+                case 'main_branch_check':
+                    return await this.executeMainBranchCheck(cwd, options);
+                // EP599: Get commits for branch
+                case 'get_commits':
+                    return await this.executeGetCommits(command, cwd, options);
+                // EP599: Advanced operations for move-to-module and discard-main-changes
+                case 'stash':
+                    return await this.executeStash(command, cwd, options);
+                case 'reset':
+                    return await this.executeReset(command, cwd, options);
+                case 'merge':
+                    return await this.executeMerge(command, cwd, options);
+                case 'cherry_pick':
+                    return await this.executeCherryPick(command, cwd, options);
+                case 'clean':
+                    return await this.executeClean(command, cwd, options);
+                case 'add':
+                    return await this.executeAdd(command, cwd, options);
+                case 'fetch':
+                    return await this.executeFetch(command, cwd, options);
+                // EP599-3: Composite operations
+                case 'move_to_module':
+                    return await this.executeMoveToModule(command, cwd, options);
+                case 'discard_main_changes':
+                    return await this.executeDiscardMainChanges(cwd, options);
+                // EP523: Branch sync operations
+                case 'sync_status':
+                    return await this.executeSyncStatus(command, cwd, options);
+                case 'sync_main':
+                    return await this.executeSyncMain(cwd, options);
+                case 'rebase_branch':
+                    return await this.executeRebaseBranch(command, cwd, options);
+                case 'rebase_abort':
+                    return await this.executeRebaseAbort(cwd, options);
+                case 'rebase_continue':
+                    return await this.executeRebaseContinue(cwd, options);
+                case 'rebase_status':
+                    return await this.executeRebaseStatus(cwd, options);
+                default:
+                    return {
+                        success: false,
+                        error: 'UNKNOWN_ERROR',
+                        output: 'Unknown command action'
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error instanceof Error ? error.message : 'Unknown error occurred'
+            };
+        }
+    }
+    /**
+     * Execute checkout command
+     */
+    async executeCheckout(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        // Check for uncommitted changes first
+        const statusResult = await this.executeStatus(cwd, options);
+        if (statusResult.success && statusResult.details?.uncommittedFiles?.length) {
+            return {
+                success: false,
+                error: 'UNCOMMITTED_CHANGES',
+                details: {
+                    uncommittedFiles: statusResult.details.uncommittedFiles
+                }
+            };
+        }
+        // Build command
+        const args = ['checkout'];
+        if (command.create) {
+            args.push('-b');
+        }
+        args.push(command.branch);
+        return await this.runGitCommand(args, cwd, options);
+    }
+    /**
+     * Execute create_branch command
+     */
+    async executeCreateBranch(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        // Validate source branch if provided
+        if (command.from) {
+            const fromValidation = (0, git_validator_1.validateBranchName)(command.from);
+            if (!fromValidation.valid) {
+                return {
+                    success: false,
+                    error: fromValidation.error || 'UNKNOWN_ERROR'
+                };
+            }
+        }
+        // Build command - use checkout -b to create AND checkout the branch
+        // This ensures the user is on the new branch immediately
+        const args = ['checkout', '-b', command.branch];
+        if (command.from) {
+            args.push(command.from);
+        }
+        return await this.runGitCommand(args, cwd, options);
+    }
+    /**
+     * Execute commit command
+     */
+    async executeCommit(command, cwd, options) {
+        // Validate commit message
+        const validation = (0, git_validator_1.validateCommitMessage)(command.message);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        // Validate file paths if provided
+        if (command.files) {
+            const fileValidation = (0, git_validator_1.validateFilePaths)(command.files);
+            if (!fileValidation.valid) {
+                return {
+                    success: false,
+                    error: fileValidation.error || 'UNKNOWN_ERROR'
+                };
+            }
+            // Stage specific files first
+            for (const file of command.files) {
+                const addResult = await this.runGitCommand(['add', file], cwd, options);
+                if (!addResult.success) {
+                    return addResult;
+                }
+            }
+        }
+        else {
+            // Stage all changes
+            const addResult = await this.runGitCommand(['add', '-A'], cwd, options);
+            if (!addResult.success) {
+                return addResult;
+            }
+        }
+        // Execute commit
+        const args = ['commit', '-m', command.message];
+        return await this.runGitCommand(args, cwd, options);
+    }
+    /**
+     * Execute push command
+     * EP769: Added force parameter for pushing rebased branches
+     */
+    async executePush(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        // Build command
+        const args = ['push'];
+        // EP769: Add --force flag for rebased branches
+        if (command.force) {
+            args.push('--force');
+        }
+        if (command.setUpstream) {
+            args.push('-u', 'origin', command.branch);
+        }
+        else {
+            args.push('origin', command.branch);
+        }
+        // Configure git credential helper for GitHub token if provided
+        const env = { ...process.env };
+        if (options?.githubToken) {
+            env.GIT_ASKPASS = 'echo';
+            env.GIT_USERNAME = 'x-access-token';
+            env.GIT_PASSWORD = options.githubToken;
+        }
+        return await this.runGitCommand(args, cwd, { ...options, env });
+    }
+    /**
+     * Execute status command
+     */
+    async executeStatus(cwd, options) {
+        const result = await this.runGitCommand(['status', '--porcelain', '-b'], cwd, options);
+        if (result.success && result.output) {
+            const statusInfo = (0, git_parser_1.parseGitStatus)(result.output);
+            return {
+                success: true,
+                output: result.output,
+                details: {
+                    uncommittedFiles: statusInfo.uncommittedFiles,
+                    branchName: statusInfo.currentBranch
+                }
+            };
+        }
+        return result;
+    }
+    /**
+     * Execute pull command
+     */
+    async executePull(command, cwd, options) {
+        // Validate branch name if provided
+        if (command.branch) {
+            const validation = (0, git_validator_1.validateBranchName)(command.branch);
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    error: validation.error || 'UNKNOWN_ERROR'
+                };
+            }
+        }
+        // Check for uncommitted changes first
+        const statusResult = await this.executeStatus(cwd, options);
+        if (statusResult.success && statusResult.details?.uncommittedFiles?.length) {
+            return {
+                success: false,
+                error: 'UNCOMMITTED_CHANGES',
+                details: {
+                    uncommittedFiles: statusResult.details.uncommittedFiles
+                }
+            };
+        }
+        // Build command
+        const args = ['pull'];
+        if (command.branch) {
+            args.push('origin', command.branch);
+        }
+        const result = await this.runGitCommand(args, cwd, options);
+        // Check for merge conflicts
+        if (!result.success && result.output) {
+            const conflicts = (0, git_parser_1.parseMergeConflicts)(result.output);
+            if (conflicts.length > 0) {
+                return {
+                    success: false,
+                    error: 'MERGE_CONFLICT',
+                    output: result.output,
+                    details: {
+                        conflictingFiles: conflicts
+                    }
+                };
+            }
+        }
+        return result;
+    }
+    /**
+     * Execute delete_branch command
+     */
+    async executeDeleteBranch(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        // Build command
+        const args = ['branch'];
+        args.push(command.force ? '-D' : '-d');
+        args.push(command.branch);
+        return await this.runGitCommand(args, cwd, options);
+    }
+    /**
+     * EP597: Execute branch_exists command
+     * Checks if a branch exists locally and/or remotely
+     */
+    async executeBranchExists(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        try {
+            let isLocal = false;
+            let isRemote = false;
+            // Check local branches
+            try {
+                const { stdout: localBranches } = await execAsync('git branch --list', { cwd, timeout: options?.timeout || 10000 });
+                isLocal = localBranches.split('\n').some(line => {
+                    const branchName = line.replace(/^\*?\s*/, '').trim();
+                    return branchName === command.branch;
+                });
+            }
+            catch {
+                // Ignore errors - branch doesn't exist locally
+            }
+            // Check remote branches
+            try {
+                const { stdout: remoteBranches } = await execAsync(`git ls-remote --heads origin ${command.branch}`, { cwd, timeout: options?.timeout || 10000 });
+                isRemote = remoteBranches.trim().length > 0;
+            }
+            catch {
+                // Ignore errors - can't check remote (might be network issue)
+            }
+            const branchExists = isLocal || isRemote;
+            return {
+                success: true,
+                output: branchExists ? `Branch ${command.branch} exists` : `Branch ${command.branch} does not exist`,
+                details: {
+                    branchName: command.branch,
+                    branchExists,
+                    isLocal,
+                    isRemote
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to check branch existence'
+            };
+        }
+    }
+    /**
+     * EP597: Execute branch_has_commits command
+     * Checks if a branch has commits ahead of the base branch (default: main)
+     */
+    async executeBranchHasCommits(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        const baseBranch = command.baseBranch || 'main';
+        try {
+            // Use git cherry to find commits unique to the branch
+            // This shows commits on branch that aren't on base
+            const { stdout } = await execAsync(`git cherry origin/${baseBranch} ${command.branch}`, { cwd, timeout: options?.timeout || 10000 });
+            // git cherry shows lines starting with + for unique commits
+            const uniqueCommits = stdout.trim().split('\n').filter(line => line.startsWith('+'));
+            const hasCommits = uniqueCommits.length > 0;
+            return {
+                success: true,
+                output: hasCommits
+                    ? `Branch ${command.branch} has ${uniqueCommits.length} commits ahead of ${baseBranch}`
+                    : `Branch ${command.branch} has no commits ahead of ${baseBranch}`,
+                details: {
+                    branchName: command.branch,
+                    hasCommits
+                }
+            };
+        }
+        catch (error) {
+            // If git cherry fails (branch not found, etc.), try alternative method
+            try {
+                // Alternative: count commits with rev-list
+                const { stdout } = await execAsync(`git rev-list --count origin/${baseBranch}..${command.branch}`, { cwd, timeout: options?.timeout || 10000 });
+                const commitCount = parseInt(stdout.trim(), 10);
+                const hasCommits = commitCount > 0;
+                return {
+                    success: true,
+                    output: hasCommits
+                        ? `Branch ${command.branch} has ${commitCount} commits ahead of ${baseBranch}`
+                        : `Branch ${command.branch} has no commits ahead of ${baseBranch}`,
+                    details: {
+                        branchName: command.branch,
+                        hasCommits
+                    }
+                };
+            }
+            catch {
+                // Both methods failed - branch likely doesn't exist or isn't tracked
+                return {
+                    success: false,
+                    error: 'BRANCH_NOT_FOUND',
+                    output: error.message || `Failed to check commits for branch ${command.branch}`
+                };
+            }
+        }
+    }
+    /**
+     * EP598: Execute main branch check - returns current branch, uncommitted files, and unpushed commits
+     */
+    async executeMainBranchCheck(cwd, options) {
+        try {
+            // Get current branch
+            let currentBranch = '';
+            try {
+                const { stdout } = await execAsync('git branch --show-current', { cwd, timeout: options?.timeout || 10000 });
+                currentBranch = stdout.trim();
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: 'UNKNOWN_ERROR',
+                    output: error.message || 'Failed to get current branch'
+                };
+            }
+            // Get uncommitted files
+            let uncommittedFiles = [];
+            try {
+                const { stdout } = await execAsync('git status --porcelain', { cwd, timeout: options?.timeout || 10000 });
+                if (stdout) {
+                    uncommittedFiles = stdout.split('\n').filter(line => line.trim()).map(line => {
+                        const parts = line.trim().split(/\s+/);
+                        return parts.slice(1).join(' ');
+                    });
+                }
+            }
+            catch {
+                // Ignore errors - just means no uncommitted changes
+            }
+            // Get unpushed commits (only if on main branch)
+            let localCommits = [];
+            if (currentBranch === 'main') {
+                try {
+                    const { stdout } = await execAsync('git log origin/main..HEAD --format="%H|%s|%an"', { cwd, timeout: options?.timeout || 10000 });
+                    if (stdout) {
+                        localCommits = stdout.split('\n').filter(line => line.trim()).map(line => {
+                            const [sha, message, author] = line.split('|');
+                            return {
+                                sha: sha ? sha.substring(0, 8) : '',
+                                message: message || '',
+                                author: author || ''
+                            };
+                        });
+                    }
+                }
+                catch {
+                    // Ignore errors - might not have origin/main or no remote
+                }
+            }
+            return {
+                success: true,
+                output: `Branch: ${currentBranch}, Uncommitted: ${uncommittedFiles.length}, Unpushed: ${localCommits.length}`,
+                details: {
+                    currentBranch,
+                    uncommittedFiles,
+                    localCommits
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to check main branch'
+            };
+        }
+    }
+    /**
+     * EP599: Execute get_commits command
+     * Returns commits for a branch with pushed/unpushed status
+     */
+    async executeGetCommits(command, cwd, options) {
+        // Validate branch name
+        const validation = (0, git_validator_1.validateBranchName)(command.branch);
+        if (!validation.valid) {
+            return {
+                success: false,
+                error: validation.error || 'UNKNOWN_ERROR'
+            };
+        }
+        const limit = command.limit || 10;
+        const baseBranch = command.baseBranch || 'main';
+        try {
+            // Get commits unique to this branch (not in main)
+            let stdout;
+            try {
+                const result = await execAsync(`git log ${baseBranch}.."${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 10000 });
+                stdout = result.stdout;
+            }
+            catch (error) {
+                // Fallback: if comparison fails, show all commits on this branch
+                try {
+                    const result = await execAsync(`git log "${command.branch}" --pretty=format:"%H|%an|%ae|%aI|%s" -n ${limit} --`, { cwd, timeout: options?.timeout || 10000 });
+                    stdout = result.stdout;
+                }
+                catch (branchError) {
+                    // Branch doesn't exist locally
+                    return {
+                        success: false,
+                        error: 'BRANCH_NOT_FOUND',
+                        output: `Branch ${command.branch} not found locally`
+                    };
+                }
+            }
+            if (!stdout.trim()) {
+                return {
+                    success: true,
+                    output: 'No commits found',
+                    details: {
+                        commits: []
+                    }
+                };
+            }
+            // Parse commits
+            const commitLines = stdout.trim().split('\n');
+            // Check which commits have been pushed to remote
+            let remoteShas = new Set();
+            try {
+                const { stdout: remoteCommits } = await execAsync(`git log "origin/${command.branch}" --pretty=format:"%H" -n ${limit} --`, { cwd, timeout: options?.timeout || 10000 });
+                remoteShas = new Set(remoteCommits.trim().split('\n').filter(Boolean));
+            }
+            catch {
+                // Remote branch doesn't exist - all commits are local/unpushed
+            }
+            const commits = commitLines.map((line) => {
+                const [sha, authorName, authorEmail, date, ...messageParts] = line.split('|');
+                const message = messageParts.join('|'); // Handle pipes in commit messages
+                const isPushed = remoteShas.has(sha);
+                return {
+                    sha,
+                    message,
+                    authorName,
+                    authorEmail,
+                    date,
+                    isPushed
+                };
+            });
+            return {
+                success: true,
+                output: `Found ${commits.length} commits`,
+                details: {
+                    commits
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to get commits'
+            };
+        }
+    }
+    // ========================================
+    // EP599: Advanced operations for move-to-module and discard-main-changes
+    // ========================================
+    /**
+     * Execute git stash operations
+     */
+    async executeStash(command, cwd, options) {
+        try {
+            const args = ['stash'];
+            switch (command.operation) {
+                case 'push':
+                    args.push('push');
+                    if (command.includeUntracked) {
+                        args.push('--include-untracked');
+                    }
+                    if (command.message) {
+                        args.push('-m', command.message);
+                    }
+                    break;
+                case 'pop':
+                    args.push('pop');
+                    break;
+                case 'drop':
+                    args.push('drop');
+                    break;
+                case 'list':
+                    args.push('list');
+                    break;
+            }
+            return await this.runGitCommand(args, cwd, options);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Stash operation failed'
+            };
+        }
+    }
+    /**
+     * Execute git reset
+     */
+    async executeReset(command, cwd, options) {
+        try {
+            const args = ['reset', `--${command.mode}`];
+            if (command.target) {
+                args.push(command.target);
+            }
+            return await this.runGitCommand(args, cwd, options);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Reset failed'
+            };
+        }
+    }
+    /**
+     * Execute git merge
+     */
+    async executeMerge(command, cwd, options) {
+        try {
+            if (command.abort) {
+                return await this.runGitCommand(['merge', '--abort'], cwd, options);
+            }
+            // Validate branch name
+            const branchValidation = (0, git_validator_1.validateBranchName)(command.branch);
+            if (!branchValidation.valid) {
+                return {
+                    success: false,
+                    error: 'BRANCH_NOT_FOUND',
+                    output: branchValidation.error || 'Invalid branch name'
+                };
+            }
+            const args = ['merge', command.branch];
+            if (command.strategy === 'ours') {
+                args.push('--strategy=ours');
+            }
+            else if (command.strategy === 'theirs') {
+                args.push('--strategy-option=theirs');
+            }
+            if (command.noEdit) {
+                args.push('--no-edit');
+            }
+            const result = await this.runGitCommand(args, cwd, options);
+            // Check for merge conflicts
+            if (!result.success && result.output?.includes('CONFLICT')) {
+                result.details = result.details || {};
+                result.details.mergeConflicts = true;
+            }
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'MERGE_CONFLICT',
+                output: error.message || 'Merge failed'
+            };
+        }
+    }
+    /**
+     * Execute git cherry-pick
+     */
+    async executeCherryPick(command, cwd, options) {
+        try {
+            if (command.abort) {
+                return await this.runGitCommand(['cherry-pick', '--abort'], cwd, options);
+            }
+            const result = await this.runGitCommand(['cherry-pick', command.sha], cwd, options);
+            // Check for cherry-pick conflicts
+            if (!result.success && result.output?.includes('CONFLICT')) {
+                result.details = result.details || {};
+                result.details.cherryPickConflicts = true;
+            }
+            return result;
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'MERGE_CONFLICT',
+                output: error.message || 'Cherry-pick failed'
+            };
+        }
+    }
+    /**
+     * Execute git clean
+     */
+    async executeClean(command, cwd, options) {
+        try {
+            const args = ['clean'];
+            if (command.force) {
+                args.push('-f');
+            }
+            if (command.directories) {
+                args.push('-d');
+            }
+            return await this.runGitCommand(args, cwd, options);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Clean failed'
+            };
+        }
+    }
+    /**
+     * Execute git add
+     */
+    async executeAdd(command, cwd, options) {
+        try {
+            const args = ['add'];
+            if (command.all) {
+                args.push('-A');
+            }
+            else if (command.files && command.files.length > 0) {
+                // Validate file paths
+                const validation = (0, git_validator_1.validateFilePaths)(command.files);
+                if (!validation.valid) {
+                    return {
+                        success: false,
+                        error: 'UNKNOWN_ERROR',
+                        output: validation.error || 'Invalid file paths'
+                    };
+                }
+                args.push(...command.files);
+            }
+            else {
+                args.push('-A'); // Default to all
+            }
+            return await this.runGitCommand(args, cwd, options);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Add failed'
+            };
+        }
+    }
+    /**
+     * Execute git fetch
+     */
+    async executeFetch(command, cwd, options) {
+        try {
+            const args = ['fetch'];
+            if (command.remote) {
+                args.push(command.remote);
+                if (command.branch) {
+                    args.push(command.branch);
+                }
+            }
+            else {
+                args.push('origin');
+            }
+            return await this.runGitCommand(args, cwd, options);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'NETWORK_ERROR',
+                output: error.message || 'Fetch failed'
+            };
+        }
+    }
+    // ========================================
+    // EP599-3: Composite operations
+    // ========================================
+    /**
+     * Execute move_to_module - composite operation
+     * Moves commits/changes to a module branch with conflict handling
+     */
+    async executeMoveToModule(command, cwd, options) {
+        const { targetBranch, commitShas, conflictResolution } = command;
+        let hasStash = false;
+        const cherryPickedCommits = [];
+        try {
+            // Step 1: Get current branch
+            const { stdout: currentBranchOut } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd });
+            const currentBranch = currentBranchOut.trim();
+            // Step 2: Stash uncommitted changes
+            const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd });
+            if (statusOutput.trim()) {
+                try {
+                    await execAsync('git add -A', { cwd });
+                    const { stdout: stashHash } = await execAsync('git stash create -m "episoda-move-to-module"', { cwd });
+                    if (stashHash && stashHash.trim()) {
+                        await execAsync(`git stash store -m "episoda-move-to-module" ${stashHash.trim()}`, { cwd });
+                        await execAsync('git reset --hard HEAD', { cwd });
+                        hasStash = true;
+                    }
+                }
+                catch (stashError) {
+                    // Continue without stashing
+                }
+            }
+            // Step 3: Switch to main if we have commits to move
+            if (commitShas && commitShas.length > 0 && currentBranch !== 'main' && currentBranch !== 'master') {
+                await execAsync('git checkout main', { cwd });
+            }
+            // Step 4: Create or checkout target branch
+            let branchExists = false;
+            try {
+                await execAsync(`git rev-parse --verify ${targetBranch}`, { cwd });
+                branchExists = true;
+            }
+            catch {
+                branchExists = false;
+            }
+            if (!branchExists) {
+                await execAsync(`git checkout -b ${targetBranch}`, { cwd });
+            }
+            else {
+                await execAsync(`git checkout ${targetBranch}`, { cwd });
+                // Try to merge changes from main
+                if (currentBranch === 'main' || currentBranch === 'master') {
+                    try {
+                        const mergeStrategy = conflictResolution === 'ours' ? '--strategy=ours' :
+                            conflictResolution === 'theirs' ? '--strategy-option=theirs' : '';
+                        await execAsync(`git merge ${currentBranch} ${mergeStrategy} --no-edit`, { cwd });
+                    }
+                    catch (mergeError) {
+                        // Check for conflicts
+                        const { stdout: conflictStatus } = await execAsync('git status --porcelain', { cwd });
+                        if (conflictStatus.includes('UU ') || conflictStatus.includes('AA ') || conflictStatus.includes('DD ')) {
+                            const { stdout: conflictFiles } = await execAsync('git diff --name-only --diff-filter=U', { cwd });
+                            const conflictedFiles = conflictFiles.trim().split('\n').filter(Boolean);
+                            if (conflictResolution) {
+                                // Auto-resolve conflicts
+                                for (const file of conflictedFiles) {
+                                    await execAsync(`git checkout --${conflictResolution} "${file}"`, { cwd });
+                                    await execAsync(`git add "${file}"`, { cwd });
+                                }
+                                await execAsync('git commit --no-edit', { cwd });
+                            }
+                            else {
+                                // Abort merge and return conflict error
+                                await execAsync('git merge --abort', { cwd });
+                                return {
+                                    success: false,
+                                    error: 'MERGE_CONFLICT',
+                                    output: 'Merge conflicts detected',
+                                    details: {
+                                        hasConflicts: true,
+                                        conflictedFiles,
+                                        movedToBranch: targetBranch
+                                    }
+                                };
+                            }
+                        }
+                    }
+                }
+            }
+            // Step 5: Cherry-pick commits if provided
+            if (commitShas && commitShas.length > 0 && (currentBranch === 'main' || currentBranch === 'master')) {
+                for (const sha of commitShas) {
+                    try {
+                        // Check if commit already exists in branch
+                        const { stdout: logOutput } = await execAsync(`git log --format=%H ${targetBranch} | grep ${sha}`, { cwd }).catch(() => ({ stdout: '' }));
+                        if (!logOutput.trim()) {
+                            await execAsync(`git cherry-pick ${sha}`, { cwd });
+                            cherryPickedCommits.push(sha);
+                        }
+                    }
+                    catch (err) {
+                        await execAsync('git cherry-pick --abort', { cwd }).catch(() => { });
+                    }
+                }
+                // Reset main to origin/main
+                await execAsync('git checkout main', { cwd });
+                await execAsync('git reset --hard origin/main', { cwd });
+                await execAsync(`git checkout ${targetBranch}`, { cwd });
+            }
+            // Step 6: Apply stashed changes
+            if (hasStash) {
+                try {
+                    await execAsync('git stash pop', { cwd });
+                }
+                catch (stashError) {
+                    // Check for stash conflicts
+                    const { stdout: conflictStatus } = await execAsync('git status --porcelain', { cwd });
+                    if (conflictStatus.includes('UU ') || conflictStatus.includes('AA ')) {
+                        if (conflictResolution) {
+                            const { stdout: conflictFiles } = await execAsync('git diff --name-only --diff-filter=U', { cwd });
+                            const conflictedFiles = conflictFiles.trim().split('\n').filter(Boolean);
+                            for (const file of conflictedFiles) {
+                                await execAsync(`git checkout --${conflictResolution} "${file}"`, { cwd });
+                                await execAsync(`git add "${file}"`, { cwd });
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                success: true,
+                output: `Successfully moved to branch ${targetBranch}`,
+                details: {
+                    movedToBranch: targetBranch,
+                    cherryPickedCommits,
+                    currentBranch: targetBranch
+                }
+            };
+        }
+        catch (error) {
+            // Try to restore stash if something went wrong
+            if (hasStash) {
+                try {
+                    const { stdout: stashList } = await execAsync('git stash list', { cwd });
+                    if (stashList.includes('episoda-move-to-module')) {
+                        await execAsync('git stash pop', { cwd });
+                    }
+                }
+                catch (e) {
+                    // Ignore errors restoring stash
+                }
+            }
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Move to module failed'
+            };
+        }
+    }
+    /**
+     * Execute discard_main_changes - composite operation
+     * Discards all uncommitted files and local commits on main branch
+     */
+    async executeDiscardMainChanges(cwd, options) {
+        try {
+            // Step 1: Verify we're on main/master
+            const { stdout: currentBranchOut } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd });
+            const branch = currentBranchOut.trim();
+            if (branch !== 'main' && branch !== 'master') {
+                return {
+                    success: false,
+                    error: 'BRANCH_NOT_FOUND',
+                    output: `Cannot discard changes - not on main branch. Current branch: ${branch}`
+                };
+            }
+            let discardedFiles = 0;
+            // Step 2: Stash uncommitted changes (will be dropped)
+            const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd });
+            if (statusOutput.trim()) {
+                try {
+                    await execAsync('git stash --include-untracked', { cwd });
+                    discardedFiles = statusOutput.trim().split('\n').length;
+                }
+                catch (stashError) {
+                    // Continue - might be nothing to stash
+                }
+            }
+            // Step 3: Fetch and reset to origin
+            await execAsync('git fetch origin', { cwd });
+            await execAsync(`git reset --hard origin/${branch}`, { cwd });
+            // Step 4: Clean untracked files
+            try {
+                await execAsync('git clean -fd', { cwd });
+            }
+            catch (cleanError) {
+                // Non-critical
+            }
+            // Step 5: Drop the stash
+            try {
+                await execAsync('git stash drop', { cwd });
+            }
+            catch (dropError) {
+                // Stash might not exist
+            }
+            return {
+                success: true,
+                output: `Successfully discarded all changes and reset to origin/${branch}`,
+                details: {
+                    currentBranch: branch,
+                    discardedFiles
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Discard main changes failed'
+            };
+        }
+    }
+    // ========================================
+    // EP523: Branch sync operations
+    // ========================================
+    /**
+     * EP523: Get sync status of a branch relative to main
+     * Returns how many commits behind/ahead the branch is
+     */
+    async executeSyncStatus(command, cwd, options) {
+        try {
+            // Validate branch name
+            const validation = (0, git_validator_1.validateBranchName)(command.branch);
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    error: validation.error || 'UNKNOWN_ERROR'
+                };
+            }
+            // Fetch latest from remote to get accurate counts
+            try {
+                await execAsync('git fetch origin', { cwd, timeout: options?.timeout || 30000 });
+            }
+            catch (fetchError) {
+                // Network error - return what we can determine locally
+                return {
+                    success: false,
+                    error: 'NETWORK_ERROR',
+                    output: 'Unable to fetch from remote. Check your network connection.'
+                };
+            }
+            let commitsBehind = 0;
+            let commitsAhead = 0;
+            // Count commits the branch is BEHIND main (main has commits branch doesn't)
+            try {
+                const { stdout: behindOutput } = await execAsync(`git rev-list --count ${command.branch}..origin/main`, { cwd, timeout: options?.timeout || 10000 });
+                commitsBehind = parseInt(behindOutput.trim(), 10) || 0;
+            }
+            catch {
+                // Branch might not exist or no common ancestor
+                commitsBehind = 0;
+            }
+            // Count commits the branch is AHEAD of main (branch has commits main doesn't)
+            try {
+                const { stdout: aheadOutput } = await execAsync(`git rev-list --count origin/main..${command.branch}`, { cwd, timeout: options?.timeout || 10000 });
+                commitsAhead = parseInt(aheadOutput.trim(), 10) || 0;
+            }
+            catch {
+                // Branch might not exist or no common ancestor
+                commitsAhead = 0;
+            }
+            const isBehind = commitsBehind > 0;
+            const isAhead = commitsAhead > 0;
+            const needsSync = isBehind;
+            return {
+                success: true,
+                output: isBehind
+                    ? `Branch ${command.branch} is ${commitsBehind} commit(s) behind main`
+                    : `Branch ${command.branch} is up to date with main`,
+                details: {
+                    branchName: command.branch,
+                    commitsBehind,
+                    commitsAhead,
+                    isBehind,
+                    isAhead,
+                    needsSync
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to check sync status'
+            };
+        }
+    }
+    /**
+     * EP523: Sync local main branch with remote
+     * Used before creating new branches to ensure we branch from latest main
+     */
+    async executeSyncMain(cwd, options) {
+        try {
+            // Get current branch to restore later if needed
+            let currentBranch = '';
+            try {
+                const { stdout } = await execAsync('git branch --show-current', { cwd, timeout: 5000 });
+                currentBranch = stdout.trim();
+            }
+            catch {
+                // Ignore - might be detached HEAD
+            }
+            // Fetch latest from remote
+            try {
+                await execAsync('git fetch origin main', { cwd, timeout: options?.timeout || 30000 });
+            }
+            catch (fetchError) {
+                return {
+                    success: false,
+                    error: 'NETWORK_ERROR',
+                    output: 'Unable to fetch from remote. Check your network connection.'
+                };
+            }
+            // Check if we need to switch to main
+            const needsSwitch = currentBranch !== 'main' && currentBranch !== '';
+            if (needsSwitch) {
+                // Check for uncommitted changes first
+                const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd, timeout: 5000 });
+                if (statusOutput.trim()) {
+                    return {
+                        success: false,
+                        error: 'UNCOMMITTED_CHANGES',
+                        output: 'Cannot sync main: you have uncommitted changes. Commit or stash them first.',
+                        details: {
+                            uncommittedFiles: statusOutput.trim().split('\n').map(line => line.slice(3))
+                        }
+                    };
+                }
+                // Switch to main
+                await execAsync('git checkout main', { cwd, timeout: options?.timeout || 10000 });
+            }
+            // Pull latest main
+            try {
+                await execAsync('git pull origin main', { cwd, timeout: options?.timeout || 30000 });
+            }
+            catch (pullError) {
+                // Check for conflicts
+                if (pullError.message?.includes('CONFLICT') || pullError.stderr?.includes('CONFLICT')) {
+                    // Abort the merge
+                    await execAsync('git merge --abort', { cwd, timeout: 5000 }).catch(() => { });
+                    return {
+                        success: false,
+                        error: 'MERGE_CONFLICT',
+                        output: 'Conflict while syncing main. This is unexpected - main should not have local commits.'
+                    };
+                }
+                throw pullError;
+            }
+            // Switch back to original branch if we switched
+            if (needsSwitch && currentBranch) {
+                await execAsync(`git checkout "${currentBranch}"`, { cwd, timeout: options?.timeout || 10000 });
+            }
+            return {
+                success: true,
+                output: 'Successfully synced main with remote',
+                details: {
+                    currentBranch: needsSwitch ? currentBranch : 'main'
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to sync main'
+            };
+        }
+    }
+    /**
+     * EP523: Rebase a branch onto main
+     * Used when resuming work on a branch that's behind main
+     */
+    async executeRebaseBranch(command, cwd, options) {
+        try {
+            // Validate branch name
+            const validation = (0, git_validator_1.validateBranchName)(command.branch);
+            if (!validation.valid) {
+                return {
+                    success: false,
+                    error: validation.error || 'UNKNOWN_ERROR'
+                };
+            }
+            // Check for uncommitted changes
+            const { stdout: statusOutput } = await execAsync('git status --porcelain', { cwd, timeout: 5000 });
+            if (statusOutput.trim()) {
+                return {
+                    success: false,
+                    error: 'UNCOMMITTED_CHANGES',
+                    output: 'Cannot rebase: you have uncommitted changes. Commit or stash them first.',
+                    details: {
+                        uncommittedFiles: statusOutput.trim().split('\n').map(line => line.slice(3))
+                    }
+                };
+            }
+            // Get current branch
+            const { stdout: currentBranchOut } = await execAsync('git branch --show-current', { cwd, timeout: 5000 });
+            const currentBranch = currentBranchOut.trim();
+            // Ensure we're on the target branch
+            if (currentBranch !== command.branch) {
+                await execAsync(`git checkout "${command.branch}"`, { cwd, timeout: options?.timeout || 10000 });
+            }
+            // Fetch latest main
+            await execAsync('git fetch origin main', { cwd, timeout: options?.timeout || 30000 });
+            // Perform rebase
+            try {
+                await execAsync('git rebase origin/main', { cwd, timeout: options?.timeout || 60000 });
+            }
+            catch (rebaseError) {
+                const errorOutput = (rebaseError.stderr || '') + (rebaseError.stdout || '');
+                // Check for conflicts
+                if (errorOutput.includes('CONFLICT') || errorOutput.includes('could not apply')) {
+                    // Get conflicting files
+                    let conflictFiles = [];
+                    try {
+                        const { stdout: conflictOutput } = await execAsync('git diff --name-only --diff-filter=U', { cwd, timeout: 5000 });
+                        conflictFiles = conflictOutput.trim().split('\n').filter(Boolean);
+                    }
+                    catch {
+                        // Ignore - try alternate method
+                        try {
+                            const { stdout: statusOut } = await execAsync('git status --porcelain', { cwd, timeout: 5000 });
+                            conflictFiles = statusOut
+                                .trim()
+                                .split('\n')
+                                .filter(line => line.startsWith('UU ') || line.startsWith('AA ') || line.startsWith('DD '))
+                                .map(line => line.slice(3));
+                        }
+                        catch {
+                            // Couldn't get conflict files
+                        }
+                    }
+                    return {
+                        success: false,
+                        error: 'REBASE_CONFLICT',
+                        output: `Rebase conflict in ${conflictFiles.length} file(s). Resolve conflicts then use rebase_continue, or use rebase_abort to cancel.`,
+                        details: {
+                            inRebase: true,
+                            rebaseConflicts: conflictFiles,
+                            hasConflicts: true,
+                            conflictedFiles: conflictFiles
+                        }
+                    };
+                }
+                throw rebaseError;
+            }
+            return {
+                success: true,
+                output: `Successfully rebased ${command.branch} onto main`,
+                details: {
+                    branchName: command.branch,
+                    inRebase: false
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Rebase failed'
+            };
+        }
+    }
+    /**
+     * EP523: Abort an in-progress rebase
+     * Returns to the state before rebase was started
+     */
+    async executeRebaseAbort(cwd, options) {
+        try {
+            await execAsync('git rebase --abort', { cwd, timeout: options?.timeout || 10000 });
+            return {
+                success: true,
+                output: 'Rebase aborted. Your branch has been restored to its previous state.',
+                details: {
+                    inRebase: false
+                }
+            };
+        }
+        catch (error) {
+            // Check if there's no rebase in progress
+            if (error.message?.includes('No rebase in progress') || error.stderr?.includes('No rebase in progress')) {
+                return {
+                    success: true,
+                    output: 'No rebase in progress.',
+                    details: {
+                        inRebase: false
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to abort rebase'
+            };
+        }
+    }
+    /**
+     * EP523: Continue a paused rebase after conflicts are resolved
+     */
+    async executeRebaseContinue(cwd, options) {
+        try {
+            // Stage all resolved files
+            await execAsync('git add -A', { cwd, timeout: 5000 });
+            // Continue the rebase
+            await execAsync('git rebase --continue', { cwd, timeout: options?.timeout || 60000 });
+            return {
+                success: true,
+                output: 'Rebase continued successfully.',
+                details: {
+                    inRebase: false
+                }
+            };
+        }
+        catch (error) {
+            const errorOutput = (error.stderr || '') + (error.stdout || '');
+            // Check if there are still conflicts
+            if (errorOutput.includes('CONFLICT') || errorOutput.includes('could not apply')) {
+                // Get remaining conflict files
+                let conflictFiles = [];
+                try {
+                    const { stdout: conflictOutput } = await execAsync('git diff --name-only --diff-filter=U', { cwd, timeout: 5000 });
+                    conflictFiles = conflictOutput.trim().split('\n').filter(Boolean);
+                }
+                catch {
+                    // Ignore
+                }
+                return {
+                    success: false,
+                    error: 'REBASE_CONFLICT',
+                    output: 'More conflicts encountered. Resolve them and try again.',
+                    details: {
+                        inRebase: true,
+                        rebaseConflicts: conflictFiles,
+                        hasConflicts: true,
+                        conflictedFiles: conflictFiles
+                    }
+                };
+            }
+            // Check if there's no rebase in progress
+            if (errorOutput.includes('No rebase in progress')) {
+                return {
+                    success: true,
+                    output: 'No rebase in progress.',
+                    details: {
+                        inRebase: false
+                    }
+                };
+            }
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to continue rebase'
+            };
+        }
+    }
+    /**
+     * EP523: Check if a rebase is currently in progress
+     */
+    async executeRebaseStatus(cwd, options) {
+        try {
+            // Check for rebase-merge directory (indicates rebase in progress)
+            let inRebase = false;
+            let rebaseConflicts = [];
+            try {
+                const { stdout: gitDir } = await execAsync('git rev-parse --git-dir', { cwd, timeout: 5000 });
+                const gitDirPath = gitDir.trim();
+                // Check for rebase directories
+                const fs = await Promise.resolve().then(() => __importStar(require('fs'))).then(m => m.promises);
+                const rebaseMergePath = `${gitDirPath}/rebase-merge`;
+                const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
+                try {
+                    await fs.access(rebaseMergePath);
+                    inRebase = true;
+                }
+                catch {
+                    try {
+                        await fs.access(rebaseApplyPath);
+                        inRebase = true;
+                    }
+                    catch {
+                        inRebase = false;
+                    }
+                }
+            }
+            catch {
+                // If we can't determine, check via status
+                try {
+                    const { stdout: statusOutput } = await execAsync('git status', { cwd, timeout: 5000 });
+                    inRebase = statusOutput.includes('rebase in progress') ||
+                        statusOutput.includes('interactive rebase in progress') ||
+                        statusOutput.includes('You are currently rebasing');
+                }
+                catch {
+                    inRebase = false;
+                }
+            }
+            // If in rebase, get conflict files
+            if (inRebase) {
+                try {
+                    const { stdout: conflictOutput } = await execAsync('git diff --name-only --diff-filter=U', { cwd, timeout: 5000 });
+                    rebaseConflicts = conflictOutput.trim().split('\n').filter(Boolean);
+                }
+                catch {
+                    // No conflicts or couldn't get them
+                }
+            }
+            return {
+                success: true,
+                output: inRebase
+                    ? `Rebase in progress with ${rebaseConflicts.length} conflicting file(s)`
+                    : 'No rebase in progress',
+                details: {
+                    inRebase,
+                    rebaseConflicts,
+                    hasConflicts: rebaseConflicts.length > 0
+                }
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: 'UNKNOWN_ERROR',
+                output: error.message || 'Failed to check rebase status'
+            };
+        }
+    }
+    /**
+     * Run a git command and return structured result
+     */
+    async runGitCommand(args, cwd, options) {
+        try {
+            // Sanitize arguments
+            const sanitizedArgs = (0, git_validator_1.sanitizeArgs)(args);
+            // Build command
+            const command = ['git', ...sanitizedArgs].join(' ');
+            // Execute with timeout
+            const timeout = options?.timeout || 30000; // 30 second default
+            const execOptions = {
+                cwd,
+                timeout,
+                env: options?.env || process.env,
+                maxBuffer: 1024 * 1024 * 10 // 10MB buffer
+            };
+            const { stdout, stderr } = await execAsync(command, execOptions);
+            // Combine output
+            const output = (stdout + stderr).trim();
+            // Extract additional details
+            const details = {};
+            // Try to extract branch name
+            const branchName = (0, git_parser_1.extractBranchName)(output);
+            if (branchName) {
+                details.branchName = branchName;
+            }
+            // Check for detached HEAD
+            if ((0, git_parser_1.isDetachedHead)(output)) {
+                details.branchName = 'HEAD (detached)';
+            }
+            return {
+                success: true,
+                output,
+                details: Object.keys(details).length > 0 ? details : undefined
+            };
+        }
+        catch (error) {
+            // Parse error
+            const stderr = error.stderr || '';
+            const stdout = error.stdout || '';
+            const exitCode = error.code || 1;
+            // Determine error code
+            const errorCode = (0, git_parser_1.parseGitError)(stderr, stdout, exitCode);
+            // Extract additional details based on error type
+            const details = {
+                exitCode
+            };
+            // Parse conflicts if merge conflict
+            if (errorCode === 'MERGE_CONFLICT') {
+                const conflicts = (0, git_parser_1.parseMergeConflicts)(stdout + stderr);
+                if (conflicts.length > 0) {
+                    details.conflictingFiles = conflicts;
+                }
+            }
+            // Parse status for uncommitted changes
+            if (errorCode === 'UNCOMMITTED_CHANGES') {
+                try {
+                    const statusResult = await this.executeStatus(cwd, options);
+                    if (statusResult.details?.uncommittedFiles) {
+                        details.uncommittedFiles = statusResult.details.uncommittedFiles;
+                    }
+                }
+                catch {
+                    // Ignore errors when getting status
+                }
+            }
+            return {
+                success: false,
+                error: errorCode,
+                output: (stdout + stderr).trim(),
+                details
+            };
+        }
+    }
+    /**
+     * Validate that git is installed
+     */
+    async validateGitInstalled() {
+        try {
+            await execAsync('git --version', { timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if directory is a git repository
+     */
+    async isGitRepository(cwd) {
+        try {
+            await execAsync('git rev-parse --git-dir', { cwd, timeout: 5000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Detect the git working directory (repository root)
+     * @returns Path to the git repository root
+     */
+    async detectWorkingDirectory(startPath) {
+        try {
+            const { stdout } = await execAsync('git rev-parse --show-toplevel', {
+                cwd: startPath || process.cwd(),
+                timeout: 5000
+            });
+            return stdout.trim();
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.GitExecutor = GitExecutor;
+//# sourceMappingURL=git-executor.js.map