factory-factory 0.2.7 → 0.2.8

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

@@ -1,364 +1,14 @@
 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';
+import { GH_MAX_BUFFER_BYTES, GH_TIMEOUT_MS } from './github-cli/constants.js';
+import { classifyError, logGitHubCLIError } from './github-cli/errors.js';
+import { computeCIStatus, computePRState, mapComments, mapLabels, mapReviews, mapStatusChecks, } from './github-cli/mappers.js';
+import { basePRSchema, fullPRDetailsSchema, issueSchema, prDetailsSchema, prListItemSchema, prStatusSchema, reviewCommentSchema, } from './github-cli/schemas.js';
+import { mapWithConcurrencyLimit, parseGhJson } from './github-cli/utils.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'], {
@@ -392,7 +42,7 @@ class GitHubCLIService {
             }
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             return {
                 isInstalled: false,
                 isAuthenticated: false,
@@ -433,9 +83,9 @@ class GitHubCLIService {
             return parseGhJson(prStatusSchema, stdout, 'getPRStatus');
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
-            this.logGitHubCLIError(errorType, errorMessage, { prUrl });
+            logGitHubCLIError(errorType, errorMessage, { prUrl });
             if (errorType === 'rate_limit') {
                 throw error;
             }
@@ -443,60 +93,10 @@ class GitHubCLIService {
         }
     }
     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;
+        return computeCIStatus(statusCheckRollup);
     }
     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;
+        return computePRState(status);
     }
     async fetchAndComputePRState(prUrl) {
         const status = await this.getPRStatus(prUrl);
@@ -519,7 +119,7 @@ class GitHubCLIService {
             '--json',
             'number,title,url,repository,author,createdAt,isDraft',
         ], { timeout: GH_TIMEOUT_MS.default });
-        const basePRs = parseGhJson(z.array(basePRSchema), stdout, 'listReviewRequests');
+        const basePRs = parseGhJson(basePRSchema.array(), stdout, 'listReviewRequests');
         const prsWithDetails = await mapWithConcurrencyLimit(basePRs, async (pr) => {
             try {
                 const { stdout: prDetails } = await execFileAsync('gh', [
@@ -546,7 +146,7 @@ class GitHubCLIService {
         }, 5);
         return prsWithDetails;
     }
-    async findPRForBranch(owner, repo, branchName) {
+    async findPRForBranch(owner, repo, branchName, workspaceCreatedAt) {
         try {
             const { stdout } = await execFileAsync('gh', [
                 'pr',
@@ -556,28 +156,27 @@ class GitHubCLIService {
                 '--repo',
                 `${owner}/${repo}`,
                 '--state',
-                'all',
+                'open',
                 '--json',
-                'number,url,state',
+                'number,url,state,createdAt',
                 '--limit',
                 '10',
             ], { timeout: GH_TIMEOUT_MS.default });
-            const prs = parseGhJson(z.array(prListItemSchema), stdout, 'findPRForBranch');
+            const prs = parseGhJson(prListItemSchema.array(), 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 };
+            const filteredPRs = workspaceCreatedAt
+                ? prs.filter((pr) => new Date(pr.createdAt) >= workspaceCreatedAt)
+                : prs;
+            const pr = filteredPRs[0];
+            if (!pr) {
+                return null;
             }
-            return null;
+            return { url: pr.url, number: pr.number };
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             if (errorType !== 'cli_not_installed' && errorType !== 'auth_required') {
                 logger.debug('No PR found for branch', { owner, repo, branchName });
             }
@@ -591,7 +190,7 @@ class GitHubCLIService {
             logger.info('PR approved successfully', { owner, repo, prNumber });
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to approve PR via gh CLI', {
                 owner,
@@ -656,7 +255,7 @@ class GitHubCLIService {
             };
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to fetch PR details via gh CLI', {
                 repo,
@@ -673,7 +272,7 @@ class GitHubCLIService {
             return stdout;
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to fetch PR diff via gh CLI', {
                 repo,
@@ -699,7 +298,7 @@ class GitHubCLIService {
             logger.info('PR review submitted successfully', { repo, prNumber, action });
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to submit PR review via gh CLI', {
                 repo,
@@ -730,10 +329,10 @@ class GitHubCLIService {
                 args.push('--assignee', assignee);
             }
             const { stdout } = await execFileAsync('gh', args, { timeout: GH_TIMEOUT_MS.default });
-            return parseGhJson(z.array(issueSchema), stdout, 'listIssues');
+            return parseGhJson(issueSchema.array(), stdout, 'listIssues');
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to list issues via gh CLI', {
                 owner,
@@ -750,7 +349,7 @@ class GitHubCLIService {
             if (!stdout.trim()) {
                 return [];
             }
-            const comments = parseGhJson(z.array(reviewCommentSchema), stdout, 'getReviewComments');
+            const comments = parseGhJson(reviewCommentSchema.array(), stdout, 'getReviewComments');
             return comments.map((comment) => ({
                 id: comment.id,
                 author: { login: comment.user.login },
@@ -763,7 +362,7 @@ class GitHubCLIService {
             }));
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to fetch PR review comments via gh CLI', {
                 repo,
@@ -782,7 +381,7 @@ class GitHubCLIService {
             logger.info('PR comment added successfully', { repo, prNumber });
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to add PR comment via gh CLI', {
                 repo,
@@ -799,7 +398,7 @@ class GitHubCLIService {
             logger.info('Issue comment added successfully', { owner, repo, issueNumber });
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to add issue comment via gh CLI', {
                 owner,
@@ -825,7 +424,7 @@ class GitHubCLIService {
             return parseGhJson(issueSchema, stdout, 'getIssue');
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to get issue via gh CLI', {
                 owner,
@@ -843,7 +442,7 @@ class GitHubCLIService {
             logger.info('Issue closed successfully', { owner, repo, issueNumber });
         }
         catch (error) {
-            const errorType = this.classifyError(error);
+            const errorType = classifyError(error);
             const errorMessage = error instanceof Error ? error.message : String(error);
             logger.error('Failed to close issue via gh CLI', {
                 owner,