opencode-magi 0.0.0-dev-20260519011027

package/dist/github/commands.js

@@ -0,0 +1,398 @@
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+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 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))}`, {
+                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)}`;
+}
+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();
+}
+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`);
+    return JSON.parse(json);
+}
+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}`);
+    const data = JSON.parse(raw);
+    return data.data.repository.pullRequest.reviews.nodes;
+}
+export async function fetchPullRequestCommits(exec, repository, pr) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100) { nodes { commit { oid committedDate parents { totalCount } } } } } } }`;
+    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.commits.nodes.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 waitForChecks(exec, repository, pr, enabled = repository.checks.waitBeforeReview) {
+    if (!enabled)
+        return undefined;
+    const report = {
+        attempts: 0,
+        excluded: [],
+        failed: [],
+        rerun: [],
+        scopeInside: [],
+        scopeOutsideRecovered: [],
+        scopeOutsideUnresolved: [],
+    };
+    try {
+        await watchChecks(exec, repository, pr);
+        return report;
+    }
+    catch {
+        report.failed = applyCheckExclusions({
+            checks: await fetchFailedChecks(exec, repository, pr),
+            excluded: report.excluded,
+            patterns: repository.checks.exclude,
+        });
+        return report;
+    }
+}
+export async function watchChecks(exec, repository, pr) {
+    await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --watch`);
+}
+export async function fetchFailedChecks(exec, repository, pr) {
+    const checks = await fetchPullRequestChecks(exec, repository, pr);
+    return checks.filter((check) => isFailedCheck(check) || isCancelledCheck(check));
+}
+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) {
+    const raw = await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json name,state,bucket,link,workflow`);
+    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, root) {
+    const worktreePath = join(root, `pr-${pr}`);
+    const lockKey = `${repoSpecifier(repository)}:${root}`;
+    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) {
+    const token = await ghToken(exec, repository, account);
+    return exec(`GH_TOKEN=${shellQuote(token)} gh pr review ${pr} --repo ${shellQuote(repoSpecifier(repository))} --approve`);
+}
+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`);
+    }
+    finally {
+        await rm(payloadPath, { force: true });
+    }
+}
+function findingComment(finding) {
+    const comment = {
+        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;
+}
+export async function postChangesRequested(exec, repository, pr, account, findings) {
+    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");
+    await writeFile(payloadPath, JSON.stringify({
+        body,
+        comments: findings.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`);
+    }
+    finally {
+        await rm(payloadPath, { force: true });
+    }
+}
+export async function mergePullRequest(exec, repository, pr, account) {
+    const token = await ghToken(exec, repository, account);
+    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_TOKEN=${shellQuote(token)} gh pr merge ${pr} --repo ${shellQuote(repoSpecifier(repository))} ${methodFlag}${autoFlag}${deleteFlag}`);
+}
+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 waitForMergeQueue(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 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))}`);
+}
+export async function pushHead(exec, repository, worktreePath, account) {
+    const token = await ghToken(exec, repository, account);
+    await exec(`git -c credential.helper= -c credential.helper=${shellQuote(`!f() { echo username=x-access-token; echo password=${token}; }; f`)} push origin HEAD`, { cwd: worktreePath });
+}
+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 query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 50) { 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}`);
+    const data = JSON.parse(raw);
+    const threads = data.data.repository.pullRequest.reviewThreads
+        .nodes;
+    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 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`);
+    }
+    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_TOKEN=${shellQuote(token)} gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F threadId=${shellQuote(threadId)}`);
+}

package/dist/github/retry.js

@@ -0,0 +1,44 @@
+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 isGitHubCommand(command) {
+    return /(^|\s)gh\s+(api|auth|pr|run)\b/.test(command);
+}
+function isRateLimitError(error) {
+    return /rate limit/i.test(errorText(error));
+}
+async function delay(ms, signal) {
+    if (ms <= 0)
+        return;
+    if (signal?.aborted)
+        throw new DOMException("Aborted", "AbortError");
+    await new Promise((resolve, reject) => {
+        const timeout = setTimeout(resolve, ms);
+        signal?.addEventListener("abort", () => {
+            clearTimeout(timeout);
+            reject(new DOMException("Aborted", "AbortError"));
+        }, { once: true });
+    });
+}
+export function withGitHubApiRetry(exec, retryAttempts, delayMs = 1_000) {
+    return async (command, options) => {
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                return await exec(command, options);
+            }
+            catch (error) {
+                if (attempt >= retryAttempts ||
+                    !isGitHubCommand(command) ||
+                    !isRateLimitError(error)) {
+                    throw error;
+                }
+                await delay(delayMs * 2 ** attempt, options?.signal);
+            }
+        }
+    };
+}