opencode-magi 0.2.0 → 0.4.0

package/dist/config/worktree.js

@@ -1,13 +1,19 @@
 import { isAbsolute, join } from "node:path";
 const DEFAULT_WORKTREE_DIRS = {
+    issue: ".magi/worktrees/issue",
     pr: ".magi/worktrees/pr",
 };
 function resolvePath(directory, path) {
     return isAbsolute(path) ? path : join(directory, path);
 }
 export function worktreeBaseDir(directory, config, kind) {
-    return resolvePath(directory, config.review?.worktree ?? DEFAULT_WORKTREE_DIRS[kind]);
+    return resolvePath(directory, kind === "issue"
+        ? (config.triage?.worktree ?? DEFAULT_WORKTREE_DIRS[kind])
+        : (config.review?.worktree ?? DEFAULT_WORKTREE_DIRS[kind]));
 }
 export function worktreeBaseDirs(directory, config = {}) {
-    return [worktreeBaseDir(directory, config, "pr")];
+    return [
+        worktreeBaseDir(directory, config, "pr"),
+        worktreeBaseDir(directory, config, "issue"),
+    ];
 }

package/dist/github/commands.js

@@ -1,6 +1,14 @@
 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();
@@ -80,10 +88,241 @@ export function ghHostOption(repository) {
 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,url,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner`);
+    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 } } } }`;
+    try {
+        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 graphqlIssue = data.data?.repository?.issue;
+        if (!graphqlIssue)
+            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,
+        };
+    }
+    catch {
+        return fetchIssueWithCli(exec, repository, issue);
+    }
+}
+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];
+}
+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 = issue.title;
+    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 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!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100) { nodes { author { login } submittedAt state body commit { oid } } } } } }`;
     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}`);
@@ -101,7 +340,7 @@ export async function fetchPullRequestCommits(exec, repository, pr) {
     }));
 }
 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 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;
@@ -162,8 +401,18 @@ export function isCancelledCheck(check) {
 export function isFailedCheck(check) {
     return check.bucket === "fail" || check.state === "FAILURE";
 }
-export async function fetchPullRequestChecks(exec, repository, pr) {
-    const raw = await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json name,state,bucket,link,workflow`);
+export async function fetchPullRequestChecks(exec, repository, pr, options = {}) {
+    let raw;
+    try {
+        raw = await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json name,state,bucket,link,workflow`);
+    }
+    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) {
@@ -247,19 +496,22 @@ export async function removeBranch(exec, branch) {
 }
 export async function postApproval(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
-    return exec(`GH_TOKEN=${shellQuote(token)} gh pr review ${pr} --repo ${shellQuote(repoSpecifier(repository))} --approve`);
+    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_TOKEN=${shellQuote(token)} gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`);
+        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 isInlineFinding(finding) {
+    return finding.line != null;
+}
 function findingComment(finding) {
     const comment = {
         body: `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
@@ -273,19 +525,58 @@ function findingComment(finding) {
     }
     return comment;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings) {
+function requirementFindingSummary(finding) {
+    return [
+        `- Missing issue #${finding.issueNumber} requirement: ${finding.requirement}`,
+        `  Evidence: ${finding.evidence}`,
+        `  Fix: ${finding.fix}`,
+    ].join("\n");
+}
+function findingLocation(finding) {
+    if (finding.line == null)
+        return finding.path;
+    if (finding.startLine == null)
+        return `${finding.path}:${finding.line}`;
+    return `${finding.path}:${finding.startLine}-${finding.line}`;
+}
+function findingSummary(finding) {
+    return [
+        `- ${findingLocation(finding)}: ${finding.issue}`,
+        `  Fix: ${finding.fix}`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function changesRequestedBody(findings, requirementFindings) {
+    const inlineFindings = findings.filter(isInlineFinding);
+    const fileLevelFindings = findings.filter((finding) => !isInlineFinding(finding));
+    const sections = [];
+    if (inlineFindings.length) {
+        sections.push(["Inline findings:", ...inlineFindings.map(findingSummary)].join("\n"));
+    }
+    if (fileLevelFindings.length) {
+        sections.push(["File-level findings:", ...fileLevelFindings.map(findingSummary)].join("\n"));
+    }
+    if (requirementFindings.length) {
+        sections.push([
+            "Requirement findings:",
+            ...requirementFindings.map(requirementFindingSummary),
+        ].join("\n"));
+    }
+    return sections.join("\n\n");
+}
+export async function postChangesRequested(exec, repository, pr, account, findings, requirementFindings = []) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
-    const body = findings
-        .map((finding) => `- ${finding.issue.split("\n")[0]}`)
-        .join("\n");
+    const inlineFindings = findings.filter(isInlineFinding);
+    const body = changesRequestedBody(findings, requirementFindings);
     await writeFile(payloadPath, JSON.stringify({
         body,
-        comments: findings.map(findingComment),
+        comments: inlineFindings.map(findingComment),
         event: "REQUEST_CHANGES",
     }));
     try {
-        return await exec(`GH_TOKEN=${shellQuote(token)} gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/reviews --method POST --input ${shellQuote(payloadPath)} --jq .html_url`);
+        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 });
@@ -293,6 +584,11 @@ export async function postChangesRequested(exec, repository, pr, account, findin
 }
 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"
@@ -300,18 +596,29 @@ export async function mergePullRequest(exec, repository, pr, account) {
             : "--squash";
     const autoFlag = repository.merge.auto ? " --auto" : "";
     const deleteFlag = repository.merge.deleteBranch ? " --delete-branch" : "";
-    return exec(`GH_TOKEN=${shellQuote(token)} gh pr merge ${pr} --repo ${shellQuote(repoSpecifier(repository))} ${methodFlag}${autoFlag}${deleteFlag}`);
+    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 fetchPullRequestMergeStatus(exec, repository, pr);
+        const status = await fetchPullRequestQueueStatus(exec, repository, pr);
         if (status.state === "MERGED")
             return "merged";
-        if (status.state === "OPEN" && status.autoMergeRequest == null) {
+        if (status.state === "OPEN" &&
+            !status.isInMergeQueue &&
+            status.mergeQueueEntry == null) {
             return "dequeued";
         }
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
@@ -319,12 +626,28 @@ export async function waitForMergeQueue(exec, repository, pr, intervalMs = 30_00
 }
 export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
-    return exec(`GH_TOKEN=${shellQuote(token)} gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`);
+    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 -c credential.helper= -c credential.helper=${shellQuote(`!f() { echo username=x-access-token; echo password=${token}; }; f`)} push ${shellQuote(url)} ${shellQuote(`HEAD:refs/heads/${head.ref}`)}`, { cwd: worktreePath });
+    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) {
@@ -384,12 +707,51 @@ export async function fetchUnresolvedThreads(exec, repository, pr, author) {
         ];
     });
 }
+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_TOKEN=${shellQuote(token)} gh api${ghHostOption(repository)} repos/${repository.github.owner}/${repository.github.repo}/pulls/${pr}/comments/${commentId}/replies --method POST --input ${shellQuote(payloadPath)} --jq .html_url`);
+        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 });
@@ -398,5 +760,5 @@ export async function postReply(exec, repository, pr, account, commentId, body)
 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_TOKEN=${shellQuote(token)} gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F threadId=${shellQuote(threadId)}`);
+    await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F threadId=${shellQuote(threadId)}`, ghTokenEnv(token));
 }