opencode-magi 0.10.0 → 0.11.0

package/dist/github/commands.js

@@ -1,905 +0,0 @@
-import { mkdir, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-function normalizeRelatedPullRequestState(state) {
-    const normalized = state?.toUpperCase();
-    if (normalized === "MERGED")
-        return "MERGED";
-    if (normalized === "CLOSED")
-        return "CLOSED";
-    return "OPEN";
-}
-const WORKTREE_CHECKOUT_RETRY_ATTEMPTS = 5;
-const WORKTREE_CHECKOUT_RETRY_DELAY_MS = 100;
-const worktreeCreateLocks = new Map();
-function errorText(error) {
-    if (!error || typeof error !== "object")
-        return String(error);
-    const value = error;
-    return [value.message, value.stderr, value.stdout]
-        .filter((item) => typeof item === "string")
-        .join("\n");
-}
-function isIssueTypeUnavailableText(text) {
-    return (/cannot query field ["']?issueType["']? on type ["']?Issue["']?/i.test(text) ||
-        /field ["']?issueType["']?.*(does not exist|doesn't exist|is not defined|not found).*type ["']?Issue["']?/i.test(text) ||
-        /undefinedField.*issueType/i.test(text) ||
-        /issueType.*unsupported field|unsupported field.*issueType/i.test(text));
-}
-function isIssueTypeUnavailableError(error) {
-    return isIssueTypeUnavailableText(errorText(error));
-}
-function isIssueTypeUnavailableGraphqlResponse(data) {
-    return (data.errors?.some((error) => isIssueTypeUnavailableText([error.message, error.type]
-        .filter((item) => typeof item === "string")
-        .join("\n"))) ?? false);
-}
-async function localCommitExists(exec, worktreePath, sha) {
-    try {
-        await exec(`git cat-file -e ${shellQuote(`${sha}^{commit}`)}`, {
-            cwd: worktreePath,
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function pullRequestCommitSource(input) {
-    if (input.source === "base") {
-        return {
-            owner: input.repository.github.owner,
-            refName: input.meta.baseRefName,
-            repo: input.repository.github.repo,
-        };
-    }
-    return {
-        owner: input.meta.headRepositoryOwner?.login ?? input.repository.github.owner,
-        refName: input.meta.headRefName,
-        repo: input.meta.headRepository?.name ?? input.repository.github.repo,
-    };
-}
-async function fetchPullRequestCommitSource(input) {
-    const commitSource = pullRequestCommitSource(input);
-    try {
-        await input.exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(input.repository, commitSource.owner, commitSource.repo))} ${shellQuote(`refs/heads/${commitSource.refName}`)}`, { cwd: input.worktreePath });
-    }
-    catch (error) {
-        throw new Error(`Could not fetch ${input.source} ref ${commitSource.refName} for #${input.meta.number}: ${errorText(error)}`);
-    }
-}
-export async function ensurePullRequestCommits(input) {
-    const missing = [];
-    for (const commit of input.commits) {
-        if (!(await localCommitExists(input.exec, input.worktreePath, commit.sha))) {
-            missing.push(commit);
-        }
-    }
-    for (const source of new Set(missing.map((commit) => commit.source))) {
-        await fetchPullRequestCommitSource({
-            exec: input.exec,
-            meta: input.meta,
-            repository: input.repository,
-            source,
-            worktreePath: input.worktreePath,
-        });
-    }
-    for (const commit of missing) {
-        if (await localCommitExists(input.exec, input.worktreePath, commit.sha)) {
-            continue;
-        }
-        const source = pullRequestCommitSource({
-            meta: input.meta,
-            repository: input.repository,
-            source: commit.source,
-        });
-        throw new Error(`${commit.label} commit ${commit.sha} is unavailable after fetching ${commit.source} ref ${source.refName}`);
-    }
-}
-function isCheckoutConfigLockError(error) {
-    const text = errorText(error);
-    return (/could not lock config file/i.test(text) ||
-        /Unable to write upstream branch configuration/i.test(text));
-}
-async function delay(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function withWorktreeCreateLock(key, run) {
-    const previous = worktreeCreateLocks.get(key) ?? Promise.resolve();
-    let release;
-    const current = new Promise((resolve) => {
-        release = resolve;
-    });
-    const tail = previous.catch(() => undefined).then(() => current);
-    worktreeCreateLocks.set(key, tail);
-    await previous.catch(() => undefined);
-    try {
-        return await run();
-    }
-    finally {
-        release();
-        if (worktreeCreateLocks.get(key) === tail)
-            worktreeCreateLocks.delete(key);
-    }
-}
-async function checkoutPullRequestWithRetry(exec, repository, pr, worktreePath) {
-    for (let attempt = 0;; attempt += 1) {
-        try {
-            await exec(`gh pr checkout ${pr} --repo ${shellQuote(repoSpecifier(repository))} --detach`, {
-                cwd: worktreePath,
-            });
-            return;
-        }
-        catch (error) {
-            if (attempt >= WORKTREE_CHECKOUT_RETRY_ATTEMPTS - 1 ||
-                !isCheckoutConfigLockError(error)) {
-                throw error;
-            }
-            await delay(WORKTREE_CHECKOUT_RETRY_DELAY_MS * 2 ** attempt);
-        }
-    }
-}
-export function shellQuote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-export function repoSlug(repository) {
-    return `${repository.github.owner}/${repository.github.repo}`;
-}
-function githubHost(repository) {
-    return repository.github.host || "github.com";
-}
-export function repoSpecifier(repository) {
-    const host = githubHost(repository);
-    return host === "github.com"
-        ? repoSlug(repository)
-        : `${host}/${repoSlug(repository)}`;
-}
-function repositoryGitUrl(repository, owner, repo) {
-    return `https://${githubHost(repository)}/${owner}/${repo}.git`;
-}
-export function ghHostOption(repository) {
-    const host = githubHost(repository);
-    return host === "github.com" ? "" : ` --hostname ${shellQuote(host)}`;
-}
-export async function ghToken(exec, repository, account) {
-    return (await exec(`gh auth token${ghHostOption(repository)} --user ${shellQuote(account)}`)).trim();
-}
-function ghTokenEnv(token) {
-    return { env: { GH_TOKEN: token } };
-}
-async function fetchPullRequestQueueInput(exec, repository, pr, token) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { id headRefOid } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`, ghTokenEnv(token));
-    const data = JSON.parse(raw);
-    const pullRequest = data.data?.repository?.pullRequest;
-    if (!pullRequest?.id || !pullRequest.headRefOid) {
-        throw new Error(`Could not fetch pull request queue metadata for #${pr}`);
-    }
-    return { headRefOid: pullRequest.headRefOid, id: pullRequest.id };
-}
-export async function fetchPullRequest(exec, repository, pr) {
-    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,body,url,state,author,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner,changedFiles`);
-    return JSON.parse(json);
-}
-export async function fetchPullRequestClosingIssues(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { closingIssuesReferences(first: 20) { nodes { number title body url state author { login } labels(first: 100) { nodes { name } } issueType { name } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return (data.data?.repository?.pullRequest?.closingIssuesReferences?.nodes?.map((issue) => ({
-        author: issue.author?.login ?? "",
-        body: issue.body ?? "",
-        labels: issue.labels?.nodes?.map((label) => label.name) ?? [],
-        number: issue.number,
-        state: issue.state,
-        title: issue.title,
-        type: issue.issueType?.name,
-        url: issue.url,
-    })) ?? []);
-}
-export async function fetchIssue(exec, repository, issue) {
-    const query = `query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { number title body url state author { login } labels(first: 100) { nodes { name } } issueType { name } } } }`;
-    let raw;
-    try {
-        raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F issue=${issue}`);
-    }
-    catch (error) {
-        if (isIssueTypeUnavailableError(error)) {
-            return fetchIssueWithCli(exec, repository, issue);
-        }
-        throw error;
-    }
-    const data = JSON.parse(raw);
-    const graphqlIssue = data.data?.repository?.issue;
-    if (!graphqlIssue) {
-        if (isIssueTypeUnavailableGraphqlResponse(data)) {
-            return fetchIssueWithCli(exec, repository, issue);
-        }
-        throw new Error(`Could not fetch issue #${issue}`);
-    }
-    return {
-        author: graphqlIssue.author?.login ?? "",
-        body: graphqlIssue.body ?? "",
-        labels: graphqlIssue.labels?.nodes?.map((label) => label.name) ?? [],
-        number: graphqlIssue.number,
-        state: graphqlIssue.state,
-        title: graphqlIssue.title,
-        type: graphqlIssue.issueType?.name,
-        url: graphqlIssue.url,
-    };
-}
-async function fetchIssueWithCli(exec, repository, issue) {
-    const raw = await exec(`gh issue view ${issue} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,body,url,state,author,labels`);
-    const data = JSON.parse(raw);
-    return {
-        author: data.author?.login ?? "",
-        body: data.body ?? "",
-        labels: data.labels?.map((label) => label.name) ?? [],
-        number: data.number,
-        state: data.state,
-        title: data.title,
-        url: data.url,
-    };
-}
-export async function fetchIssueComments(exec, repository, issue, limit = 50) {
-    return (await fetchIssueCommentPage(exec, repository, issue, limit)).comments;
-}
-export async function fetchIssueCommentPage(exec, repository, issue, limit = 50) {
-    const query = `query($owner: String!, $repo: String!, $issue: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { comments(last: $limit) { totalCount nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F issue=${issue} -F limit=${limit}`);
-    const data = JSON.parse(raw);
-    const connection = data.data?.repository?.issue?.comments;
-    const comments = connection?.nodes?.map((comment) => ({
-        author: comment.author?.login ?? "",
-        authorAssociation: comment.authorAssociation,
-        body: comment.body ?? "",
-        createdAt: comment.createdAt,
-        id: comment.databaseId,
-        url: comment.url,
-    })) ?? [];
-    return {
-        comments,
-        omitted: Math.max(0, (connection?.totalCount ?? comments.length) - comments.length),
-    };
-}
-export async function fetchPullRequestComments(exec, repository, pr, limit = 50) {
-    return (await fetchPullRequestCommentPage(exec, repository, pr, limit))
-        .comments;
-}
-export async function fetchPullRequestCommentPage(exec, repository, pr, limit = 50) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { comments(last: $limit) { totalCount nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr} -F limit=${limit}`);
-    const data = JSON.parse(raw);
-    const connection = data.data?.repository?.pullRequest?.comments;
-    const comments = connection?.nodes?.map((comment) => ({
-        author: comment.author?.login ?? "",
-        authorAssociation: comment.authorAssociation,
-        body: comment.body ?? "",
-        createdAt: comment.createdAt,
-        id: comment.databaseId,
-        url: comment.url,
-    })) ?? [];
-    return {
-        comments,
-        omitted: Math.max(0, (connection?.totalCount ?? comments.length) - comments.length),
-    };
-}
-export async function fetchRelatedPullRequests(exec, repository, issue) {
-    const query = `query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { timelineItems(first: 50, itemTypes: [CONNECTED_EVENT, CROSS_REFERENCED_EVENT]) { nodes { __typename ... on ConnectedEvent { subject { __typename ... on PullRequest { number title url state mergedAt body author { login } } } } ... on CrossReferencedEvent { source { __typename ... on PullRequest { number title url state mergedAt body author { login } } } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F issue=${issue}`);
-    const data = JSON.parse(raw);
-    const prs = new Map();
-    for (const node of data.data?.repository?.issue?.timelineItems?.nodes ?? []) {
-        const source = (node.subject ?? node.source);
-        if (!source?.number || !source.url)
-            continue;
-        const state = source.mergedAt
-            ? "MERGED"
-            : normalizeRelatedPullRequestState(source.state);
-        prs.set(source.number, {
-            author: source.author?.login ?? "",
-            body: source.body,
-            mergedAt: source.mergedAt,
-            number: source.number,
-            state,
-            title: source.title ?? `PR #${source.number}`,
-            url: source.url,
-        });
-    }
-    const searchQuery = `repo:${repoSlug(repository)} is:pr ${issue}`;
-    const searchRaw = await exec(`gh search prs ${shellQuote(searchQuery)} --json number,title,url,state,body,author --limit 10`).catch(() => "[]");
-    const searchData = JSON.parse(searchRaw);
-    const closingReference = new RegExp(`\\b(?:close[sd]?|fix(?:e[sd])?|resolve[sd]?)\\s+#${issue}\\b`, "i");
-    for (const item of searchData) {
-        if (!closingReference.test(item.body ?? ""))
-            continue;
-        prs.set(item.number, {
-            author: item.author?.login ?? "",
-            body: item.body,
-            number: item.number,
-            state: normalizeRelatedPullRequestState(item.state),
-            title: item.title,
-            url: item.url,
-        });
-    }
-    return [...prs.values()];
-}
-function duplicateReferences(text) {
-    const refs = new Set();
-    const pattern = /duplicate(?:s)?\s+(?:of\s+)?#(\d+)/gi;
-    for (const match of text.matchAll(pattern))
-        refs.add(Number(match[1]));
-    return [...refs];
-}
-function issueTitleSearchQuery(title, fallback) {
-    return (title
-        .replaceAll(/[^\p{L}\p{N}_]+/gu, " ")
-        .replaceAll(/\s+/g, " ")
-        .trim() || fallback);
-}
-async function fetchIssueCandidate(exec, repository, number, whyCandidate) {
-    const raw = await exec(`gh issue view ${number} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,state,body,createdAt`).catch(() => undefined);
-    if (!raw)
-        return undefined;
-    const data = JSON.parse(raw);
-    return { ...data, whyCandidate };
-}
-export async function searchDuplicateIssues(exec, repository, issue, limit = 5) {
-    const query = issueTitleSearchQuery(issue.title, String(issue.number));
-    const explicitCandidates = await Promise.all(duplicateReferences(issue.body)
-        .filter((number) => number !== issue.number)
-        .map((number) => fetchIssueCandidate(exec, repository, number, "Issue body explicitly references a duplicate target.")));
-    const raw = await exec(`gh search issues --repo ${shellQuote(repoSlug(repository))} --json number,title,url,state,body --limit ${limit} -- ${shellQuote(query)}`);
-    const data = JSON.parse(raw);
-    const candidates = new Map();
-    for (const candidate of explicitCandidates) {
-        if (candidate)
-            candidates.set(candidate.number, candidate);
-    }
-    for (const item of data
-        .filter((item) => item.number !== issue.number)
-        .map((item) => ({
-        ...item,
-        whyCandidate: "GitHub issue search matched the title.",
-    }))) {
-        if (!candidates.has(item.number))
-            candidates.set(item.number, item);
-    }
-    return [...candidates.values()].slice(0, limit);
-}
-export async function postIssueComment(exec, repository, issue, account, body) {
-    const token = await ghToken(exec, repository, account);
-    const payloadPath = join(tmpdir(), `magi-issue-${process.pid}-${Date.now()}.json`);
-    await writeFile(payloadPath, JSON.stringify({ body }));
-    try {
-        const raw = await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/issues/${issue}/comments --method POST --input ${shellQuote(payloadPath)} --jq '{id: .id, url: .html_url}'`, ghTokenEnv(token));
-        const data = JSON.parse(raw);
-        if (!data.id || !data.url)
-            throw new Error("GitHub issue comment response did not include id and url");
-        return { id: data.id, url: data.url };
-    }
-    finally {
-        await rm(payloadPath, { force: true });
-    }
-}
-export async function updateIssueComment(exec, repository, commentId, account, body) {
-    const token = await ghToken(exec, repository, account);
-    const payloadPath = join(tmpdir(), `magi-issue-comment-${process.pid}-${Date.now()}.json`);
-    await writeFile(payloadPath, JSON.stringify({ body }));
-    try {
-        const raw = await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/issues/comments/${commentId} --method PATCH --input ${shellQuote(payloadPath)} --jq '{id: .id, url: .html_url}'`, ghTokenEnv(token));
-        const data = JSON.parse(raw);
-        if (!data.id || !data.url)
-            throw new Error("GitHub issue comment response did not include id and url");
-        return { id: data.id, url: data.url };
-    }
-    finally {
-        await rm(payloadPath, { force: true });
-    }
-}
-export async function closeIssue(exec, repository, issue, account) {
-    const token = await ghToken(exec, repository, account);
-    return exec(`gh issue close ${issue} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));
-}
-export async function assignIssue(exec, repository, issue, account) {
-    const token = await ghToken(exec, repository, account);
-    return exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-assignee ${shellQuote(account)}`, ghTokenEnv(token));
-}
-export async function addIssueLabels(exec, repository, issue, labels, account) {
-    const token = await ghToken(exec, repository, account);
-    const added = [];
-    for (const label of labels) {
-        await exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --add-label ${shellQuote(label)}`, ghTokenEnv(token));
-        added.push(label);
-    }
-    return added;
-}
-export async function removeIssueLabels(exec, repository, issue, labels, account) {
-    const token = await ghToken(exec, repository, account);
-    const removed = [];
-    for (const label of labels) {
-        await exec(`gh issue edit ${issue} --repo ${shellQuote(repoSpecifier(repository))} --remove-label ${shellQuote(label)}`, ghTokenEnv(token));
-        removed.push(label);
-    }
-    return removed;
-}
-export async function fetchPullRequestReviews(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100, after: $cursor) { nodes { author { login } submittedAt state body commit { oid } comments(first: 100) { nodes { body path line startLine } } } pageInfo { hasNextPage endCursor } } } } }`;
-    const reviews = [];
-    let cursor;
-    for (;;) {
-        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
-        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
-        const data = JSON.parse(raw);
-        const connection = data.data.repository.pullRequest.reviews;
-        reviews.push(...connection.nodes);
-        if (!connection.pageInfo?.hasNextPage)
-            break;
-        cursor = connection.pageInfo.endCursor;
-        if (!cursor)
-            throw new Error("GitHub reviews page was truncated");
-    }
-    return reviews.map((review) => ({
-        ...review,
-        comments: review.comments?.nodes ?? [],
-    }));
-}
-export async function fetchPullRequestCommits(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100, after: $cursor) { nodes { commit { oid committedDate parents { totalCount } } } pageInfo { hasNextPage endCursor } } } } }`;
-    const commits = [];
-    let cursor;
-    for (;;) {
-        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
-        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
-        const data = JSON.parse(raw);
-        const connection = data.data.repository.pullRequest.commits;
-        commits.push(...connection.nodes);
-        if (!connection.pageInfo?.hasNextPage)
-            break;
-        cursor = connection.pageInfo.endCursor;
-        if (!cursor)
-            throw new Error("GitHub commits page was truncated");
-    }
-    return commits.map(({ commit }) => ({
-        committedDate: commit.committedDate,
-        oid: commit.oid,
-        parentCount: commit.parents.totalCount,
-    }));
-}
-export async function fetchPullRequestSafetyMeta(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { author { login } changedFiles labels(first: 100) { nodes { name } } files(first: 100, after: $filesCursor) { nodes { path } pageInfo { hasNextPage endCursor } } } } }`;
-    const files = [];
-    let author = "";
-    let changedFiles = 0;
-    let labels = [];
-    let cursor;
-    for (;;) {
-        const cursorFlag = cursor ? ` -F filesCursor=${shellQuote(cursor)}` : "";
-        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
-        const data = JSON.parse(raw);
-        const pullRequest = data.data.repository.pullRequest;
-        author = pullRequest.author?.login ?? author;
-        changedFiles = pullRequest.changedFiles;
-        labels = pullRequest.labels.nodes.map((label) => label.name);
-        files.push(...pullRequest.files.nodes.map((file) => file.path));
-        if (!pullRequest.files.pageInfo.hasNextPage)
-            break;
-        cursor = pullRequest.files.pageInfo.endCursor;
-        if (!cursor)
-            break;
-    }
-    return { author, changedFiles, files, labels };
-}
-export async function watchChecks(exec, repository, pr, options = {}) {
-    const requiredFlag = options.requiredOnly ? " --required" : "";
-    await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --watch${requiredFlag}`);
-}
-export function isCancelledCheck(check) {
-    return check.bucket === "cancel" || check.state === "CANCELLED";
-}
-export function isFailedCheck(check) {
-    return check.bucket === "fail" || check.state === "FAILURE";
-}
-export async function fetchPullRequestChecks(exec, repository, pr, options = {}) {
-    let raw;
-    const requiredFlag = options.requiredOnly ? " --required" : "";
-    try {
-        raw = await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json name,state,bucket,link,workflow${requiredFlag}`);
-    }
-    catch (error) {
-        if (options.tolerateMissingChecks &&
-            /no checks reported on the '.+' branch/i.test(errorText(error))) {
-            return [];
-        }
-        throw error;
-    }
-    return JSON.parse(raw);
-}
-export async function fetchWorkflowRunMeta(exec, repository, runId) {
-    const endpoint = `repos/${repository.github.owner}/${repository.github.repo}/actions/runs/${runId}`;
-    const raw = await exec(`gh api${ghHostOption(repository)} ${shellQuote(endpoint)}`);
-    const data = JSON.parse(raw);
-    return {
-        conclusion: data.conclusion,
-        headSha: data.head_sha ?? "",
-        status: data.status ?? "",
-    };
-}
-function excludedCheckMatcher(pattern) {
-    if (pattern.startsWith("/") && pattern.endsWith("/") && pattern.length > 1) {
-        const regex = new RegExp(pattern.slice(1, -1));
-        return (check) => regex.test(check.name);
-    }
-    return (check) => check.name === pattern;
-}
-export function applyCheckExclusions(input) {
-    if (!input.patterns.length)
-        return input.checks;
-    const matchers = input.patterns.map(excludedCheckMatcher);
-    const kept = [];
-    for (const check of input.checks) {
-        if (matchers.some((matcher) => matcher(check))) {
-            input.excluded.push(check);
-            continue;
-        }
-        kept.push(check);
-    }
-    return kept;
-}
-export function checkJobId(check) {
-    return check.link.match(/\/actions\/runs\/\d+\/job\/(\d+)/)?.[1];
-}
-export function checkRunId(check) {
-    return check.link.match(/\/actions\/runs\/(\d+)\/job\/\d+/)?.[1];
-}
-export async function rerunCheckJob(exec, repository, jobId) {
-    await exec(`gh run rerun --repo ${shellQuote(repoSpecifier(repository))} --job ${shellQuote(jobId)}`);
-}
-export async function watchRun(exec, repository, runId) {
-    await exec(`gh run watch ${shellQuote(runId)} --repo ${shellQuote(repoSpecifier(repository))} --exit-status`);
-}
-export async function fetchCheckFailureLog(exec, repository, jobId) {
-    return exec(`gh run view --repo ${shellQuote(repoSpecifier(repository))} --job ${shellQuote(jobId)} --log-failed`);
-}
-export async function fetchMergeQueueRequirement(exec, repository, branch) {
-    const raw = await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/rules/branches/${shellQuote(branch)} -H ${shellQuote("Accept: application/vnd.github+json")}`);
-    const rules = JSON.parse(raw);
-    return rules.some((rule) => rule.type === "merge_queue");
-}
-export async function createWorktree(exec, repository, pr, worktreePath) {
-    const lockKey = `${repoSpecifier(repository)}:${dirname(dirname(worktreePath))}`;
-    return withWorktreeCreateLock(lockKey, async () => {
-        let worktreeAdded = false;
-        try {
-            await mkdir(dirname(worktreePath), { recursive: true });
-            await exec(`git worktree add --detach ${shellQuote(worktreePath)}`);
-            worktreeAdded = true;
-            await checkoutPullRequestWithRetry(exec, repository, pr, worktreePath);
-            const branch = (await exec("git branch --show-current", { cwd: worktreePath })).trim();
-            return { branch: branch || undefined, path: worktreePath };
-        }
-        catch (error) {
-            if (worktreeAdded) {
-                await removeWorktree(exec, worktreePath).catch(() => undefined);
-            }
-            throw error;
-        }
-    });
-}
-export async function removeWorktree(exec, worktreePath) {
-    await exec(`git worktree remove --force ${shellQuote(worktreePath)}`);
-    await exec("git worktree prune");
-}
-export async function removeBranch(exec, branch) {
-    await exec(`git branch -D ${shellQuote(branch)}`);
-}
-export async function postApproval(exec, repository, pr, account, body) {
-    const token = await ghToken(exec, repository, account);
-    if (body != null) {
-        const payloadPath = join(tmpdir(), `magi-approve-${process.pid}-${Date.now()}.json`);
-        await writeFile(payloadPath, JSON.stringify({ body, event: "APPROVE" }));
-        try {
-            return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
-        }
-        finally {
-            await rm(payloadPath, { force: true });
-        }
-    }
-    return exec(`gh pr review ${pr} --repo ${shellQuote(repoSpecifier(repository))} --approve`, ghTokenEnv(token));
-}
-export async function postCloseComment(exec, repository, pr, account, body) {
-    const token = await ghToken(exec, repository, account);
-    const payloadPath = join(tmpdir(), `magi-close-${process.pid}-${Date.now()}.json`);
-    await writeFile(payloadPath, JSON.stringify({ body, event: "COMMENT" }));
-    try {
-        return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
-    }
-    finally {
-        await rm(payloadPath, { force: true });
-    }
-}
-function findingComment(finding, body) {
-    const comment = {
-        body: body ?? `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
-        line: finding.line,
-        path: finding.path,
-        side: "RIGHT",
-    };
-    if (finding.startLine != null) {
-        comment.start_line = finding.startLine;
-        comment.start_side = "RIGHT";
-    }
-    return comment;
-}
-function changesRequestedBody(findings) {
-    return findings.length === 1
-        ? "Changes requested: 1 inline comment."
-        : `Changes requested: ${findings.length} inline comments.`;
-}
-export async function postChangesRequested(exec, repository, pr, account, findings, options = {}) {
-    const token = await ghToken(exec, repository, account);
-    const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
-    const body = options.body ?? changesRequestedBody(findings);
-    await writeFile(payloadPath, JSON.stringify({
-        body,
-        comments: findings.map((finding, index) => findingComment(finding, options.commentBodies?.[index])),
-        event: "REQUEST_CHANGES",
-    }));
-    try {
-        return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
-    }
-    finally {
-        await rm(payloadPath, { force: true });
-    }
-}
-export async function mergePullRequest(exec, repository, pr, account) {
-    const token = await ghToken(exec, repository, account);
-    if (repository.merge.mergeQueue) {
-        const queueInput = await fetchPullRequestQueueInput(exec, repository, pr, token);
-        const query = `mutation($pullRequestId: ID!, $expectedHeadOid: GitObjectID!) { enqueuePullRequest(input: { pullRequestId: $pullRequestId, expectedHeadOid: $expectedHeadOid }) { mergeQueueEntry { id } } }`;
-        return exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F pullRequestId=${shellQuote(queueInput.id)} -F expectedHeadOid=${shellQuote(queueInput.headRefOid)} --jq .data.enqueuePullRequest.mergeQueueEntry.id`, ghTokenEnv(token));
-    }
-    const methodFlag = repository.merge.method === "merge"
-        ? "--merge"
-        : repository.merge.method === "rebase"
-            ? "--rebase"
-            : "--squash";
-    const autoFlag = repository.merge.auto ? " --auto" : "";
-    const deleteFlag = repository.merge.deleteBranch ? " --delete-branch" : "";
-    return exec(`gh pr merge ${pr} --repo ${shellQuote(repoSpecifier(repository))} ${methodFlag}${autoFlag}${deleteFlag}`, ghTokenEnv(token));
-}
-export async function fetchPullRequestMergeStatus(exec, repository, pr) {
-    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json state,mergeStateStatus,autoMergeRequest`);
-    return JSON.parse(json);
-}
-export async function fetchPullRequestQueueStatus(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { state isInMergeQueue mergeQueueEntry { id } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    const status = data.data?.repository?.pullRequest;
-    if (!status)
-        throw new Error(`Could not fetch merge queue status for #${pr}`);
-    return status;
-}
-export async function waitForMergeQueue(exec, repository, pr, intervalMs = 30_000) {
-    for (;;) {
-        const status = await fetchPullRequestQueueStatus(exec, repository, pr);
-        if (status.state === "MERGED")
-            return "merged";
-        if (status.state === "OPEN" &&
-            !status.isInMergeQueue &&
-            status.mergeQueueEntry == null) {
-            return "dequeued";
-        }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-}
-export async function waitForAutoMerge(exec, repository, pr, intervalMs = 30_000) {
-    for (;;) {
-        const status = await fetchPullRequestMergeStatus(exec, repository, pr);
-        if (status.state === "MERGED")
-            return "merged";
-        if (status.state !== "OPEN" || status.autoMergeRequest == null) {
-            return "dequeued";
-        }
-        await new Promise((resolve) => setTimeout(resolve, intervalMs));
-    }
-}
-export async function fetchBaseBranch(exec, repository, meta, worktreePath) {
-    await exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(repository, repository.github.owner, repository.github.repo))} ${shellQuote(`refs/heads/${meta.baseRefName}`)}`, { cwd: worktreePath });
-}
-export async function mergeBaseNoCommit(exec, baseSha, worktreePath) {
-    await exec(`git merge --no-commit --no-ff ${shellQuote(baseSha)}`, {
-        cwd: worktreePath,
-    }).catch(() => undefined);
-}
-export async function listUnmergedFiles(exec, worktreePath) {
-    const output = await exec("git diff --name-only --diff-filter=U", {
-        cwd: worktreePath,
-    });
-    return output
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean);
-}
-export async function abortMerge(exec, worktreePath) {
-    await exec("git merge --abort", { cwd: worktreePath }).catch(() => undefined);
-}
-export async function currentHeadSha(exec, worktreePath) {
-    return (await exec("git rev-parse HEAD", { cwd: worktreePath })).trim();
-}
-export async function closePullRequest(exec, repository, pr, account) {
-    const token = await ghToken(exec, repository, account);
-    return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));
-}
-export async function pushHead(exec, repository, worktreePath, account, head) {
-    const token = await ghToken(exec, repository, account);
-    const url = repositoryGitUrl(repository, head.owner, head.repo);
-    await exec(`git push ${shellQuote(url)} ${shellQuote(`HEAD:refs/heads/${head.ref}`)}`, {
-        cwd: worktreePath,
-        env: {
-            GIT_CONFIG_COUNT: "2",
-            GIT_CONFIG_KEY_0: "credential.helper",
-            GIT_CONFIG_KEY_1: "credential.helper",
-            GIT_CONFIG_VALUE_0: "",
-            GIT_CONFIG_VALUE_1: "!f() { echo username=x-access-token; echo password=$GIT_PASSWORD; }; f",
-            GIT_PASSWORD: token,
-            GIT_TERMINAL_PROMPT: "0",
-        },
-    });
-}
-export async function createPullRequest(exec, repository, account, input) {
-    const token = await ghToken(exec, repository, account);
-    const baseFlag = input.base ? ` --base ${shellQuote(input.base)}` : "";
-    return exec(`gh pr create --repo ${shellQuote(repoSpecifier(repository))} --head ${shellQuote(input.head)}${baseFlag} --title ${shellQuote(input.title)} --body ${shellQuote(input.body)}`, ghTokenEnv(token));
-}
-export async function configureGitIdentity(exec, worktreePath, identity) {
-    if (identity.name) {
-        await exec(`git config --worktree user.name ${shellQuote(identity.name)}`, {
-            cwd: worktreePath,
-        });
-    }
-    if (identity.email) {
-        await exec(`git config --worktree user.email ${shellQuote(identity.email)}`, {
-            cwd: worktreePath,
-        });
-    }
-}
-export async function fetchUnresolvedThreads(exec, repository, pr, author) {
-    const threadQuery = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100, after: $cursor) { nodes { id isResolved comments(first: 100) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } pageInfo { hasNextPage endCursor } } } } }`;
-    const commentQuery = `query($threadId: ID!, $cursor: String) { node(id: $threadId) { ... on PullRequestReviewThread { comments(first: 100, after: $cursor) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } } }`;
-    const threads = [];
-    let cursor;
-    async function fetchRemainingComments(threadId, initialCursor) {
-        const comments = [];
-        let commentsCursor = initialCursor;
-        for (;;) {
-            const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(commentQuery)} -F threadId=${shellQuote(threadId)} -F cursor=${shellQuote(commentsCursor)}`);
-            const data = JSON.parse(raw);
-            const connection = data.data.node?.comments;
-            if (!connection)
-                throw new Error("GitHub review thread comments were missing");
-            comments.push(...connection.nodes);
-            if (!connection.pageInfo?.hasNextPage)
-                break;
-            const nextCursor = connection.pageInfo.endCursor;
-            if (!nextCursor)
-                throw new Error("GitHub review thread comments page was truncated");
-            commentsCursor = nextCursor;
-        }
-        return comments;
-    }
-    for (;;) {
-        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
-        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(threadQuery)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
-        const data = JSON.parse(raw);
-        const connection = data.data.repository.pullRequest.reviewThreads;
-        for (const thread of connection.nodes) {
-            const commentsCursor = thread.comments.pageInfo?.endCursor;
-            if (thread.comments.pageInfo?.hasNextPage) {
-                if (!commentsCursor)
-                    throw new Error("GitHub review thread comments page was truncated");
-                thread.comments.nodes.push(...(await fetchRemainingComments(thread.id, commentsCursor)));
-            }
-        }
-        threads.push(...connection.nodes);
-        if (!connection.pageInfo?.hasNextPage)
-            break;
-        cursor = connection.pageInfo.endCursor;
-        if (!cursor)
-            throw new Error("GitHub review threads page was truncated");
-    }
-    return threads.flatMap((thread) => {
-        if (thread.isResolved || !thread.comments.nodes.length)
-            return [];
-        const comments = [...thread.comments.nodes]
-            .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
-            .map((comment) => ({
-            author: comment.author.login,
-            body: comment.body,
-            commentId: comment.databaseId,
-            createdAt: comment.createdAt,
-        }));
-        const first = thread.comments.nodes[0];
-        if (!author)
-            return [
-                {
-                    body: first.body,
-                    commentId: first.databaseId,
-                    comments,
-                    line: first.line,
-                    path: first.path,
-                    threadId: thread.id,
-                },
-            ];
-        if (first.author.login !== author)
-            return [];
-        const authored = thread.comments.nodes.filter((comment) => comment.author.login === author);
-        const latest = authored.sort((a, b) => a.createdAt.localeCompare(b.createdAt)).at(-1) ??
-            first;
-        return [
-            {
-                commentId: first.databaseId,
-                comments,
-                latestBody: latest.body,
-                line: first.line,
-                path: first.path,
-                threadId: thread.id,
-            },
-        ];
-    });
-}
-export async function fetchPullRequestReviewThreads(exec, repository, pr, threadLimit = 50, commentsPerThread = 20) {
-    return (await fetchPullRequestReviewThreadPage(exec, repository, pr, threadLimit, commentsPerThread)).threads;
-}
-export async function fetchPullRequestReviewThreadPage(exec, repository, pr, threadLimit = 50, commentsPerThread = 20) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $threadLimit: Int!, $commentsPerThread: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(last: $threadLimit) { totalCount nodes { id isResolved comments(last: $commentsPerThread) { totalCount nodes { databaseId author { login } path line body createdAt } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr} -F threadLimit=${threadLimit} -F commentsPerThread=${commentsPerThread}`);
-    const data = JSON.parse(raw);
-    const connection = data.data?.repository?.pullRequest?.reviewThreads;
-    const nodes = connection?.nodes ?? [];
-    const threads = nodes.flatMap((thread) => {
-        const comments = [...thread.comments.nodes]
-            .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
-            .map((comment) => ({
-            author: comment.author?.login ?? "",
-            body: comment.body ?? "",
-            commentId: comment.databaseId,
-            createdAt: comment.createdAt,
-        }));
-        const first = thread.comments.nodes[0];
-        if (!first)
-            return [];
-        return [
-            {
-                body: first.body ?? "",
-                commentId: first.databaseId,
-                comments,
-                isResolved: thread.isResolved,
-                line: first.line,
-                omittedComments: Math.max(0, (thread.comments.totalCount ?? comments.length) - comments.length),
-                path: first.path,
-                threadId: thread.id,
-            },
-        ];
-    });
-    return {
-        omitted: Math.max(0, (connection?.totalCount ?? threads.length) - threads.length),
-        threads,
-    };
-}
-export async function postReply(exec, repository, pr, account, commentId, body) {
-    const token = await ghToken(exec, repository, account);
-    const payloadPath = join(tmpdir(), `magi-reply-${process.pid}-${Date.now()}-${commentId}.json`);
-    await writeFile(payloadPath, JSON.stringify({ body }));
-    try {
-        return await exec(`gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/comments/${commentId}/replies --method POST --input ${shellQuote(payloadPath)} --jq .html_url`, ghTokenEnv(token));
-    }
-    finally {
-        await rm(payloadPath, { force: true });
-    }
-}
-export async function resolveThread(exec, repository, account, threadId) {
-    const token = await ghToken(exec, repository, account);
-    const query = `mutation($threadId: ID!) { resolveReviewThread(input: { threadId: $threadId }) { thread { id } } }`;
-    await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F threadId=${shellQuote(threadId)}`, ghTokenEnv(token));
-}