@generacy-ai/workflow-engine 0.0.0-preview-20260304013206

package/dist/actions/github/client/gh-cli.js

@@ -0,0 +1,781 @@
+import { executeCommand, parseJSONSafe } from '../../cli-utils.js';
+/**
+ * GitHubClient implementation using gh CLI and git commands
+ */
+export class GhCliGitHubClient {
+    workdir;
+    constructor(workdir) {
+        this.workdir = workdir ?? process.cwd();
+    }
+    // ==========================================================================
+    // Repository Info
+    // ==========================================================================
+    async getRepoInfo() {
+        const result = await executeCommand('gh', [
+            'repo', 'view',
+            '--json', 'owner,name,defaultBranchRef',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to get repo info: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            throw new Error('Failed to parse repo info');
+        }
+        return {
+            owner: data.owner.login,
+            repo: data.name,
+            default_branch: data.defaultBranchRef.name,
+        };
+    }
+    // ==========================================================================
+    // Issue Operations
+    // ==========================================================================
+    async getIssue(owner, repo, number) {
+        const result = await executeCommand('gh', [
+            'issue', 'view', String(number),
+            '-R', `${owner}/${repo}`,
+            '--json', 'number,title,body,state,labels,assignees,milestone,createdAt,updatedAt',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to get issue #${number}: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            throw new Error('Failed to parse issue data');
+        }
+        return {
+            number: data['number'],
+            title: data['title'],
+            body: data['body'] ?? '',
+            state: data['state'].toLowerCase(),
+            labels: (data['labels'] ?? []).map(l => ({
+                name: l.name,
+                color: l.color,
+                description: l.description,
+            })),
+            assignees: (data['assignees'] ?? []).map(a => a.login),
+            milestone: data['milestone'] ? {
+                number: data['milestone'].number,
+                title: data['milestone'].title,
+                state: 'open',
+            } : undefined,
+            created_at: data['createdAt'],
+            updated_at: data['updatedAt'],
+        };
+    }
+    async listIssuesWithLabel(owner, repo, label) {
+        const result = await executeCommand('gh', [
+            'issue', 'list',
+            '-R', `${owner}/${repo}`,
+            '--label', label,
+            '--state', 'open',
+            '--json', 'number,title,body,state,labels,assignees,milestone,createdAt,updatedAt',
+            '--limit', '100',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to list issues with label "${label}": ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            return [];
+        }
+        return data.map(item => ({
+            number: item['number'],
+            title: item['title'],
+            body: item['body'] ?? '',
+            state: (item['state'] ?? 'open').toLowerCase(),
+            labels: (item['labels'] ?? []).map(l => ({
+                name: l.name,
+                color: l.color,
+                description: l.description,
+            })),
+            assignees: (item['assignees'] ?? []).map(a => a.login),
+            milestone: item['milestone'] ? {
+                number: item['milestone'].number,
+                title: item['milestone'].title,
+                state: 'open',
+            } : undefined,
+            created_at: item['createdAt'],
+            updated_at: item['updatedAt'],
+        }));
+    }
+    async updateIssue(owner, repo, number, data) {
+        const args = ['issue', 'edit', String(number), '-R', `${owner}/${repo}`];
+        if (data.title) {
+            args.push('--title', data.title);
+        }
+        if (data.body !== undefined) {
+            args.push('--body', data.body);
+        }
+        if (data.labels) {
+            // Clear existing labels and add new ones
+            args.push('--remove-label', '*');
+            for (const label of data.labels) {
+                args.push('--add-label', label);
+            }
+        }
+        if (data.assignees) {
+            for (const assignee of data.assignees) {
+                args.push('--add-assignee', assignee);
+            }
+        }
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to update issue #${number}: ${result.stderr}`);
+        }
+    }
+    async addIssueComment(owner, repo, number, body) {
+        const result = await executeCommand('gh', [
+            'issue', 'comment', String(number),
+            '-R', `${owner}/${repo}`,
+            '--body', body,
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to add comment to issue #${number}: ${result.stderr}`);
+        }
+        // gh doesn't return the comment details, so we need to fetch the latest comment
+        const comments = await this.getIssueComments(owner, repo, number);
+        const latest = comments[comments.length - 1];
+        if (!latest) {
+            throw new Error('Failed to get created comment');
+        }
+        return latest;
+    }
+    async getIssueComments(owner, repo, number) {
+        const result = await executeCommand('gh', [
+            'issue', 'view', String(number),
+            '-R', `${owner}/${repo}`,
+            '--json', 'comments',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to get comments for issue #${number}: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            return [];
+        }
+        return data.comments.map(c => ({
+            id: parseInt(c.id.split('/').pop() ?? '0', 10),
+            body: c.body,
+            author: c.author.login,
+            created_at: c.createdAt,
+            updated_at: c.updatedAt,
+        }));
+    }
+    async updateComment(owner, repo, commentId, body) {
+        // gh CLI doesn't have a direct command to edit comments, use API
+        const result = await executeCommand('gh', [
+            'api',
+            '-X', 'PATCH',
+            `/repos/${owner}/${repo}/issues/comments/${commentId}`,
+            '-f', `body=${body}`,
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to update comment ${commentId}: ${result.stderr}`);
+        }
+    }
+    // ==========================================================================
+    // PR Operations
+    // ==========================================================================
+    async createPullRequest(owner, repo, data) {
+        const args = [
+            'pr', 'create',
+            '-R', `${owner}/${repo}`,
+            '--title', data.title,
+            '--body', data.body ?? '',
+            '--head', data.head,
+            '--base', data.base,
+        ];
+        if (data.draft) {
+            args.push('--draft');
+        }
+        // Add JSON output for details
+        args.push('--json', 'number,url,state,headRefName,baseRefName,isDraft,title,body,createdAt,updatedAt');
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to create PR: ${result.stderr}`);
+        }
+        const parsed = parseJSONSafe(result.stdout);
+        if (!parsed) {
+            // Try to extract URL from output
+            const urlMatch = result.stdout.match(/https:\/\/github\.com\/[^\s]+\/pull\/(\d+)/);
+            if (urlMatch) {
+                return {
+                    number: parseInt(urlMatch[1], 10),
+                    title: data.title,
+                    body: data.body ?? '',
+                    state: data.draft ? 'open' : 'open',
+                    draft: data.draft ?? false,
+                    head: { ref: data.head, sha: '', repo: `${owner}/${repo}` },
+                    base: { ref: data.base, sha: '', repo: `${owner}/${repo}` },
+                    labels: [],
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                };
+            }
+            throw new Error('Failed to parse PR creation response');
+        }
+        return {
+            number: parsed['number'],
+            title: parsed['title'],
+            body: parsed['body'] ?? '',
+            state: 'open',
+            draft: parsed['isDraft'] ?? false,
+            head: { ref: parsed['headRefName'], sha: '', repo: `${owner}/${repo}` },
+            base: { ref: parsed['baseRefName'], sha: '', repo: `${owner}/${repo}` },
+            labels: [],
+            created_at: parsed['createdAt'],
+            updated_at: parsed['updatedAt'],
+        };
+    }
+    async getPullRequest(owner, repo, number) {
+        const result = await executeCommand('gh', [
+            'pr', 'view', String(number),
+            '-R', `${owner}/${repo}`,
+            '--json', 'number,title,body,state,isDraft,headRefName,baseRefName,labels,mergeable,createdAt,updatedAt',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to get PR #${number}: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            throw new Error('Failed to parse PR data');
+        }
+        const state = data['state'].toLowerCase();
+        return {
+            number: data['number'],
+            title: data['title'],
+            body: data['body'] ?? '',
+            state: state === 'merged' ? 'merged' : state === 'closed' ? 'closed' : 'open',
+            draft: data['isDraft'] ?? false,
+            head: { ref: data['headRefName'], sha: '', repo: `${owner}/${repo}` },
+            base: { ref: data['baseRefName'], sha: '', repo: `${owner}/${repo}` },
+            labels: (data['labels'] ?? []).map(l => ({
+                name: l.name,
+                color: l.color,
+            })),
+            mergeable: data['mergeable'],
+            created_at: data['createdAt'],
+            updated_at: data['updatedAt'],
+        };
+    }
+    async updatePullRequest(owner, repo, number, data) {
+        const args = ['pr', 'edit', String(number), '-R', `${owner}/${repo}`];
+        if (data.title) {
+            args.push('--title', data.title);
+        }
+        if (data.body !== undefined) {
+            args.push('--body', data.body);
+        }
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to update PR #${number}: ${result.stderr}`);
+        }
+        // Handle state change separately
+        if (data.state === 'closed') {
+            const closeResult = await executeCommand('gh', [
+                'pr', 'close', String(number),
+                '-R', `${owner}/${repo}`,
+            ], { cwd: this.workdir });
+            if (closeResult.exitCode !== 0) {
+                throw new Error(`Failed to close PR #${number}: ${closeResult.stderr}`);
+            }
+        }
+    }
+    async markPRReady(owner, repo, number) {
+        const result = await executeCommand('gh', [
+            'pr', 'ready', String(number),
+            '-R', `${owner}/${repo}`,
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to mark PR #${number} as ready: ${result.stderr}`);
+        }
+    }
+    async getPRComments(owner, repo, number) {
+        // Get review comments using API
+        const result = await executeCommand('gh', [
+            'api',
+            `/repos/${owner}/${repo}/pulls/${number}/comments`,
+            '--jq', '.[] | {id: .id, body: .body, author: .user.login, path: .path, line: .line, in_reply_to_id: .in_reply_to_id, created_at: .created_at, updated_at: .updated_at}',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            // No comments is not an error
+            return [];
+        }
+        const lines = result.stdout.trim().split('\n').filter(l => l);
+        const comments = [];
+        for (const line of lines) {
+            const data = parseJSONSafe(line);
+            if (!data)
+                continue;
+            comments.push({
+                id: data['id'],
+                body: data['body'],
+                author: data['author'],
+                path: data['path'],
+                line: data['line'],
+                in_reply_to_id: data['in_reply_to_id'],
+                created_at: data['created_at'],
+                updated_at: data['updated_at'],
+            });
+        }
+        return comments;
+    }
+    async replyToPRComment(owner, repo, number, commentId, body) {
+        const result = await executeCommand('gh', [
+            'api',
+            '-X', 'POST',
+            `/repos/${owner}/${repo}/pulls/${number}/comments/${commentId}/replies`,
+            '-f', `body=${body}`,
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to reply to comment ${commentId}: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            throw new Error('Failed to parse reply response');
+        }
+        return {
+            id: data['id'],
+            body: data['body'],
+            author: data['user'].login,
+            created_at: data['created_at'],
+            updated_at: data['updated_at'],
+        };
+    }
+    async listOpenPullRequests(owner, repo) {
+        const result = await executeCommand('gh', [
+            'pr', 'list',
+            '-R', `${owner}/${repo}`,
+            '--state', 'open',
+            '--json', 'number,title,body,state,isDraft,headRefName,baseRefName,labels,createdAt,updatedAt',
+            '--limit', '100',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to list open PRs for ${owner}/${repo}: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data) {
+            return [];
+        }
+        return data.map(pr => ({
+            number: pr['number'],
+            title: pr['title'],
+            body: pr['body'] ?? '',
+            state: 'open',
+            draft: pr['isDraft'] ?? false,
+            head: { ref: pr['headRefName'], sha: '', repo: `${owner}/${repo}` },
+            base: { ref: pr['baseRefName'], sha: '', repo: `${owner}/${repo}` },
+            labels: (pr['labels'] ?? []).map(l => ({
+                name: l.name,
+                color: l.color,
+            })),
+            created_at: pr['createdAt'],
+            updated_at: pr['updatedAt'],
+        }));
+    }
+    async findPRForBranch(owner, repo, branch) {
+        const result = await executeCommand('gh', [
+            'pr', 'list',
+            '-R', `${owner}/${repo}`,
+            '--head', branch,
+            '--json', 'number,title,body,state,isDraft,headRefName,baseRefName,labels,createdAt,updatedAt',
+            '--limit', '1',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            return null;
+        }
+        const data = parseJSONSafe(result.stdout);
+        if (!data || data.length === 0) {
+            return null;
+        }
+        const pr = data[0];
+        return {
+            number: pr['number'],
+            title: pr['title'],
+            body: pr['body'] ?? '',
+            state: pr['state'].toLowerCase() === 'merged' ? 'merged' : 'open',
+            draft: pr['isDraft'] ?? false,
+            head: { ref: pr['headRefName'], sha: '', repo: `${owner}/${repo}` },
+            base: { ref: pr['baseRefName'], sha: '', repo: `${owner}/${repo}` },
+            labels: (pr['labels'] ?? []).map(l => ({
+                name: l.name,
+                color: l.color,
+            })),
+            created_at: pr['createdAt'],
+            updated_at: pr['updatedAt'],
+        };
+    }
+    // ==========================================================================
+    // Label Operations
+    // ==========================================================================
+    async addLabels(owner, repo, number, labels) {
+        if (labels.length === 0)
+            return;
+        const args = ['issue', 'edit', String(number), '-R', `${owner}/${repo}`];
+        for (const label of labels) {
+            args.push('--add-label', label);
+        }
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to add labels: ${result.stderr}`);
+        }
+    }
+    async removeLabels(owner, repo, number, labels) {
+        if (labels.length === 0)
+            return;
+        const args = ['issue', 'edit', String(number), '-R', `${owner}/${repo}`];
+        for (const label of labels) {
+            args.push('--remove-label', label);
+        }
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            // Label might not exist, don't fail
+            if (!result.stderr.includes('not found')) {
+                throw new Error(`Failed to remove labels: ${result.stderr}`);
+            }
+        }
+    }
+    async getRepoLabels(owner, repo) {
+        const result = await executeCommand('gh', [
+            'label', 'list',
+            '-R', `${owner}/${repo}`,
+            '--json', 'name,color,description',
+            '--limit', '1000',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to get labels: ${result.stderr}`);
+        }
+        const data = parseJSONSafe(result.stdout);
+        return data ?? [];
+    }
+    async createOrUpdateLabel(owner, repo, label) {
+        // Check if label exists
+        const existing = await this.getRepoLabels(owner, repo);
+        const exists = existing.some(l => l.name === label.name);
+        if (exists) {
+            // Update
+            const args = [
+                'label', 'edit', label.name,
+                '-R', `${owner}/${repo}`,
+                '--color', label.color.replace('#', ''),
+            ];
+            if (label.description) {
+                args.push('--description', label.description);
+            }
+            const result = await executeCommand('gh', args, { cwd: this.workdir });
+            if (result.exitCode !== 0) {
+                throw new Error(`Failed to update label ${label.name}: ${result.stderr}`);
+            }
+            return { created: false };
+        }
+        else {
+            // Create
+            const args = [
+                'label', 'create', label.name,
+                '-R', `${owner}/${repo}`,
+                '--color', label.color.replace('#', ''),
+            ];
+            if (label.description) {
+                args.push('--description', label.description);
+            }
+            const result = await executeCommand('gh', args, { cwd: this.workdir });
+            if (result.exitCode !== 0) {
+                throw new Error(`Failed to create label ${label.name}: ${result.stderr}`);
+            }
+            return { created: true };
+        }
+    }
+    // ==========================================================================
+    // Git Operations (Local)
+    // ==========================================================================
+    async getStatus() {
+        const branchResult = await executeCommand('git', ['branch', '--show-current'], { cwd: this.workdir });
+        const branch = branchResult.stdout.trim();
+        const statusResult = await executeCommand('git', ['status', '--porcelain'], { cwd: this.workdir });
+        const lines = statusResult.stdout.split('\n').filter(l => l);
+        const staged = [];
+        const unstaged = [];
+        const untracked = [];
+        for (const line of lines) {
+            const indexStatus = line[0];
+            const workingStatus = line[1];
+            const file = line.substring(3);
+            if (indexStatus === '?' && workingStatus === '?') {
+                untracked.push(file);
+            }
+            else {
+                if (indexStatus && indexStatus !== ' ' && indexStatus !== '?') {
+                    staged.push(file);
+                }
+                if (workingStatus && workingStatus !== ' ' && workingStatus !== '?') {
+                    unstaged.push(file);
+                }
+            }
+        }
+        return {
+            branch,
+            has_changes: lines.length > 0,
+            staged,
+            unstaged,
+            untracked,
+        };
+    }
+    async getCurrentBranch() {
+        const result = await executeCommand('git', ['branch', '--show-current'], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to get current branch: ${result.stderr}`);
+        }
+        return result.stdout.trim();
+    }
+    async branchExists(branch, remote = false) {
+        if (remote) {
+            const result = await executeCommand('git', ['ls-remote', '--heads', 'origin', branch], { cwd: this.workdir });
+            return result.stdout.includes(branch);
+        }
+        else {
+            const result = await executeCommand('git', ['branch', '--list', branch], { cwd: this.workdir });
+            return result.stdout.trim().length > 0;
+        }
+    }
+    async createBranch(name, startPoint) {
+        const args = ['checkout', '-b', name];
+        if (startPoint) {
+            args.push(startPoint);
+        }
+        const result = await executeCommand('git', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to create branch ${name}: ${result.stderr}`);
+        }
+    }
+    async checkout(branch) {
+        const result = await executeCommand('git', ['checkout', branch], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to checkout ${branch}: ${result.stderr}`);
+        }
+    }
+    async stageFiles(files) {
+        if (files.length === 0)
+            return;
+        const result = await executeCommand('git', ['add', ...files], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to stage files: ${result.stderr}`);
+        }
+    }
+    async stageAll() {
+        const result = await executeCommand('git', ['add', '-A'], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to stage all: ${result.stderr}`);
+        }
+    }
+    async commit(message) {
+        const result = await executeCommand('git', ['commit', '-m', message], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to commit: ${result.stderr}`);
+        }
+        // Get the commit SHA
+        const shaResult = await executeCommand('git', ['rev-parse', 'HEAD'], { cwd: this.workdir });
+        const sha = shaResult.stdout.trim();
+        // Get committed files
+        const diffResult = await executeCommand('git', ['diff-tree', '--no-commit-id', '--name-only', '-r', 'HEAD'], { cwd: this.workdir });
+        const files = diffResult.stdout.split('\n').filter(f => f);
+        return {
+            sha,
+            files_committed: files,
+        };
+    }
+    async push(remote = 'origin', branch, setUpstream = false) {
+        const currentBranch = branch ?? await this.getCurrentBranch();
+        const args = ['push', remote, currentBranch];
+        if (setUpstream) {
+            args.splice(1, 0, '-u');
+        }
+        const result = await executeCommand('git', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to push: ${result.stderr}`);
+        }
+        return {
+            success: true,
+            ref: currentBranch,
+            remote,
+        };
+    }
+    async fetch(remote = 'origin', prune = true) {
+        const args = ['fetch', remote];
+        if (prune) {
+            args.push('--prune');
+        }
+        const result = await executeCommand('git', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to fetch: ${result.stderr}`);
+        }
+    }
+    async merge(branch, noCommit = false) {
+        const args = ['merge', branch];
+        if (noCommit) {
+            args.push('--no-commit');
+        }
+        const result = await executeCommand('git', args, { cwd: this.workdir });
+        // Check for conflicts
+        if (result.exitCode !== 0 && result.stdout.includes('CONFLICT')) {
+            const conflicted = await this.getConflictedFiles();
+            const conflicts = conflicted.map(path => ({
+                path,
+                ours: '',
+                theirs: '',
+                resolved: false,
+            }));
+            return {
+                success: false,
+                commits_merged: 0,
+                already_up_to_date: false,
+                conflicts,
+                summary: `Merge conflict in ${conflicts.length} file(s)`,
+            };
+        }
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to merge ${branch}: ${result.stderr}`);
+        }
+        // Check if already up to date
+        if (result.stdout.includes('Already up to date')) {
+            return {
+                success: true,
+                commits_merged: 0,
+                already_up_to_date: true,
+                conflicts: [],
+                summary: 'Already up to date',
+            };
+        }
+        // Count commits merged (rough estimate from output)
+        const commitMatch = result.stdout.match(/(\d+) files? changed/);
+        const filesChanged = commitMatch ? parseInt(commitMatch[1], 10) : 0;
+        return {
+            success: true,
+            commits_merged: filesChanged > 0 ? 1 : 0,
+            already_up_to_date: false,
+            conflicts: [],
+            summary: result.stdout.trim().split('\n')[0] ?? 'Merge completed',
+        };
+    }
+    async mergeAbort() {
+        const result = await executeCommand('git', ['merge', '--abort'], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to abort merge: ${result.stderr}`);
+        }
+    }
+    async stash(message) {
+        const args = ['stash', 'push'];
+        if (message) {
+            args.push('-m', message);
+        }
+        const result = await executeCommand('git', args, { cwd: this.workdir });
+        // Returns true if something was stashed
+        return !result.stdout.includes('No local changes to save');
+    }
+    async stashPop() {
+        const result = await executeCommand('git', ['stash', 'pop'], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            if (result.stderr.includes('CONFLICT')) {
+                return { success: false, conflicts: true };
+            }
+            throw new Error(`Failed to pop stash: ${result.stderr}`);
+        }
+        return { success: true, conflicts: false };
+    }
+    async getConflictedFiles() {
+        const result = await executeCommand('git', ['diff', '--name-only', '--diff-filter=U'], { cwd: this.workdir });
+        return result.stdout.split('\n').filter(f => f);
+    }
+    async getDefaultBranch() {
+        // Try to get from remote
+        const result = await executeCommand('git', ['symbolic-ref', 'refs/remotes/origin/HEAD'], { cwd: this.workdir });
+        if (result.exitCode === 0) {
+            return result.stdout.trim().replace('refs/remotes/origin/', '');
+        }
+        // Fallback to checking common names
+        for (const branch of ['develop', 'main', 'master']) {
+            const exists = await this.branchExists(branch, true);
+            if (exists)
+                return branch;
+        }
+        return 'main';
+    }
+    async getCommitsBetween(base, head) {
+        const result = await executeCommand('git', [
+            'log', `${base}..${head}`,
+            '--format=%H|%s',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            return [];
+        }
+        return result.stdout.split('\n').filter(l => l).map(line => {
+            const [sha, ...messageParts] = line.split('|');
+            return {
+                sha: sha ?? '',
+                message: messageParts.join('|'),
+            };
+        });
+    }
+    // ==========================================================================
+    // Alias Methods (convenience wrappers)
+    // ==========================================================================
+    async listBranches(owner, repo) {
+        // List remote branches using gh api
+        const result = await executeCommand('gh', [
+            'api',
+            `/repos/${owner}/${repo}/branches`,
+            '--jq', '.[].name',
+        ], { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            // Fallback to git
+            const gitResult = await executeCommand('git', [
+                'branch', '-r', '--format=%(refname:short)',
+            ], { cwd: this.workdir });
+            return gitResult.stdout.split('\n')
+                .filter(b => b)
+                .map(b => b.replace('origin/', ''));
+        }
+        return result.stdout.split('\n').filter(b => b);
+    }
+    async createPR(owner, repo, data) {
+        return this.createPullRequest(owner, repo, data);
+    }
+    async updatePR(owner, repo, number, data) {
+        return this.updatePullRequest(owner, repo, number, data);
+    }
+    async getPRForBranch(owner, repo, branch) {
+        return this.findPRForBranch(owner, repo, branch);
+    }
+    async listLabels(owner, repo) {
+        return this.getRepoLabels(owner, repo);
+    }
+    async createLabel(owner, repo, name, color, description) {
+        const args = [
+            'label', 'create', name,
+            '-R', `${owner}/${repo}`,
+            '--color', color.replace('#', ''),
+        ];
+        if (description) {
+            args.push('--description', description);
+        }
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to create label ${name}: ${result.stderr}`);
+        }
+    }
+    async updateLabel(owner, repo, name, data) {
+        const args = ['label', 'edit', name, '-R', `${owner}/${repo}`];
+        if (data.color) {
+            args.push('--color', data.color.replace('#', ''));
+        }
+        if (data.description !== undefined) {
+            args.push('--description', data.description);
+        }
+        const result = await executeCommand('gh', args, { cwd: this.workdir });
+        if (result.exitCode !== 0) {
+            throw new Error(`Failed to update label ${name}: ${result.stderr}`);
+        }
+    }
+}
+//# sourceMappingURL=gh-cli.js.map