factory-factory 0.2.5 → 0.2.7

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

@@ -1,681 +0,0 @@
-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 './logger.service.js';
-const execFileAsync = promisify(execFile);
-const logger = createLogger('github-cli');
-const statusCheckRollupItemSchema = z.object({
-    status: z.string(),
-    conclusion: z.string().optional(),
-    state: z.string().optional(),
-});
-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 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.any()).nullable(),
-    reviews: z.array(z.any()),
-    comments: z.array(z.any()),
-    labels: z.array(z.any()),
-    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 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++;
-            results[index] = await fn(items[index]);
-        }
-    }
-    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'));
-    }
-    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.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 {
-            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: 10_000,
-            });
-            return stdout.trim() || null;
-        }
-        catch {
-            return null;
-        }
-    }
-    async checkHealth() {
-        try {
-            const { stdout: versionOutput } = await execFileAsync('gh', ['--version'], { timeout: 5000 });
-            const versionMatch = versionOutput.match(/gh version ([\d.]+)/);
-            const version = versionMatch?.[1];
-            try {
-                await execFileAsync('gh', ['auth', 'status'], { timeout: 10_000 });
-                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: 30_000 });
-            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 });
-            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;
-        };
-        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: 30_000 });
-        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: 10_000 });
-                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: 30_000 });
-            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: 30_000 });
-            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: 30_000 });
-            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 || null,
-                reviews: data.reviews || [],
-                comments: data.comments || [],
-                labels: 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: 60_000, maxBuffer: 10 * 1024 * 1024 });
-            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: 30_000 });
-            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: 30_000 });
-            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: 30_000 });
-            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: 30_000,
-            });
-            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: 30_000 });
-            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: 30_000 });
-            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: 30_000 });
-            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