factory-factory 0.2.5 → 0.2.7

package/dist/src/backend/domains/github/github-cli.service.js

@@ -0,0 +1,860 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { CIStatus, PRState } from '../../../../prisma/generated/client.js';
+import { z } from 'zod';
+import { createLogger } from '../../../backend/services/logger.service.js';
+import { isRateLimitMessage } from '../../../backend/services/rate-limit-backoff.js';
+const execFileAsync = promisify(execFile);
+const logger = createLogger('github-cli');
+const GH_TIMEOUT_MS = Object.freeze({
+    healthVersion: 5000,
+    healthAuth: 10_000,
+    userLookup: 10_000,
+    default: 30_000,
+    reviewDetails: 10_000,
+    diff: 60_000,
+});
+const GH_MAX_BUFFER_BYTES = Object.freeze({
+    diff: 10 * 1024 * 1024,
+});
+const statusCheckRollupItemSchema = z
+    .object({
+    status: z.string().optional(),
+    conclusion: z.string().optional(),
+    state: z.string().optional(),
+})
+    .refine((item) => item.status !== undefined || item.state !== undefined, {
+    message: 'statusCheckRollup items must include status or state',
+});
+const reviewDecisionSchema = z.preprocess((val) => (val === '' ? null : val), z.enum(['APPROVED', 'CHANGES_REQUESTED', 'REVIEW_REQUIRED']).nullable());
+const prStatusSchema = z.object({
+    number: z.number(),
+    state: z.enum(['OPEN', 'CLOSED', 'MERGED']),
+    isDraft: z.boolean(),
+    reviewDecision: reviewDecisionSchema,
+    mergedAt: z.string().nullable(),
+    updatedAt: z.string(),
+    statusCheckRollup: z.array(statusCheckRollupItemSchema).nullable(),
+});
+const authorSchema = z.object({
+    login: z.string(),
+});
+const repositorySchema = z.object({
+    nameWithOwner: z.string(),
+});
+const basePRSchema = z.object({
+    number: z.number(),
+    title: z.string(),
+    url: z.string(),
+    repository: repositorySchema,
+    author: authorSchema,
+    createdAt: z.string(),
+    isDraft: z.boolean(),
+});
+const prDetailsSchema = z.object({
+    reviewDecision: reviewDecisionSchema,
+    additions: z.number().optional(),
+    deletions: z.number().optional(),
+    changedFiles: z.number().optional(),
+});
+const prListItemSchema = z.object({
+    number: z.number(),
+    url: z.string(),
+    state: z.string(),
+});
+const fullPRCheckRunSchema = z.object({
+    __typename: z.enum(['CheckRun', 'StatusContext']).optional(),
+    name: z.string(),
+    status: z.string(),
+    conclusion: z.string().nullable().optional(),
+    detailsUrl: z.string().optional(),
+});
+const fullPRStatusContextSchema = z.object({
+    __typename: z.enum(['CheckRun', 'StatusContext']).optional(),
+    context: z.string(),
+    state: z.string(),
+    targetUrl: z.string().optional(),
+    detailsUrl: z.string().optional(),
+});
+const fullPRDetailsSchema = z.object({
+    number: z.number(),
+    title: z.string(),
+    url: z.string(),
+    author: authorSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    isDraft: z.boolean(),
+    state: z.enum(['OPEN', 'CLOSED', 'MERGED']),
+    reviewDecision: reviewDecisionSchema,
+    statusCheckRollup: z.array(z.union([fullPRCheckRunSchema, fullPRStatusContextSchema])).nullable(),
+    reviews: z.array(z
+        .object({
+        id: z.string(),
+        author: z.object({ login: z.string() }),
+        state: z.string(),
+        submittedAt: z.string(),
+        body: z.string().optional(),
+    })
+        .passthrough()),
+    comments: z.array(z
+        .object({
+        id: z.string(),
+        author: z.object({ login: z.string() }),
+        body: z.string(),
+        createdAt: z.string(),
+        updatedAt: z.string().nullish(),
+        url: z.string(),
+    })
+        .passthrough()),
+    labels: z.array(z
+        .object({
+        name: z.string(),
+        color: z.string(),
+    })
+        .passthrough()),
+    additions: z.number().optional(),
+    deletions: z.number().optional(),
+    changedFiles: z.number().optional(),
+    headRefName: z.string().optional(),
+    baseRefName: z.string().optional(),
+    mergeStateStatus: z
+        .enum(['BEHIND', 'BLOCKED', 'CLEAN', 'DIRTY', 'HAS_HOOKS', 'UNKNOWN', 'UNSTABLE'])
+        .optional(),
+});
+const CHECK_STATUS_VALUES = ['COMPLETED', 'IN_PROGRESS', 'PENDING', 'QUEUED'];
+const CHECK_CONCLUSION_VALUES = [
+    'SUCCESS',
+    'FAILURE',
+    'SKIPPED',
+    'CANCELLED',
+    'TIMED_OUT',
+    'ACTION_REQUIRED',
+];
+const REVIEW_STATE_VALUES = [
+    'APPROVED',
+    'CHANGES_REQUESTED',
+    'COMMENTED',
+    'PENDING',
+    'DISMISSED',
+];
+function normalizeCheckStatus(status) {
+    return CHECK_STATUS_VALUES.includes(status)
+        ? status
+        : 'PENDING';
+}
+function normalizeCheckConclusion(conclusion) {
+    if (conclusion === null || conclusion === undefined) {
+        return null;
+    }
+    return CHECK_CONCLUSION_VALUES.includes(conclusion)
+        ? conclusion
+        : null;
+}
+function normalizeStatusContextStatus(state) {
+    if (state === 'PENDING' || state === 'EXPECTED') {
+        return 'PENDING';
+    }
+    return 'COMPLETED';
+}
+function normalizeStatusContextConclusion(state) {
+    switch (state) {
+        case 'SUCCESS':
+            return 'SUCCESS';
+        case 'FAILURE':
+        case 'ERROR':
+            return 'FAILURE';
+        case 'TIMED_OUT':
+            return 'TIMED_OUT';
+        case 'ACTION_REQUIRED':
+            return 'ACTION_REQUIRED';
+        case 'CANCELLED':
+            return 'CANCELLED';
+        case 'SKIPPED':
+            return 'SKIPPED';
+        default:
+            return null;
+    }
+}
+function normalizeReviewState(state) {
+    return REVIEW_STATE_VALUES.includes(state)
+        ? state
+        : 'PENDING';
+}
+function mapStatusChecks(checks) {
+    return checks.map((check) => {
+        if ('context' in check) {
+            return {
+                __typename: 'StatusContext',
+                name: check.context,
+                status: normalizeStatusContextStatus(check.state),
+                conclusion: normalizeStatusContextConclusion(check.state),
+                detailsUrl: check.targetUrl ?? check.detailsUrl,
+            };
+        }
+        return {
+            __typename: check.__typename ?? 'CheckRun',
+            name: check.name,
+            status: normalizeCheckStatus(check.status),
+            conclusion: normalizeCheckConclusion(check.conclusion),
+            detailsUrl: check.detailsUrl,
+        };
+    });
+}
+function mapReviews(reviews) {
+    return reviews.map((review) => ({
+        id: review.id,
+        author: review.author,
+        state: normalizeReviewState(review.state),
+        submittedAt: review.submittedAt,
+        body: review.body,
+    }));
+}
+function mapComments(comments) {
+    return comments.map((comment) => ({
+        id: comment.id,
+        author: comment.author,
+        body: comment.body,
+        createdAt: comment.createdAt,
+        updatedAt: comment.updatedAt ?? comment.createdAt,
+        url: comment.url,
+    }));
+}
+function mapLabels(labels) {
+    return labels.map((label) => ({
+        name: label.name,
+        color: label.color,
+    }));
+}
+const issueSchema = z.object({
+    number: z.number(),
+    title: z.string(),
+    body: z.string(),
+    url: z.string(),
+    state: z.enum(['OPEN', 'CLOSED']),
+    createdAt: z.string(),
+    author: authorSchema,
+});
+const reviewCommentSchema = z.object({
+    id: z.number(),
+    user: z.object({
+        login: z.string(),
+    }),
+    body: z.string(),
+    path: z.string(),
+    line: z.number().nullable(),
+    created_at: z.string(),
+    updated_at: z.string(),
+    html_url: z.string(),
+});
+function parseGhJson(schema, stdout, context) {
+    try {
+        const data = JSON.parse(stdout);
+        return schema.parse(data);
+    }
+    catch (error) {
+        if (error instanceof z.ZodError) {
+            logger.error('Invalid gh CLI JSON response', {
+                context,
+                validationErrors: error.issues,
+                stdout: stdout.slice(0, 500),
+            });
+            throw new Error(`Invalid gh CLI response for ${context}: ${error.message}`);
+        }
+        logger.error('Failed to parse gh CLI JSON', {
+            context,
+            error: error instanceof Error ? error.message : String(error),
+            stdout: stdout.slice(0, 500),
+        });
+        throw new Error(`Failed to parse gh CLI JSON for ${context}`);
+    }
+}
+async function mapWithConcurrencyLimit(items, fn, limit) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    async function worker() {
+        while (nextIndex < items.length) {
+            const index = nextIndex++;
+            const item = items[index];
+            if (item === undefined) {
+                throw new Error(`Unexpected undefined item at index ${index}`);
+            }
+            results[index] = await fn(item);
+        }
+    }
+    const workers = Array.from({ length: Math.min(limit, items.length) }, () => worker());
+    await Promise.all(workers);
+    return results;
+}
+class GitHubCLIService {
+    isCliNotInstalledError(message) {
+        return message.includes('enoent') || message.includes('not found');
+    }
+    isAuthRequiredError(message) {
+        return (message.includes('authentication') ||
+            message.includes('not logged in') ||
+            message.includes('gh auth login'));
+    }
+    isPRNotFoundError(message) {
+        return message.includes('could not resolve') || message.includes('not found');
+    }
+    isNetworkError(message) {
+        return (message.includes('network') || message.includes('timeout') || message.includes('connection'));
+    }
+    isRateLimitError(message) {
+        return isRateLimitMessage(message);
+    }
+    classifyError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const lowerMessage = message.toLowerCase();
+        if (this.isCliNotInstalledError(lowerMessage)) {
+            return 'cli_not_installed';
+        }
+        if (this.isAuthRequiredError(lowerMessage)) {
+            return 'auth_required';
+        }
+        if (this.isPRNotFoundError(lowerMessage)) {
+            return 'pr_not_found';
+        }
+        if (this.isRateLimitError(lowerMessage)) {
+            return 'rate_limit';
+        }
+        if (this.isNetworkError(lowerMessage)) {
+            return 'network_error';
+        }
+        return 'unknown';
+    }
+    logGitHubCLIError(errorType, errorMessage, context) {
+        if (errorType === 'cli_not_installed') {
+            logger.error('GitHub CLI configuration issue', {
+                ...context,
+                errorType,
+                error: errorMessage,
+                hint: 'Install gh CLI from https://cli.github.com/',
+            });
+        }
+        else if (errorType === 'auth_required') {
+            logger.error('GitHub CLI configuration issue', {
+                ...context,
+                errorType,
+                error: errorMessage,
+                hint: 'Run `gh auth login` to authenticate',
+            });
+        }
+        else if (errorType === 'pr_not_found') {
+            logger.warn('PR not found', { ...context, errorType });
+        }
+        else if (errorType === 'rate_limit') {
+            logger.warn('GitHub API rate limit hit', {
+                ...context,
+                errorType,
+                error: errorMessage,
+                hint: 'Polling intervals have been increased to reduce API pressure',
+            });
+        }
+        else {
+            logger.error('Failed to fetch PR status via gh CLI', {
+                ...context,
+                errorType,
+                error: errorMessage,
+            });
+        }
+    }
+    async getAuthenticatedUsername() {
+        try {
+            const { stdout } = await execFileAsync('gh', ['api', 'user', '--jq', '.login'], {
+                timeout: GH_TIMEOUT_MS.userLookup,
+            });
+            return stdout.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async checkHealth() {
+        try {
+            const { stdout: versionOutput } = await execFileAsync('gh', ['--version'], {
+                timeout: GH_TIMEOUT_MS.healthVersion,
+            });
+            const versionMatch = versionOutput.match(/gh version ([\d.]+)/);
+            const version = versionMatch?.[1];
+            try {
+                await execFileAsync('gh', ['auth', 'status'], { timeout: GH_TIMEOUT_MS.healthAuth });
+                return { isInstalled: true, isAuthenticated: true, version };
+            }
+            catch {
+                return {
+                    isInstalled: true,
+                    isAuthenticated: false,
+                    version,
+                    error: 'GitHub CLI is not authenticated. Run `gh auth login` to authenticate.',
+                    errorType: 'auth_required',
+                };
+            }
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            return {
+                isInstalled: false,
+                isAuthenticated: false,
+                error: errorType === 'cli_not_installed'
+                    ? 'GitHub CLI (gh) is not installed. Install from https://cli.github.com/'
+                    : `Failed to check gh CLI: ${error instanceof Error ? error.message : String(error)}`,
+                errorType,
+            };
+        }
+    }
+    extractPRInfo(prUrl) {
+        const match = prUrl.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+        if (!match) {
+            return null;
+        }
+        return {
+            owner: match[1],
+            repo: match[2],
+            number: Number.parseInt(match[3], 10),
+        };
+    }
+    async getPRStatus(prUrl) {
+        const prInfo = this.extractPRInfo(prUrl);
+        if (!prInfo) {
+            logger.warn('Could not parse PR URL', { prUrl });
+            return null;
+        }
+        try {
+            const { stdout } = await execFileAsync('gh', [
+                'pr',
+                'view',
+                String(prInfo.number),
+                '--repo',
+                `${prInfo.owner}/${prInfo.repo}`,
+                '--json',
+                'number,state,isDraft,reviewDecision,mergedAt,updatedAt,statusCheckRollup',
+            ], { timeout: GH_TIMEOUT_MS.default });
+            return parseGhJson(prStatusSchema, stdout, 'getPRStatus');
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logGitHubCLIError(errorType, errorMessage, { prUrl });
+            if (errorType === 'rate_limit') {
+                throw error;
+            }
+            return null;
+        }
+    }
+    computeCIStatus(statusCheckRollup) {
+        if (!statusCheckRollup || statusCheckRollup.length === 0) {
+            return CIStatus.UNKNOWN;
+        }
+        const getEffectiveState = (check) => {
+            if (check.status === 'COMPLETED' && check.conclusion) {
+                return check.conclusion;
+            }
+            return check.state || check.status || 'PENDING';
+        };
+        const hasFailure = statusCheckRollup.some((check) => {
+            const state = getEffectiveState(check);
+            return state === 'FAILURE' || state === 'ERROR' || state === 'ACTION_REQUIRED';
+        });
+        if (hasFailure) {
+            return CIStatus.FAILURE;
+        }
+        const hasPending = statusCheckRollup.some((check) => {
+            const state = getEffectiveState(check);
+            return (state === 'PENDING' ||
+                state === 'EXPECTED' ||
+                state === 'QUEUED' ||
+                state === 'IN_PROGRESS' ||
+                check.status === 'QUEUED' ||
+                check.status === 'IN_PROGRESS');
+        });
+        if (hasPending) {
+            return CIStatus.PENDING;
+        }
+        const allSuccess = statusCheckRollup.every((check) => {
+            const state = getEffectiveState(check);
+            return (state === 'SUCCESS' || state === 'NEUTRAL' || state === 'CANCELLED' || state === 'SKIPPED');
+        });
+        if (allSuccess) {
+            return CIStatus.SUCCESS;
+        }
+        return CIStatus.UNKNOWN;
+    }
+    computePRState(status) {
+        if (status.mergedAt || status.state === 'MERGED') {
+            return PRState.MERGED;
+        }
+        if (status.state === 'CLOSED') {
+            return PRState.CLOSED;
+        }
+        if (status.isDraft) {
+            return PRState.DRAFT;
+        }
+        if (status.reviewDecision === 'APPROVED') {
+            return PRState.APPROVED;
+        }
+        if (status.reviewDecision === 'CHANGES_REQUESTED') {
+            return PRState.CHANGES_REQUESTED;
+        }
+        return PRState.OPEN;
+    }
+    async fetchAndComputePRState(prUrl) {
+        const status = await this.getPRStatus(prUrl);
+        if (!status) {
+            return null;
+        }
+        return {
+            prState: this.computePRState(status),
+            prNumber: status.number,
+            prReviewState: status.reviewDecision,
+            prCiStatus: this.computeCIStatus(status.statusCheckRollup),
+        };
+    }
+    async listReviewRequests() {
+        const { stdout } = await execFileAsync('gh', [
+            'search',
+            'prs',
+            '--review-requested=@me',
+            '--state=open',
+            '--json',
+            'number,title,url,repository,author,createdAt,isDraft',
+        ], { timeout: GH_TIMEOUT_MS.default });
+        const basePRs = parseGhJson(z.array(basePRSchema), stdout, 'listReviewRequests');
+        const prsWithDetails = await mapWithConcurrencyLimit(basePRs, async (pr) => {
+            try {
+                const { stdout: prDetails } = await execFileAsync('gh', [
+                    'pr',
+                    'view',
+                    String(pr.number),
+                    '--repo',
+                    pr.repository.nameWithOwner,
+                    '--json',
+                    'reviewDecision,additions,deletions,changedFiles',
+                ], { timeout: GH_TIMEOUT_MS.reviewDetails });
+                const details = parseGhJson(prDetailsSchema, prDetails, 'listReviewRequests:prDetails');
+                return {
+                    ...pr,
+                    reviewDecision: details.reviewDecision,
+                    additions: details.additions ?? 0,
+                    deletions: details.deletions ?? 0,
+                    changedFiles: details.changedFiles ?? 0,
+                };
+            }
+            catch {
+                return { ...pr, reviewDecision: null, additions: 0, deletions: 0, changedFiles: 0 };
+            }
+        }, 5);
+        return prsWithDetails;
+    }
+    async findPRForBranch(owner, repo, branchName) {
+        try {
+            const { stdout } = await execFileAsync('gh', [
+                'pr',
+                'list',
+                '--head',
+                branchName,
+                '--repo',
+                `${owner}/${repo}`,
+                '--state',
+                'all',
+                '--json',
+                'number,url,state',
+                '--limit',
+                '10',
+            ], { timeout: GH_TIMEOUT_MS.default });
+            const prs = parseGhJson(z.array(prListItemSchema), stdout, 'findPRForBranch');
+            if (prs.length === 0) {
+                return null;
+            }
+            const openPr = prs.find((pr) => pr.state === 'OPEN');
+            if (openPr) {
+                return { url: openPr.url, number: openPr.number };
+            }
+            const mergedPr = prs.find((pr) => pr.state === 'MERGED');
+            if (mergedPr) {
+                return { url: mergedPr.url, number: mergedPr.number };
+            }
+            return null;
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            if (errorType !== 'cli_not_installed' && errorType !== 'auth_required') {
+                logger.debug('No PR found for branch', { owner, repo, branchName });
+            }
+            return null;
+        }
+    }
+    async approvePR(owner, repo, prNumber) {
+        const args = ['pr', 'review', String(prNumber), '--repo', `${owner}/${repo}`, '--approve'];
+        try {
+            await execFileAsync('gh', args, { timeout: GH_TIMEOUT_MS.default });
+            logger.info('PR approved successfully', { owner, repo, prNumber });
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to approve PR via gh CLI', {
+                owner,
+                repo,
+                prNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to approve PR: ${errorMessage}`);
+        }
+    }
+    async getPRFullDetails(repo, prNumber) {
+        const fields = [
+            'number',
+            'title',
+            'url',
+            'author',
+            'createdAt',
+            'updatedAt',
+            'isDraft',
+            'state',
+            'reviewDecision',
+            'statusCheckRollup',
+            'reviews',
+            'comments',
+            'labels',
+            'additions',
+            'deletions',
+            'changedFiles',
+            'headRefName',
+            'baseRefName',
+            'mergeStateStatus',
+        ].join(',');
+        try {
+            const { stdout } = await execFileAsync('gh', ['pr', 'view', String(prNumber), '--repo', repo, '--json', fields], { timeout: GH_TIMEOUT_MS.default });
+            const data = parseGhJson(fullPRDetailsSchema, stdout, 'getPRFullDetails');
+            const [, repoName] = repo.split('/');
+            return {
+                number: data.number,
+                title: data.title,
+                url: data.url,
+                author: data.author,
+                repository: {
+                    name: repoName,
+                    nameWithOwner: repo,
+                },
+                createdAt: data.createdAt,
+                updatedAt: data.updatedAt,
+                isDraft: data.isDraft,
+                state: data.state,
+                reviewDecision: data.reviewDecision,
+                statusCheckRollup: data.statusCheckRollup ? mapStatusChecks(data.statusCheckRollup) : null,
+                reviews: mapReviews(data.reviews),
+                comments: mapComments(data.comments),
+                labels: mapLabels(data.labels),
+                additions: data.additions || 0,
+                deletions: data.deletions || 0,
+                changedFiles: data.changedFiles || 0,
+                headRefName: data.headRefName || '',
+                baseRefName: data.baseRefName || '',
+                mergeStateStatus: data.mergeStateStatus || 'UNKNOWN',
+            };
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to fetch PR details via gh CLI', {
+                repo,
+                prNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to fetch PR details: ${errorMessage}`);
+        }
+    }
+    async getPRDiff(repo, prNumber) {
+        try {
+            const { stdout } = await execFileAsync('gh', ['pr', 'diff', String(prNumber), '--repo', repo], { timeout: GH_TIMEOUT_MS.diff, maxBuffer: GH_MAX_BUFFER_BYTES.diff });
+            return stdout;
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to fetch PR diff via gh CLI', {
+                repo,
+                prNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to fetch PR diff: ${errorMessage}`);
+        }
+    }
+    async submitReview(repo, prNumber, action, body) {
+        const actionFlags = {
+            approve: '--approve',
+            'request-changes': '--request-changes',
+            comment: '--comment',
+        };
+        const args = ['pr', 'review', String(prNumber), '--repo', repo, actionFlags[action]];
+        if (body && (action === 'request-changes' || action === 'comment')) {
+            args.push('--body', body);
+        }
+        try {
+            await execFileAsync('gh', args, { timeout: GH_TIMEOUT_MS.default });
+            logger.info('PR review submitted successfully', { repo, prNumber, action });
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to submit PR review via gh CLI', {
+                repo,
+                prNumber,
+                action,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to submit review: ${errorMessage}`);
+        }
+    }
+    async listIssues(owner, repo, options = {}) {
+        const { limit = 50, assignee } = options;
+        try {
+            const args = [
+                'issue',
+                'list',
+                '--repo',
+                `${owner}/${repo}`,
+                '--state',
+                'open',
+                '--json',
+                'number,title,body,url,state,createdAt,author',
+                '--limit',
+                String(limit),
+            ];
+            if (assignee) {
+                args.push('--assignee', assignee);
+            }
+            const { stdout } = await execFileAsync('gh', args, { timeout: GH_TIMEOUT_MS.default });
+            return parseGhJson(z.array(issueSchema), stdout, 'listIssues');
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to list issues via gh CLI', {
+                owner,
+                repo,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to list issues: ${errorMessage}`);
+        }
+    }
+    async getReviewComments(repo, prNumber) {
+        try {
+            const { stdout } = await execFileAsync('gh', ['api', `repos/${repo}/pulls/${prNumber}/comments`, '--paginate'], { timeout: GH_TIMEOUT_MS.default });
+            if (!stdout.trim()) {
+                return [];
+            }
+            const comments = parseGhJson(z.array(reviewCommentSchema), stdout, 'getReviewComments');
+            return comments.map((comment) => ({
+                id: comment.id,
+                author: { login: comment.user.login },
+                body: comment.body,
+                path: comment.path,
+                line: comment.line,
+                createdAt: comment.created_at,
+                updatedAt: comment.updated_at,
+                url: comment.html_url,
+            }));
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to fetch PR review comments via gh CLI', {
+                repo,
+                prNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to fetch PR review comments: ${errorMessage}`);
+        }
+    }
+    async addPRComment(repo, prNumber, body) {
+        try {
+            await execFileAsync('gh', ['pr', 'comment', String(prNumber), '--repo', repo, '--body', body], {
+                timeout: GH_TIMEOUT_MS.default,
+            });
+            logger.info('PR comment added successfully', { repo, prNumber });
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to add PR comment via gh CLI', {
+                repo,
+                prNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to add PR comment: ${errorMessage}`);
+        }
+    }
+    async addIssueComment(owner, repo, issueNumber, body) {
+        try {
+            await execFileAsync('gh', ['issue', 'comment', String(issueNumber), '--repo', `${owner}/${repo}`, '--body', body], { timeout: GH_TIMEOUT_MS.default });
+            logger.info('Issue comment added successfully', { owner, repo, issueNumber });
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to add issue comment via gh CLI', {
+                owner,
+                repo,
+                issueNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to add issue comment: ${errorMessage}`);
+        }
+    }
+    async getIssue(owner, repo, issueNumber) {
+        try {
+            const { stdout } = await execFileAsync('gh', [
+                'issue',
+                'view',
+                String(issueNumber),
+                '--repo',
+                `${owner}/${repo}`,
+                '--json',
+                'number,title,body,url,state,createdAt,author',
+            ], { timeout: GH_TIMEOUT_MS.default });
+            return parseGhJson(issueSchema, stdout, 'getIssue');
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to get issue via gh CLI', {
+                owner,
+                repo,
+                issueNumber,
+                errorType,
+                error: errorMessage,
+            });
+            return null;
+        }
+    }
+    async closeIssue(owner, repo, issueNumber) {
+        try {
+            await execFileAsync('gh', ['issue', 'close', String(issueNumber), '--repo', `${owner}/${repo}`], { timeout: GH_TIMEOUT_MS.default });
+            logger.info('Issue closed successfully', { owner, repo, issueNumber });
+        }
+        catch (error) {
+            const errorType = this.classifyError(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error('Failed to close issue via gh CLI', {
+                owner,
+                repo,
+                issueNumber,
+                errorType,
+                error: errorMessage,
+            });
+            throw new Error(`Failed to close issue: ${errorMessage}`);
+        }
+    }
+}
+export const githubCLIService = new GitHubCLIService();
+//# sourceMappingURL=github-cli.service.js.map